C# .NET 逻辑层的框架设计

　　前述：在我的了解中，一个大项目的逻辑层是不可捉摸的，对于不同项目或场景都是不同的逻辑。先说明，我的想法是对逻辑层类结构，以及如何操作逻辑的方法进行抽象的封装。并且考虑将不同类，或者不同程序集中的逻辑方法，全都可以归于一个类中控制和使用，并使用链式将它完成。是不是听起来很不可思议。

　　之所以这样思考封装，首先是考虑到类间解耦：像很多解耦的框架，虽然能够起到解耦作用，但我觉得它只是降低类间的调用，但是也没有真正意义上的解耦，因为操作方法还是需要UI层中。

　　比如：一个支付功能。

　　在我之前做的项目中它需要经过这么多步骤（细分会更多）：

　　　　1、判断有没有登录

　　　　2、用户选择收获地址

　　　　3、判断商品是否充足

　　　　4、判断余额是否充足

　　　　5、更新数据

　　在我之前做项目时候，因为赶时间所以没什么讲究，毕竟在学校只要能够执行成功就行，所以如果调用类，就会在里面new一大堆的bll类。这样，就使得UI层很累赘，并且需要一个一个调用他们的方法，判断一大堆，然后并且还需要对每一个判断，如果失败，还得提示失败给用户。这样UI层显得很累赘，这就是要思考我对我框架思考的主要原因。我觉得在框架中，并没有真正的做到解耦，是因为下面还需要用到方法，这样就使得方法直接在UI中操作。

　　我认为，一个逻辑层的框架，不仅要对类间解耦，更重要的应该是如何控制逻辑操作，每个方法只实现一个功能，在UI层对它进行组装，并且组装时候，使用者不需要知道每个逻辑的结果，只需要知道整体返回的结果，根据这个结果来判断操作结果；除了类似支付这样判断的方法，逻辑层大部分还在查询数据的，因此，框架类中还提供能够支撑逻辑层返回数据的方法；最后，因为现在还有部分功能是写在特性上，比如权限控制等，为了开发者的便利，写逻辑的程序员应该只需要考虑怎么实现一个逻辑功能，而逻辑功能放在哪里用，需要框架来定义。

　　好了，说了自己的看法，来看下框架的使用方式：例如，支付功能。

　　支付功能中，判断用户是否登录在MethodTest类中的Login方法，只是简单的判断；支付功能又在另一个类中，MethodTest，对用户的余额判断，看下框架是如何使用：

public class Admin
{
public string ID
{
get;
set;
}
public int Count
{
get;
set;
}
public string Pwd
{
get;
set;
}
}

public class MethodTest
{
public bool Login(Admin admin)
{
if (admin.ID == "admin" && admin.Pwd == "123456")
return true;
else
return false;
}
}

public class MethodTest1
{
public bool Pay(Admin admin)
{
if (admin.Count > 100)
return true;
else
return false;
}
}

下面是实例方法：

static void Main(string[] args)
{
IComMethod method = BllHelper.getMethod<TMethod>();

method.setInstance<MethodTest>();
method.setInstance<MethodTest1>();

Admin admin = new Admin()
{
ID = "admin",
Pwd = "123456",
Count = 200
};

Msg result = method.GMethod<MethodTest>((test, me, msg) =>
{
msg.setFailMsg("登录失败");
msg.setSuccessMsg("登录成功");
return test.Login(admin);
})
.GMethod<MethodTest1>((test, me, msg) =>
{
msg.setSuccessMsg("支付成功");
msg.setFailMsg("支付失败");
return test.Pay(admin);
}).getResult();

if(result.State)
{
Console.WriteLine(result.getSuccessMsg());
}else
{
Console.WriteLine(result.getFailMsg());
}
}

没有了new实例，原来如果一个判断应该给用户一个提示，使用链式控制，在最后获得的result里面就存放着操作是否成功的信息。

当用户名或者密码错误时候，它运行是这样的：



下面支付功能就不会执行。

如果账号密码正确，而账户余额不足时候，运行结果：



只有当账户跟余额充足下，才能执行成功，而在中间，都不要额外的判断，也没有创建实例，就能够轻松的把逻辑功能联系起来。



当然，框架里还有别的功能，比如带参数的构造，特性过滤器，以及使用者来创建对象，都可以利用这个框架；整个框架最主要的功能还是类似上边的，链式组合，并且在框架中提供了两种不同的形式：第一种像上边支付功能，上下是有联系的，第二种是上下无关的，也就是上边操作跟下边操作没有影响。这样看我设计的框架，是不是十分的灵活，并且把所有原来在UI处理的事情，都可以放在Bll层中解决，解决了逻辑层与UI层间的耦合，而且，还可以分开的设计逻辑方法，放在Bll中，而不需要对每个方法进行考虑要如何使用组合。

那么接下来就分析下这个框架的设计思路：

　　框架最主要有创建对象类(CreateInstance)、组合功能类(IComMethod 和实现该接口的TMethod、DMethod)、过滤器特性类(FilterAttribute)、帮助类(BllHelper)，额外的类就不写里面了。

CreateInstance就是用来创建对象，比较简单。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Bll
{
class CreateInstance
{
public static TClass createInstance<TClass>()
where TClass : class,new()
{
return new TClass();
}

public static TClass createInstance<TClass>(object[] args)
where TClass : class
{
Type type = typeof(TClass);
TClass c = null;
c = Activator.CreateInstance(type, args) as TClass;
return c;
}

public static TBaseClass createInstance<TBaseClass, TSubClass>()
where TSubClass : class,new()
where TBaseClass : class
{
return new TSubClass() as TBaseClass;
}

public static TBaseClass createInstance<TBaseClass, TSubClass>(object[] args)
where TBaseClass : class
where TSubClass : class
{
Type type = typeof(TSubClass);
TBaseClass c = null;
c = Activator.CreateInstance(type, args) as TBaseClass;
return c;
}
}
}

最主要的是组合功能的类，在使用的时候，这里面才存放着实例后的对象，并以委托的形式，暴露给外部使用。里面包含有将要使用的类实例化到这个对象内，其实是要使用这些对象的Method方法；考虑到有些方法可能只用一次，所以下边还封装了只使用一次的对应Method方法。TMethod 和 DMethod就是实现接口，他们的区别就是一个上边跟下边执行时有联系的，另一个是无关联的。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Bll
{
public interface IComMethod
{
IComMethod setInstance<TClass>()
where TClass : class,new();
IComMethod setInstance<TClass>(object[] args)
where TClass : class;
IComMethod setInstance<TBaseClass, TSubClass>()
where TSubClass : class,new()
where TBaseClass : class;
IComMethod setInstance<TBaseClass, TSubClass>(object[] args)
where TSubClass : class
where TBaseClass : class;

IComMethod GMethod<TClass>(Func<TClass, IComMethod, IMsg, bool> fun)
where TClass : class;

TResult GMethod<TClass, TResult>(Func<TClass, IComMethod, IMsg, TResult> fun)
where TClass : class;

IComMethod Method<TClass>(Func<TClass, IComMethod, IMsg, bool> fun)
where TClass : class,new();
IComMethod Method<TClass>(object[] args, Func<TClass, IComMethod, IMsg, bool> fun)
where TClass : class;
IComMethod Method<TBaseClass, TSubClass>(Func<TBaseClass, IComMethod, IMsg, bool> fun)
where TBaseClass : class
where TSubClass : class,new();
IComMethod Method<TBaseClass, TSubClass>(object[] args, Func<TBaseClass, IComMethod, IMsg, bool> fun)
where TBaseClass : class
where TSubClass : class;
TResult Method<TClass, TResult>(Func<TClass, IComMethod, IMsg, TResult> fun)
where TClass : class,new();
TResult Method<TClass, TResult>(object[] args, Func<TClass, IComMethod, IMsg, TResult> fun)
where TClass : class;
TResult Method<TBaseClass, TSubClass, TResult>(Func<TBaseClass, IComMethod, IMsg, TResult> fun)
where TBaseClass : class
where TSubClass : class,new();
TResult Method<TBaseClass, TSubClass, TResult>(object[] args, Func<TBaseClass, IComMethod, IMsg, TResult> fun)
where TBaseClass : class
where TSubClass : class;

Msg getResult();
}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Bll
{
public class DMethod:IComMethod
{
private Dictionary<string, object> bllmodule = new Dictionary<string, object>();
private List<Msg> msglist = new List<Msg>();
private int top = -1;
public IComMethod setInstance<TClass>() where TClass : class, new()
{
Type t = typeof(TClass);
TClass c = CreateInstance.createInstance<TClass>();
bllmodule.Add(t.Name, c);
return this;
}

public IComMethod setInstance<TClass>(object[] args) where TClass : class
{
Type t = typeof(TClass);
TClass c = CreateInstance.createInstance<TClass>(args);
bllmodule.Add(t.Name, c);
return this;
}

public IComMethod setInstance<TBaseClass, TSubClass>()
where TBaseClass : class
where TSubClass : class, new()
{
Type t = typeof(TBaseClass);
Type t1 = typeof(TSubClass);
TBaseClass c = CreateInstance.createInstance<TBaseClass, TSubClass>();
bllmodule.Add(t.Name + "." + t1.Name, c);
return this;
}

public IComMethod setInstance<TBaseClass, TSubClass>(object[] args)
where TBaseClass : class
where TSubClass : class
{
Type t = typeof(TBaseClass);
Type t1 = typeof(TSubClass);
if (bllmodule.ContainsKey(t.Name + "." + t1.Name))
return this;
TBaseClass c = CreateInstance.createInstance<TBaseClass, TSubClass>(args);
bllmodule.Add(t.Name + "." + t1.Name, c);
return this;
}

public IComMethod GMethod<TClass>(Func<TClass, IComMethod, IMsg, bool> fun) where TClass : class
{
Type t = typeof(TClass);
if (!bllmodule.ContainsKey(t.Name))
return this;
TClass c = bllmodule[t.Name] as TClass;
Msg msg = new Msg();
msg.State = fun(c, this, msg);
msglist.Add(msg);
top++;
return this;
}

public TResult GMethod<TClass, TResult>(Func<TClass, IComMethod, IMsg, TResult> fun) where TClass : class
{
Type t = typeof(TClass);
if (!bllmodule.ContainsKey(t.Name))
return default(TResult);
TClass c = bllmodule[t.Name] as TClass;
return getResult(c, fun);
}

public IComMethod Method<TClass>(Func<TClass, IComMethod, IMsg, bool> fun) where TClass : class, new()
{
TClass c = CreateInstance.createInstance<TClass>();
Msg msg = new Msg();
msg.State = fun(c, this, msg);
msglist.Add(msg);
top++;
return this;
}

public IComMethod Method<TClass>(object[] args, Func<TClass, IComMethod, IMsg, bool> fun) where TClass : class
{
TClass c = CreateInstance.createInstance<TClass>(args);
Msg msg = new Msg();
msg.State = fun(c, this, msg);
msglist.Add(msg);
top++;
return this;
}

public IComMethod Method<TBaseClass, TSubClass>(Func<TBaseClass, IComMethod, IMsg, bool> fun)
where TBaseClass : class
where TSubClass : class,new()
{
TBaseClass c = CreateInstance.createInstance<TBaseClass, TSubClass>();
Msg msg = new Msg();
msg.State = fun(c, this, msg);
msglist.Add(msg);
top++;
return this;
}

public IComMethod Method<TBaseClass, TSubClass>(object[] args, Func<TBaseClass, IComMethod, IMsg, bool> fun)
where TBaseClass : class
where TSubClass : class
{
TBaseClass c = CreateInstance.createInstance<TBaseClass, TSubClass>(args);
Msg msg = new Msg();
msg.State = fun(c, this, msg);
msglist.Add(msg);
top++;
return this;
}

public TResult Method<TClass, TResult>(Func<TClass, IComMethod, IMsg, TResult> fun) where TClass : class, new()
{
TClass c = CreateInstance.createInstance<TClass>();
return getResult(c, fun);
}

public TResult Method<TClass, TResult>(object[] args, Func<TClass, IComMethod, IMsg, TResult> fun) where TClass : class
{
TClass c = CreateInstance.createInstance<TClass>(args);
return getResult(c, fun);
}

public TResult Method<TBaseClass, TSubClass, TResult>(Func<TBaseClass, IComMethod, IMsg, TResult> fun)
where TBaseClass : class
where TSubClass : class,new()
{
TBaseClass c = CreateInstance.createInstance<TBaseClass, TSubClass>();

return getResult(c, fun);
}

public TResult Method<TBaseClass, TSubClass, TResult>(object[] args, Func<TBaseClass, IComMethod, IMsg, TResult> fun)
where TBaseClass : class
where TSubClass : class
{
TBaseClass c = CreateInstance.createInstance<TBaseClass, TSubClass>(args);

return getResult(c, fun);
}

TResult getResult<TClass, TResult>(TClass c, Func<TClass, IComMethod, IMsg, TResult> fun)
{
Msg msg = new Msg();
TResult result = fun(c, this, msg);
if (result != null)
msg.State = true;
msglist.Add(msg);
top++;
return result;
}

public Msg getResult()
{
return this.msglist[top];
}
}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Bll
{
public class TMethod : IComMethod
{
private Dictionary<string, object> bllmodule = new Dictionary<string, object>();
private List<Msg> msglist = new List<Msg>();
private int top = -1;
public IComMethod setInstance<TClass>() where TClass : class, new()
{
Type t = typeof(TClass);
TClass c = CreateInstance.createInstance<TClass>();
bllmodule.Add(t.Name, c);
return this;
}

public IComMethod setInstance<TClass>(object[] args) where TClass : class
{
Type t = typeof(TClass);
TClass c = CreateInstance.createInstance<TClass>(args);
bllmodule.Add(t.Name, c);
return this;
}

public IComMethod setInstance<TBaseClass, TSubClass>()
where TBaseClass : class
where TSubClass : class, new()
{
Type t = typeof(TBaseClass);
Type t1 = typeof(TSubClass);
TBaseClass c = CreateInstance.createInstance<TBaseClass, TSubClass>();
bllmodule.Add(t.Name + "." + t1.Name, c);
return this;
}

public IComMethod setInstance<TBaseClass, TSubClass>(object[] args)
where TBaseClass : class
where TSubClass : class
{
Type t = typeof(TBaseClass);
Type t1 = typeof(TSubClass);
if (bllmodule.ContainsKey(t.Name + "." + t1.Name))
return this;
TBaseClass c = CreateInstance.createInstance<TBaseClass, TSubClass>(args);
bllmodule.Add(t.Name + "." + t1.Name, c);
return this;
}

public IComMethod GMethod<TClass>(Func<TClass, IComMethod, IMsg, bool> fun) where TClass : class
{
if (top != -1 && msglist[top].State == false)
return this;
Type t = typeof(TClass);
if (!bllmodule.ContainsKey(t.Name))
return this;
TClass c = bllmodule[t.Name] as TClass;
Msg msg = new Msg();
msg.State = fun(c, this, msg);
msglist.Add(msg);
top++;
return this;
}

public TResult GMethod<TClass, TResult>(Func<TClass, IComMethod, IMsg, TResult> fun) where TClass : class
{
if (top != -1 && msglist[top].State == false)
return default(TResult);
Type t = typeof(TClass);
if (!bllmodule.ContainsKey(t.Name))
return default(TResult);
TClass c = bllmodule[t.Name] as TClass;
return getResult(c, fun);
}

public IComMethod Method<TClass>(Func<TClass, IComMethod, IMsg, bool> fun) where TClass : class, new()
{
if (top != -1 && msglist[top].State == false)
return this;
TClass c = CreateInstance.createInstance<TClass>();
Msg msg = new Msg();
msg.State = fun(c,this, msg);
msglist.Add(msg);
top++;
return this;
}

public IComMethod Method<TClass>(object[] args, Func<TClass, IComMethod, IMsg, bool> fun) where TClass : class
{
if (top != -1 && msglist[top].State == false)
return this;
TClass c = CreateInstance.createInstance<TClass>(args);
Msg msg = new Msg();
msg.State = fun(c, this, msg);
msglist.Add(msg);
top++;
return this;
}

public IComMethod Method<TBaseClass, TSubClass>(Func<TBaseClass, IComMethod, IMsg, bool> fun)
where TBaseClass : class
where TSubClass : class,new()
{
if (top != -1 && msglist[top].State == false)
return this;
TBaseClass c = CreateInstance.createInstance<TBaseClass, TSubClass>();
Msg msg = new Msg();
msg.State = fun(c, this, msg);
msglist.Add(msg);
top++;
return this;
}

public IComMethod Method<TBaseClass, TSubClass>(object[] args, Func<TBaseClass, IComMethod, IMsg, bool> fun)
where TBaseClass : class
where TSubClass : class
{
if (top != -1 && msglist[top].State == false)
return this;
TBaseClass c = CreateInstance.createInstance<TBaseClass, TSubClass>(args);
Msg msg = new Msg();
msg.State = fun(c, this, msg);
msglist.Add(msg);
top++;
return this;
}

public TResult Method<TClass, TResult>(Func<TClass, IComMethod, IMsg, TResult> fun) where TClass : class, new()
{
if (top != -1 && msglist[top].State == false)
return default(TResult);
TClass c = CreateInstance.createInstance<TClass>();
return getResult(c, fun);
}

public TResult Method<TClass, TResult>(object[] args, Func<TClass, IComMethod, IMsg, TResult> fun) where TClass : class
{
if (top != -1 && msglist[top].State == false)
return default(TResult);
TClass c = CreateInstance.createInstance<TClass>(args);
return getResult(c, fun);
}

public TResult Method<TBaseClass, TSubClass, TResult>(Func<TBaseClass, IComMethod, IMsg, TResult> fun)
where TBaseClass : class
where TSubClass : class,new()
{
if (top != -1 && msglist[top].State == false)
return default(TResult);
TBaseClass c = CreateInstance.createInstance<TBaseClass, TSubClass>();

return getResult(c, fun);
}

public TResult Method<TBaseClass, TSubClass, TResult>(object[] args, Func<TBaseClass, IComMethod, IMsg, TResult> fun)
where TBaseClass : class
where TSubClass : class
{
if (top != -1 && msglist[top].State == false)
return default(TResult);
TBaseClass c = CreateInstance.createInstance<TBaseClass, TSubClass>(args);

return getResult(c, fun);
}

TResult getResult<TClass, TResult>(TClass c, Func<TClass, IComMethod, IMsg, TResult> fun)
{
Msg msg = new Msg();
TResult result = fun(c, this, msg);
if (result != null)
msg.State = true;
msglist.Add(msg);
top++;
return result;
}

public Msg getResult()
{
return this.msglist[top];
}
}
}

最后是实现过滤器部分，过滤器也是使用委托，将委托里面的方法放在一个池中，使用字典，将他们对应，在使用特性时候，就可以将对应方法的key写在特性上就可以了。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Bll
{
public class FilterAttribute:Attribute
{
public FilterAttribute(string key)
{
Action fun = FilterPool.DelegatePool[key];
if (fun != null)
fun();
}
}
}

最后一个Bllhelper类，里面存放静态方法，用于创建对象，UI层不能访问CreateInstance，只能通过它；一个特殊的静态函数，就是在应用开始时候将需要的过滤器填充到里面。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Bll
{
public class BllHelper
{
public static TClass createInstance<TClass>()
where TClass : class,new()
{
return CreateInstance.createInstance<TClass>();
}
public static TClass createInstance<TClass>(object[] args)
where TClass : class
{
return CreateInstance.createInstance<TClass>(args);
}
public static TBaseClass createInstance<TBaseClass, TSubClass>()
where TSubClass : class,new()
where TBaseClass : class
{
return CreateInstance.createInstance<TBaseClass, TSubClass>();
}
public static TBaseClass createInstance<TBaseClass, TSubClass>(object[] args)
where TBaseClass : class
where TSubClass : class
{
return CreateInstance.createInstance<TBaseClass, TSubClass>(args);
}

public static void setFilter(string key,Action fun)
{
FilterPool.DelegatePool.Add(key, fun);
}

public static IComMethod getMethod<T>()
where T:class,new()
{
return createInstance<IComMethod, T>();
}
}
}

好了，基本思路就这样。

项目地址链接:http://files.cnblogs.com/files/jnxzk/Work18.rar

不过，这个项目还没完工，因为还有好多没有考虑进去。是一时想法一时写的代码，所以就没有注释。项目能够正常使用，如果大家有什么不理解的地方，或者不足，可以下边评论，谢谢大家~~