/// <summary>
/// 使用<see cref="TransactionScope"/>实现<see cref="IUnitOfWork"/>接口
/// if the parameter <paramref name="isDtcAllowed"/> is true, the connection of UnitOfWork not needed to create.
/// else the connection need to create and bound to the thread.
/// </summary>
/// <param name="isDtcAllowed">是否允许使用DTC</param>
/// <param name="transactionScopeFactory">实现<see cref="ITransactionScopeFactory"/>接口的实例，用来创建<see cref="TransactionScope"/></param>
/// <param name="unitOfWorkDefinition">实现<see cref="IUnitOfWorkDefinition"/>接口的实例，用来定义事务环境</param>
/// <param name="dbProvider">实现<see cref="IDbProvider"/>的实例.</param>
public TransactionScopeUnitOfWork(bool isDtcAllowed, ITransactionScopeFactory transactionScopeFactory,
IUnitOfWorkDefinition unitOfWorkDefinition, IDbProvider dbProvider)
{
IsDTCAllowed = isDtcAllowed;
if (unitOfWorkDefinition == null)
{
unitOfWorkDefinition = UnitOfWorkDefinition.DefaultDefinition;
}
CheckUnitOfWorkDefinition(unitOfWorkDefinition);
Definition = unitOfWorkDefinition;
if (transactionScopeFactory == null)
{
transactionScopeFactory = new TransactionScopeFactory(unitOfWorkDefinition);
}
scope = transactionScopeFactory.GetInstance();
System.Transactions.Transaction.Current.TransactionCompleted +=
(o, args) => Logger.Debug(m => m("Current transaction completed with status {0}.",
args.Transaction.TransactionInformation.Status));
//不允许使用分布式事务，则DAO方式必须使用同一个Connection，需要在事务开始前创建Connection，并放入当前线程中。
if (!IsDTCAllowed)
{
CheckDbProvider(dbProvider);
DbProvider = dbProvider;
//开始事务，创建连接，并压入当前线程
BeginTransaction(DbProvider, Definition);
}
}
/// <summary>
/// 决定TimeOut事务的Timeout值
/// </summary>
/// <param name="definition">the <see cref="IUnitOfWorkDefinition"/></param>
/// <returns>returns the timeout of the current unitofwork.</returns>
protected int DetermineTimeout(IUnitOfWorkDefinition definition)
{
if (definition.Timeout != DefaultUnitOfWorkDefinition.TIMEOUT_DEFAULT)
{
return(definition.Timeout);
}
return(DefaultUnitOfWorkDefinition.TIMEOUT_DEFAULT);
}
/// <summary>
/// returns a <see cref="IUnitOfWork"/> instance based on the Ado.NET.
/// </summary>
/// <param name="connString">A ConnectionString.</param>
/// <param name="unitOfWorkDefinition">A UnitOfWorkDefinition.</param>
/// <returns>返回事务单元管理者<see cref="IUnitOfWork"/>实例，该实例基于Ado.Net实现<see cref="IUnitOfWork"/>接口.</returns>
public static IUnitOfWork GetAdoNetUnitOfWork(string connString, IUnitOfWorkDefinition unitOfWorkDefinition)
{
IDbProvider dbProvider = CreateDbProvider(connString);
return(AdoNetUnitOfWorkFactory.Create()
.SetDbProvider(dbProvider)
.GetUnitOfWork(unitOfWorkDefinition));
}
public WMSDefaultUnitOfWorkDefinition()
{
unitOfWorkDefinition = UnitOfWorkDefinition.DefaultDefinition;
unitOfWorkDefinition.Timeout = 180;
WarehouseId = string.Empty;
Database = null;
unitOfWorkDefinition.Name = "WMS_UnitOfWork";
}
/// <summary>
/// return a <see cref="IUnitOfWork"/> based on the <see cref="System.Transactions.TransactionScope"/>.
/// 当前Unit Work环境中，数据库的DTC不可用，UnitWork中的所有DAO方法采用同一个Connection.
/// </summary>
/// <param name="connString">A ConnectionString.</param>
/// <param name="unitOfWorkDefinition">A UnitOfWorkDefinition.</param>
/// <returns>返回事务单元管理者<see cref="IUnitOfWork"/>实例，该实例基于TransactionScope实现<see cref="IUnitOfWork"/>接口.</returns>
public static IUnitOfWork GetTransactionScopeUnitOfWorkWithoutDTC(string connString,
IUnitOfWorkDefinition unitOfWorkDefinition)
{
IDbProvider dbProvider = CreateDbProvider(connString);
return(TransactionScopeUnitOfWorkFactory.Create()
.SetIsDtcAllowed(false)
.SetDbProvider(dbProvider)
.GetUnitOfWork(unitOfWorkDefinition));
}
/// <summary>
/// 验证UnitOfWorkDefinition是否有异常.
/// </summary>
/// <param name="unitOfWorkDefinition">The UnitOfWorkDefinition.</param>
protected void CheckUnitOfWorkDefinition(IUnitOfWorkDefinition unitOfWorkDefinition)
{
if (unitOfWorkDefinition == null)
{
return;
}
// Check definition settings for new transaction.
if (unitOfWorkDefinition.Timeout < DefaultUnitOfWorkDefinition.TIMEOUT_DEFAULT)
{
throw new InvalidUnitOfWorkDefinitionException("Invalid transaction timeout");
}
}
public TransactionScope GetInstance()
{
if (unitOfWorkDefinition == null)
{
unitOfWorkDefinition = UnitOfWorkDefinition.DefaultDefinition;
}
var transactionToUse = new TransactionOptions
{
IsolationLevel = IsolationConvert.Convert(unitOfWorkDefinition.IsolationLevel),
Timeout = new TimeSpan(0, 0, unitOfWorkDefinition.Timeout)
};
return(new TransactionScope(TransactionScopeOption.Required, transactionToUse));
}
public AdoNetUnitOfWork(IDbProvider dbProvider, IUnitOfWorkDefinition unitOfWorkDefinition)
{
//验证DbProvider
CheckDbProvider(dbProvider);
DbProvider = dbProvider;
if (unitOfWorkDefinition == null)
{
unitOfWorkDefinition = UnitOfWorkDefinition.DefaultDefinition;
}
// Check definition settings for new transaction.
CheckUnitOfWorkDefinition(unitOfWorkDefinition);
Definition = unitOfWorkDefinition;
BeginTransaction(DbProvider, Definition);
}
/// <summary>
/// 事务开始
/// </summary>
protected void BeginTransaction(IDbProvider dbProvider, IUnitOfWorkDefinition definition)
{
CheckUnitOfWorkOutMostFlag(dbProvider);
//从当前线程中获取
ConnectionHolder conHolder = GetConnectionHolder(dbProvider);
//如果当前线程中存在ConnectionHolder，则此事务为嵌套事务，外层事务已存在多年；
if (conHolder != null)
{
Logger.Debug(m => m("[AbstractUnitOfWork.BeginTransaction]:Inner(deepth:{0}) unit of work initiates with definition({1})!",
UnitOfWorkStackManager.Count, definition));
}
else //外层事务
{
Logger.Debug(m => m("[AbstractUnitOfWork.BeginTransaction]:Outer most unit of work initiates with definition({0})!", definition));
ConnectionHolder connectionHolder = CreateConnectionHolder();
TransactionSynchronizationManager.BindResource(dbProvider, connectionHolder);
Logger.Debug(m => m("[AbstractUnitOfWork.BeginTransaction]:UnitOfWork created with(connstring:{0})", connectionHolder.Connection.ConnectionString));
}
}
public IUnitOfWork GetUnitOfWork(IUnitOfWorkDefinition definition)
{
return(new AdoNetUnitOfWork(dbProvider, definition));
}
public IUnitOfWork GetUnitOfWork(IUnitOfWorkDefinition definition)
{
ITransactionScopeFactory transactionScopeFactory = new TransactionScopeFactory(definition);
return(new TransactionScopeUnitOfWork(isDtcAllowed, transactionScopeFactory, definition, dbProvider));
}
/// <summary>
/// return a <see cref="IUnitOfWork"/> based on the <see cref="System.Transactions.TransactionScope"/>.
/// </summary>
/// <param name="unitOfWorkDefinition">A UnitOfWorkDefinition.</param>
/// <returns>返回事务单元管理者<see cref="IUnitOfWork"/>实例，该实例基于TransactionScope实现<see cref="IUnitOfWork"/>接口.</returns>
public static IUnitOfWork GetTransactionScopeUnitOfWorkWithDTCUsed(IUnitOfWorkDefinition unitOfWorkDefinition)
{
return(TransactionScopeUnitOfWorkFactory.Create().SetIsDtcAllowed(true).GetUnitOfWork(unitOfWorkDefinition));
}
public TransactionScopeFactory(IUnitOfWorkDefinition unitOfWorkDefinition)
{
this.unitOfWorkDefinition = unitOfWorkDefinition;
}
public TransactionScope GetInstance()
{
IUnitOfWorkDefinition definition = UnitOfWorkDefinition.DefaultDefinition;
return(new TransactionScopeFactory(definition).GetInstance());
}
