EF5中使用UnitOfWork
前言
每次提交数据库都会打开一个连接，造成结果是：多个连接无法共用一个数据库级别的事务，也就无法保证数据的原子性、一致性。
解决办法是：在ObjectContext的CRUD操作基础上再包装一层，提供统一的入口，让服务层调用。
同一个UnitOfWork实例对象下所有的ObjectContext都共同一个数据库上下文对象（ps：EF用的是ObjectContext），也就是共用一个事物。
提交数据库时，只要有一个操作失败，那么所有的操作都被视为失败。
代码托管：https://github.com/catbiscuit/MT
实现过程
实体层
数据访问层
T_Log表示例
IDAL层
直接继承IRepository<T>泛型接口，其中定义了一些基础的方法。
namespace MT.Business.IDAL.SystemManage { public interface IT_LogDAL : IRepository<T_Log> { } }
DAL层
直接继承Repository<T>类，和IT_LogDAL接口。
Repository类，需要提供实体类和数据库上下文。因为需要创建一个统一管理数据库操作的对象。
namespace MT.Business.DAL.SystemManage { public class T_LogDAL : Repository<T_Log, MTEntities>, IT_LogDAL { public T_LogDAL(IDatabaseFactory<MTEntities> iDatabaseFactory) : base(iDatabaseFactory) { } } }
IBLL层
定义基本的数据操作方法。
namespace MT.Business.IBLL.SystemManage { public interface IT_LogBLL { int Insert(T_Log entity); int Delete(T_Log entity); int Update(); int Insert(List<T_Log> lstEntity); T_Log GetModelByCondition(Expression<Func<T_Log, bool>> condition); } }
BLL
对IT_LogBLL接口中方法的实现。
namespace MT.Business.BLL.SystemManage { public class T_LogBLL : IT_LogBLL { private IUnitOfWork<MTEntities> _iUnitOfWork; private IT_LogDAL _iT_LogDAL; public T_LogBLL(IUnitOfWork<MTEntities> iUnitOfWork , IT_LogDAL iT_LogDAL) { this._iUnitOfWork = iUnitOfWork; this._iT_LogDAL = iT_LogDAL; } public int Insert(T_Log entity) { _iT_LogDAL.Insert(entity); return _iUnitOfWork.Commit(); } public int Delete(T_Log entity) { _iT_LogDAL.Delete(entity); return _iUnitOfWork.Commit(); } public int Update() { return _iUnitOfWork.Commit(); } public int Insert(List<T_Log> lstEntity) { foreach (var item in lstEntity) { _iT_LogDAL.Insert(item); } return _iUnitOfWork.Commit(); } public T_Log GetModelByCondition(Expression<Func<T_Log, bool>> condition) { return _iT_LogDAL.GetModelByCondition(condition); } } }
注意
第一：类中定义了一个IUnitOfWork泛型对象，这个就是单元事务的管理对象。
DAL层只是将对数据的操作，添加到一个数据缓存的集合中。
当数据操作的步骤完成时，才调用IUnitOfWork泛型对象进行数据操作的提交。
这样确保了原子性和一致性。
第二：Update操作，BLL并没有将数据的操作添加到数据缓存的集合中。
此处，可以通过单步调试，当执行到UnitOfWork类中时，
监视DbContext对象的值，这个对象会监视数据库上下文中数据的状态。
这个地方，就要求Update操作的对象只能是从数据库获取得来。
使用lambda表达式获取实体。
示例操作：
Model model = DAL.GetModel(2);
model.Name = "修改Name";
BLL.Update();
此时BLL层执行update方法，实际上只是执行了单元事务的提交，也就完成了对该条记录的修改。
但是，如果是实例化的对象是无法修改数据。
Model model = new Model();
model.ID = 2;
model.Name = "修改Name";
BLL.Update();
这样执行更新操作，是无法修改数据的
总结
思路
DAL层，只是将数据的操作(新增修改删除)附加到数据库上下文中。
UnitOfWork，才是将数据进行提交的地方。
所以，BLL层的方法才是实现对数据的完成操作。
使用工作单元的思路
a.DatabaseFactory类的使用。确保一次业务中每一个线程使用的数据库上下文对象是同一个。
Web中每一次HTTP请求，都会开启一个新的线程。
我们要保证在这个线程中，所有的数据库操作都提交到了同一个数据库上下文对象中。
在一次业务操作时，所使用的数据库上下文对象都由DatabaseFactory实例化。
b.DAL层中的Repository类。将一次业务操作中的数据库实体增删改实体附加到从DatabaseFactory中获取到的数据库上下文中。
Repository类的构造函数，就要求传递数DatabaseFactory的对象。
Repository类中使用的数据库上下文对象，从DatabaseFactory获取。
c.BLL层中的UnitOfWork类。将一次业务操作中的数据库上下文操作提交到数据库中。
UnitOfWork类中使用的数据库上下文对象，从DatabaseFactory获取。
调用各个表DAL层对象，将增删改的操作附加到从DatabaseFactory类获取到的数据库上下文对象中。
最终调用UnitOfWork类的Commit();方法，将所有的数据操作提交到数据库中去。
关键点
a.同一个业务操作时，不同表操作时使用的数据库上下文必须是同一个，保证数据提交的完整性。
b.将数据库附加放在DAL层，数据的提交放在BLL层。
关于每一次HTTP请求中数据库上下文对象的获取问题
问题
在网上看到了，每一次HTTP请求都会开启一个新的线程，这句话不理解是什么意思，就直接照着这个思路来。
但是，总感觉有什么问题，于是今天做了测试。
在HomeController控制器中，
在Index方法中，获取实体，修改属性值，但是不调用BLL层，也就是仅附加不提交。
在Add方法中，获取实体，修改属性值，之后调用BLL层，附加且提交。
经过测试，发现了问题
执行了Index方法，F_isValid++; ，数据库中记录的值并不会改变。
但是当执行了Add方法后，F_isValid++;，数据库中记录的值会发生改变，但是F_isValid自增了两次。
有问题，然后继续测试。执行了三次Index方法，再执行一次Add方法，数据库中记录的值自增了四次。
调试发现，自从程序运行后，DatabaseFactory类中的private T _dbcontext; 一直存在。也就是整个程序周期内，这个示例是共享的。
于是有两个问题。
(1)在一个HTTP周期内，使用的数据库上下文对象应该是同一个。
(2)在一个HTTP周期结束后，使用的数据库上下文对象应该被销毁(回收)。
public class HomeController: Controller { private readonly IT_LogBLL _iT_LogBLL; public HomeController(IT_LogBLL iT_LogBLL) { this._iT_LogBLL = iT_LogBLL; } public ActionResult Index() { T_Log model2 = new T_Log(); model2 = _iT_LogBLL.GetModelByCondition(x => x.F_isValid > 0); model2.F_isValid++; //_iT_LogBLL.Update(); return View(); } public ActionResult Add() { T_Log model2 = new T_Log(); model2 = _iT_LogBLL.GetModelByCondition(x => x.F_isValid > 0); model2.F_isValid++; _iT_LogBLL.Update(); return View(); } }
解决
(1)在一个HTTP周期内，使用的数据库上下文对象应该是同一个。---Autofac配置格式
想起Autofac中，有实例生命周期的设置。
地址：https://www.cnblogs.com/masonblog/p/9584299.html
又寻找到配置格式：
builder.RegisterType<OpenIdRelyingPartyService>().As<IOpenIdRelyingPartyService>().InstancePerHttpRequest();
基于线程或者Context上下文的请求，返回一个单例实例，在Controller的一个View页面执行时包含了整个Context上下文处理.
地址：https://www.cnblogs.com/xiaoweinet/archive/2014/01/09/3512255.html
(2)在一个HTTP周期结束后，使用的数据库上下文对象应该被销毁(回收)。---IDisposable回收
参照网上大神的设置，对DatabaseFactory 资源的回收。
地址：https://www.cnblogs.com/tiancai/p/6612444.html
测试
(1)、InstancePerDependency
builder.RegisterGeneric(typeof(DatabaseFactory<>)).As(typeof(IDatabaseFactory<>)).InstancePerDependency();
每次获取DatabaseFactory类都是新的实体，
数据无法添加。
(2)、InstancePerLifetimeScope
builder.RegisterGeneric(typeof(DatabaseFactory<>)).As(typeof(IDatabaseFactory<>)).InstancePerLifetimeScope();
每次获取DatabaseFactory类都是新的实体，
数据无法添加。
(3)、InstancePerMatchingLifetimeScope
builder.RegisterGeneric(typeof(DatabaseFactory<>)).As(typeof(IDatabaseFactory<>)).InstancePerMatchingLifetimeScope();
No
scope with a Tag matching '' is visible from the scope in which the
instance was requested. This generally indicates that a component
registered as per-HTTP request is being requested by a SingleInstance()
component (or a similar scenario.) Under the web integration always
request dependencies from the DependencyResolver.Current or
ILifetimeScopeProvider.RequestLifetime, never from the container itself.
报错，程序无法运行。
(4)、InstancePerOwned
builder.RegisterGeneric(typeof(DatabaseFactory<>)).As(typeof(IDatabaseFactory<>)).InstancePerOwned(typeof(DatabaseFactory<>));
No
scope with a Tag matching 'MT.Data.Base.BaseObject.DatabaseFactory`1'
is visible from the scope in which the instance was requested. This
generally indicates that a component registered as per-HTTP request is
being requested by a SingleInstance() component (or a similar scenario.)
Under the web integration always request dependencies from the
DependencyResolver.Current or ILifetimeScopeProvider.RequestLifetime,
never from the container itself.
报错，程序无法运行。
(5)、SingleInstance
builder.RegisterGeneric(typeof(DatabaseFactory<>)).As(typeof(IDatabaseFactory<>)).SingleInstance();
单例模式，执行时得到的都是同一个相同的共享的实例。
一个HTTP请求，将实体附加到数据库上下问中，但是不提交。在下一个HTTP请求中，得到的数据库上下文对象与上一次HTTP请求的数据库上下文对象是同一个。
数据会将之前附加未提交的记录一并提交。
数据添加异常，不能这样操作。
(6)、InstancePerHttpRequest
builder.RegisterGeneric(typeof(DatabaseFactory<>)).As(typeof(IDatabaseFactory<>)).InstancePerRequest();
builder.RegisterType<DatabaseFactory<MTEntities>>().As<IDatabaseFactory<MTEntities>>().InstancePerRequest();
在一次HTTP请求中，获取到的数据库上下文中对象是同一个。
数据正常添加。
最终设置格式
修改或添加的文件：AutofacRegister,DatabaseFactory,Disposable,IDatabaseFactory
namespace MT.Application.Web.App_Code { /// <summary> /// Autofac注册 /// </summary> public class AutofacRegister { public static ContainerBuilder Register() { ContainerBuilder builder = null; try { builder = new ContainerBuilder(); //工作单元 builder.RegisterGeneric(typeof(UnitOfWork<>)).As(typeof(IUnitOfWork<>));//单例模式 //数据库工厂 builder.RegisterGeneric(typeof(DatabaseFactory<>)).As(typeof(IDatabaseFactory<>)).InstancePerRequest(); //T_Log类 builder.RegisterType<T_LogDAL>().As<IT_LogDAL>(); builder.RegisterType<T_LogBLL>().As<IT_LogBLL>(); return builder; } catch { builder = new ContainerBuilder(); return builder; } } } } namespace MT.Data.Base.BaseObject { /// <summary> /// 数据库工厂类 /// </summary> public class DatabaseFactory<T> : Disposable, IDatabaseFactory<T> where T : class { private T _dbcontext; /// <summary> /// 获取一个数据库上下文对象 /// 每一次http请求都会开启一个新的线程 /// 保证在一个线程(功能)中,DbContext是唯一 /// </summary> /// <returns></returns> public T Get() { try { if (_dbcontext == null) { Type t = typeof(T); System.Reflection.ConstructorInfo ci = t.GetConstructor(System.Type.EmptyTypes); T to = (T)ci.Invoke(new object[0]); _dbcontext = to; } return _dbcontext; } catch (Exception) { throw; } } protected override void DisposeCore() { if (_dbcontext != null) { ((IDisposable)_dbcontext).Dispose(); } } } } namespace MT.Data.Base.BaseObject { /// <summary> /// 释放资源 /// </summary> public class Disposable { //是否回收完毕 private bool isDisposed; ~Disposable() { Dispose(false); } public void Dispose() { Dispose(true); GC.SuppressFinalize(this); } private void Dispose(bool disposing) { //标志位:未回收，且参数标识为需要回收资源 if (!isDisposed && disposing) { //释放那些实现IDisposable接口的托管对象。此处调用方法进行释放。 DisposeCore(); } isDisposed = true; //释放非托管资源。此处没有需要释放的非托管对象 } protected virtual void DisposeCore() { } } } namespace MT.Data.Base.IBaseInterface { /// <summary> /// 数据库工厂接口 /// </summary> /// <typeparam name="T"></typeparam> public interface IDatabaseFactory<T> : IDisposable where T : class { T Get(); } }
