UnitOfWork机制
/*一点牢骚：
* UnitOfWork机制的蛋疼之处：
* UnitOfWork机制，决定了插入新的实体前，要预先设置数据库中的主键Id，尽管数据库自己生产主键。
* 但是，如果自己能生成主键还要数据库自动生成主键干什么，即使自己生成主键不能保证主键的唯一性，
* 除非主键是GUID。
*
* if (!addedEntities.ContainsKey(entity))
{
addedEntities.Add(entity, unitofWorkRepository);
};
* 判断实体的唯一性标准是调用实体的GetHashCode（）；
* public override int GetHashCode()
{
return this.Id.GetHashCode();
}
*而 this.Id是实体在数据库的主键（一般用数据库自动生成），但我插入前怎么能由我生成能。
*如果人工生成不能保证主键的唯一性，就不能添加到所以addedEntities中，也就不能保存到数据库。
*折中的解决方案是每添加一个新的实体，就Commit一次（马上提交到数据库，并清空addedEntities）。
*
*/
---------------------------------------------------------冷静分割线---------------------------------------------------
仓储实现UintOfWork机制
1.目标：
实现仓储实现UintOfWork机制（UintOfWork机制的目的是实现实体的持久化操作的原子性，保证数据的一致性）
2.具体的实现思路：
图解：
伪代码：
（1）仓储类Repository的定义
Repository类
{
虚拟增(实体entity） {
UintOfWork对象.增登记（实体entity，this） }; 虚拟删(实体entity） {
UintOfWork对象.删登记（实体entity，this） }; 虚拟改Add(实体entity） {
UintOfWork对象. 改登记（实体entity，this） }; 真的增到数据库(实体entity） {
AddTo数据库（实体entity）
}; 真的删到数据库(实体entity） {
RemovFrom数据库（实体entity）
}; 真的改保存到数据库(实体entity） {
UpdateTo数据库（实体entity）
};
}
（2）UnitOfWork类的定义：
UnitOfWork
{ 被增实体的字典 = new ();
被删实体的字典 = new ();
被改实体的字典 = new(); 增登记（实体entity，Repository）
{
if（如果被增实体的字典包不含实体entity）
被增实体的字典.Add(实体entity，Repository);
} 删登记（实体entity，Repository）
{
if （如果被删实体的字典不包含实体enity）
被删实体的字典.Add(实体entity，Repository);
} 改登记（实体entity，Repository）
{ if（如果被改实体的字典不包含实体entity）
被改实体的字典.Add(实体entity，Repository);
} 统一提交到数据库Commit（）
{
for(int i = ; i < 被增实体的字典.lengh; ++i )
{
实体entity tmpEntity = 被增实体的字典[i].Key；
Repository repository = 被增实体的字典[i].Value；
repository.真的增保存到数据库（tmpEntity）；
} for(int i = ; i < 被删实体的字典.lengh; ++i )
{
实体entity tmpEntity = 被删实体的字典[i].Key；
Repository repository = 被删实体的字典[i].Value；
repository.真的删保存到数据库（tmpEntity）；
} for(int i = ; i < 被改实体的字典.lengh; ++i )
{
实体entity tmpEntity = 被改实体的字典[i].Key；
Repository repository = 被改实体的字典[i].Value；
repository.真的改保存到数据库（tmpEntity）；
}
}
}
3.光说不练，代码实现：
IUnitOfWorkRepository.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using NCS.Infrastructure.Domain; namespace NCS.Infrastructure.UnitOfWork
{
/// <summary>
/// Repository实现了UnitOfWork机制的Repository
/// </summary>
public interface IUnitOfWorkRepository
{
/// <summary>
/// 实体的持久化操作（包括三个操作：增Add、删remove、改save，注意不包括查询）前，
/// 先用UnitOfWork进行登记，
/// 以便日后由UnitOfWork统一（原子性）通过Commit操作，提交修改到数据库（持久化操作）
/// </summary>
IUnitOfWork UnitOfWork { get; set; } /**
* Persist持久化系列函数
*/
void PersistCreationOf(IAggregateRoot entity);
void PersistUpdateOf(IAggregateRoot entity);
void PersistDeletionOf(IAggregateRoot entity);
}
}
IUnitOfWork.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using NCS.Infrastructure.Domain; namespace NCS.Infrastructure.UnitOfWork
{
/// <summary>
/// UnitOfWork模式：
/// 1.跟踪领域实体聚合的变化
/// 2.原子操作中完成实体聚合的持久化
/// 3.具体实现：
/// 实体的进行持久化操作（包括三个操作：增Add、删remove、改save，注意不包括查询）前，
/// 先用UnitOfWork进行登记，
/// 以便日后由UnitOfWork统一（原子性）通过Commit操作，提交修改到数据库（持久化操作）
/// </summary>
/// </summary>
public interface IUnitOfWork
{
/// <summary>
/// 注册登记被添加的实体
/// </summary>
/// <param name="entity">目标实体</param>
/// <param name="unitofWorkRepository">实体所在的仓储</param>
void RegisterNew(IAggregateRoot entity, IUnitOfWorkRepository unitofWorkRepository);
/// <summary>
/// 注册登记被删除的实体
/// </summary>
/// <param name="entity">目标实体</param>
/// <param name="unitofWorkRepository">实体所在的仓储</param>
void RegisterRemoved(IAggregateRoot entity, IUnitOfWorkRepository unitofWorkRepository);
/// <summary>
/// 注册登记被修改的实体
/// </summary>
/// <param name="entity">目标实体</param>
/// <param name="unitofWorkRepository">实体所在的仓储</param>
void RegisterAmended(IAggregateRoot entity, IUnitOfWorkRepository unitofWorkRepository); void Commit();
}
}
AdoUnitOfWork.cs
/*一点牢骚：
* UnitOfWork机制的蛋疼之处：
* UnitOfWork机制，决定了插入新的实体前，要预先设置数据库中的主键Id，尽管数据库自己生产主键。
* 但是，如果自己能生成主键还要数据库自动生成主键干什么，即使自己生成主键不能保证主键的唯一性，
* 除非主键是GUID。
*
* if (!addedEntities.ContainsKey(entity))
{
addedEntities.Add(entity, unitofWorkRepository);
};
* 判断实体的唯一性标准是调用实体的GetHashCode（）；
* public override int GetHashCode()
{
return this.Id.GetHashCode();
}
*而 this.Id是实体在数据库的主键（一般用数据库自动生成），但我插入前怎么能由我生成呢！！！
*因为：
*1.不知主键的数据库类型；
*2.即使知道主键的数据库类型，也不能因为硬编码造成的依赖，耦合。
*3.人工生成不能保证主键的唯一性，
*综上，所以就不能添加到addedEntities中，也就不能保存到数据库。
*折中的解决方案是每添加一个新的实体，就Commit一次（马上提交到数据库，并清空addedEntities）。
*
*/ using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using NCS.Infrastructure.Domain;
using NCS.Infrastructure.UnitOfWork;
using System.Transactions; namespace NCS.Repository.ADO
{
public class AdoUnitOfWork : IUnitOfWork
{
private Dictionary<IAggregateRoot, IUnitOfWorkRepository> addedEntities;
private Dictionary<IAggregateRoot, IUnitOfWorkRepository> changedEntities;
private Dictionary<IAggregateRoot, IUnitOfWorkRepository> deletedEntities; public AdoUnitOfWork()
{
addedEntities = new Dictionary<IAggregateRoot, IUnitOfWorkRepository>();
changedEntities = new Dictionary<IAggregateRoot, IUnitOfWorkRepository>();
deletedEntities = new Dictionary<IAggregateRoot, IUnitOfWorkRepository>();
} #region IUnitOfWork member #region 注册登记实体
public void RegisterNew(IAggregateRoot entity,
IUnitOfWorkRepository unitofWorkRepository)
{
if (!addedEntities.ContainsKey(entity))
{
addedEntities.Add(entity, unitofWorkRepository);
};
} public void RegisterRemoved(IAggregateRoot entity,
IUnitOfWorkRepository unitofWorkRepository)
{
if (!deletedEntities.ContainsKey(entity))
{
deletedEntities.Add(entity, unitofWorkRepository);
}
} public void RegisterAmended(IAggregateRoot entity,
IUnitOfWorkRepository unitofWorkRepository)
{
if (!changedEntities.ContainsKey(entity))
{
changedEntities.Add(entity, unitofWorkRepository);
}
} #endregion
public void Commit()
{
using (TransactionScope scope = new TransactionScope())
{
foreach (IAggregateRoot entity in this.addedEntities.Keys)
{
this.addedEntities[entity].PersistCreationOf(entity);
} foreach (IAggregateRoot entity in this.changedEntities.Keys)
{
this.changedEntities[entity].PersistUpdateOf(entity);
} foreach (IAggregateRoot entity in this.deletedEntities.Keys)
{
this.deletedEntities[entity].PersistDeletionOf(entity);
} scope.Complete(); this.addedEntities.Clear();
this.changedEntities.Clear();
this.deletedEntities.Clear();
}
} #endregion }
}
Repository.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using NCS.Infrastructure.Domain;
using NCS.Infrastructure.Querying;
using NCS.Infrastructure.UnitOfWork;
using NCS.Repository.ADO.DataSession; namespace NCS.Repository.ADO.Repositories
{
public abstract class Repository<T, TEntityKey> : IUnitOfWorkRepository
where T : IAggregateRoot
{
private IUnitOfWork unitOfWork; private IDataSession<T, TEntityKey> dataSession; public Repository(IUnitOfWork unitOfWork)
{
this.UnitOfWork = unitOfWork;
DataSession = DataSessionFactory.GetDataSession<T, TEntityKey>();
} public IUnitOfWork UnitOfWork
{
get { return unitOfWork; }
set { unitOfWork = value; }
} public IDataSession<T, TEntityKey> DataSession
{
get { return dataSession; }
set { dataSession = value; }
} #region 持久化 public void Add(T entity)
{
UnitOfWork.RegisterNew(entity, this);
} public void Remove(T entity)
{
UnitOfWork.RegisterNew(entity, this);
} public void Remove(Query query)
{
//TODO:好像Remove(Query query)并不能保证事务操作，因为没添加到UnitOfWork里面
//先提交事务
unitOfWork.Commit(); DataSession = DataSessionFactory.GetDataSession<T, TEntityKey>();
DataSession.Remove(query); } public void Save(T entity)
{
UnitOfWork.RegisterRemoved(entity, this);
} #endregion #region 查询部分 public T FindBy(TEntityKey id)
{
return this.DataSession.FindBy(id);
} public IEnumerable<T> FindAll()
{
return this.DataSession.FindAll();
} public IEnumerable<T> FindAll(int index, int count)
{
return this.DataSession.FindAll().Skip(index).Take(count);
} public IEnumerable<T> FindBy(Query query)
{
return this.DataSession.FindBy(query);
} public IEnumerable<T> FindBy(Query query, int index, int count)
{
return this.DataSession.FindBy(query, index, count);
} #endregion #region IUnitOfWorkRepository members public virtual void PersistCreationOf(IAggregateRoot entity)
{
this.DataSession.Add((T)entity);
} public virtual void PersistUpdateOf(IAggregateRoot entity)
{
this.DataSession.Save((T)entity);
} public virtual void PersistDeletionOf(IAggregateRoot entity)
{
this.DataSession.Remove((T)entity);
} #endregion }
}