像TransactionScope一样使用DbTransaction

System.Transactions.TransactionScope为了提供一种非常方便的实现分布式事务的方式，但是在某些情况下为了阻止本地事务向分布式事务提升，我们只能通过DbTransaction进行事务控制。在进行数据库操作的时候，我们经常会遇到这样的事务场景：当某个方法单独执行的时候，它应该在一个单一的DbTransaction中执行；当多个方法一起执行的时候，它们应用共同在DbTransaction中执行。在本篇文章中我们通过对DbTransaction进行封装，提供一种类似于TransactionScope的编程方式来解决这个问题。[源代码从这里下载]

目录
一、自定义的Transaction
二、自定义CommittableTransaction和DependentTransaction
三、自定义TransactionScope
四、一个具有事务感知的DbHelper
五、三种事务控制的性能

一、自定义的Transaction

我们完全采用System.Transactions的应用编程接口的设计定义基于DbTransaction的相关类型，首选来看看具有如下定义的表示事务的Transaction类型。Transaction是一个抽象类，具有DbTransactionWrapper和Completed两个属性，前者表示对DbTransaction的封装，后者表示事务操作是否已经完成。静态属性Current表示当前事务，这是一个基于当前线程的静态字段。Rollback和Dispose直接调用了DbTransactionWrapper的同名方法。

namespace Artech.Transactions
{
    public class DbTransactionWrapper: IDisposable
    {
        public DbTransactionWrapper(DbTransaction transaction)
        {
            this.DbTransaction = transaction;
        }
        public DbTransaction DbTransaction { get; private set; }
        public bool IsRollBack { get; set; }
        public void Rollback()
        {
            if (!this.IsRollBack)
            {
                this.DbTransaction.Rollback();
            }
        }
        public void Commit()
        {
            this.DbTransaction.Commit();
        }
        public void Dispose()
        {
            this.DbTransaction.Dispose();
        }
    }
    public abstract class Transaction : IDisposable
    {
        [ThreadStatic]
        private static Transaction current;

        public bool Completed { get; private set; }
        public DbTransactionWrapper DbTransactionWrapper { get; protected set; }
        protected Transaction() { }
        public void Rollback()
        {
            this.DbTransactionWrapper.Rollback();
        }
        public DependentTransaction DependentClone()
        {
            return new DependentTransaction(this);
        }
        public void Dispose()
        {
            this.DbTransactionWrapper.Dispose();
        }
        public static Transaction Current
        {
            get { return current; }
            set { current = value; }
        }
    }
}

二、自定义CommittableTransaction和DependentTransaction

和定义在System.Transactions的事务一样，具体事务分为CommittableTransaction和DependentTransaction，前者可以使一个可以直接提交的独立事务，后者则是依附于某个事务的依赖事务。如下面的代码片断所示，我们直接基于某个DbTransaction来创建CommittableTransaction对象。而用于提交事务的Commit方法则直接调用DbTransaction的同名方法。

public class CommittableTransaction : Transaction
{
    public CommittableTransaction(DbTransaction dbTransaction)
    {
        this.DbTransaction = dbTransaction;
    }
    public void Commit()
    {
        this.DbTransaction.Commit();
    }
}

下面是DependentTransaction的定义，我们直接基于某个作为内部事务的Transaction对象来创建DependentTransaction，而这个内部事务可以是一个CommittableTransaction，也可以是DependentTransaction。由于DependentTransaction只具有一个内部构造函数，所以DependentTransaction通过调用定义在Transaction的DependentClone方法来创建。

public class DependentTransaction : Transaction
{
    public Transaction InnerTransaction { get; private set; }
    internal DependentTransaction(Transaction innerTransaction)
    {
        this.InnerTransaction = innerTransaction;
        this.DbTransaction = this.InnerTransaction.DbTransaction;
    }
}

三、自定义TransactionScope

我们在进行事务编程的时候只会使用到具有如下定义的TransactionScope类型。我们通过指定连接字符串名称、隔离级别以及用于创建DbProviderFactory的委托创建TransactionScope对象。在TransactionScope的构造函数中，如果通过Artech.Transactions.Transaction.Current属性表示的当前事务不存在，则根据DbProviderFactory创建DbConnection并调用BeginTransaction方法开启事务，并用被开启的DbTransaction创建CommittableTransaction对象。最终将创建的CommittableTransaction作为当前事务；服务过当前事务已经存在，则直接调用它的DependentClone方法创建的DependentTransaction作为当前事务。

namespace Artech.Transactions
{
    public class TransactionScope: IDisposable
    {
        private Transaction transaction = Transaction.Current;
        public bool Completed { get; private set; }

        public TransactionScope(string connectionStringName, IsolationLevel isolationLevel = IsolationLevel.Unspecified,
            Func<string, DbProviderFactory> getFactory = null)
        {
            if (null == transaction)
            {
                if (null == getFactory)
                {
                    getFactory = cnnstringName => DbHelper.GetFactory(cnnstringName);
                }
                DbProviderFactory factory = getFactory(connectionStringName);
                DbConnection connection = factory.CreateConnection();
                connection.ConnectionString = ConfigurationManager.ConnectionStrings[connectionStringName].ConnectionString;
                connection.Open();
                DbTransaction dbTransaction = connection.BeginTransaction(isolationLevel);
                Transaction.Current = new CommittableTransaction(dbTransaction);
            }
            else
            {
                Transaction.Current = transaction.DependentClone();
            }
        }

        public void Complete()
        {
            this.Completed = true;
        }
        public void Dispose()
        {
            Transaction current = Transaction.Current;
            Transaction.Current = transaction;
            if (!this.Completed)
            {
                current.Rollback();
            }
            CommittableTransaction committableTransaction = current as CommittableTransaction;
            if (null != committableTransaction)
            {
                if (this.Completed)
                {
                    committableTransaction.Commit();
                }
                committableTransaction.Dispose();
            }
        }
    }
}

在事务操作完成之后必须调用Complete方法“提交事务”，此时我们将TransactionScope的Completed 属性设置为True。TransactionScope实现了IDisposable方法，Dispose方法具有这样的逻辑：先将当前状态还原成创建TransactionScope之初的状态，在还原之前先将当前事务保存下来。如果Completed属性为False，则直接调用Transaction的Rollback方法对事务进行回滚。如果Completed状态为True，而且当前事务为CommittableTransaction 则直接提交事务。

四、一个具有事务感知的DbHelper

为了演示通过捕捉当前事务来来控制具体事务的执行方式，我们写了如下一个DbHelper，其中ExecuteNonQuery用于在事务中执行指定的一段SQL。具体事务控制的逻辑是这样的：如果Artech.Transactions.Transaction.Current属性返回的事务存在，则将当前操作纳入封装的DbTransaction；如果System.Transactions.Transaction.Current属性返回的事务存在，操作的执行会自动纳入该事务中；如果上述两中环境事务均不存在，则创建一个单独的DbTransaction并将相应的操作纳入其中。

public class DbHelper
{
    //其他成员
    public int ExecuteNonQuery(string commandText, IDictionary<string, object> parameters)
    {
        DbConnection connection = null;
        DbCommand command = this.DbProviderFactory.CreateCommand();
        DbTransaction dbTransaction = null;
        try
        {
            command.CommandText = commandText;
            parameters = parameters ?? new Dictionary<string, object>();
            foreach (var item in parameters)
            {
                command.Parameters.Add(this.BuildDbParameter(item.Key, item.Value));
            }
            if (null != Artech.Transactions.Transaction.Current)
            {
                command.Connection = Artech.Transactions.Transaction.Current.DbTransactionWrapper.DbTransaction.Connection;
                command.Transaction = Artech.Transactions.Transaction.Current.DbTransactionWrapper.DbTransaction;
            }
            else
            {
                connection = this.DbProviderFactory.CreateConnection();
                connection.ConnectionString = this.ConnectionString;
                command.Connection = connection;
                connection.Open();
                if (System.Transactions.Transaction.Current == null)
                {
                    dbTransaction = connection.BeginTransaction();
                    command.Transaction = dbTransaction;
                }
            }
            int result = command.ExecuteNonQuery();
            if (null != dbTransaction)
            {
                dbTransaction.Commit();
            }
            return result;
        }
        catch
        {
            if (null != dbTransaction)
            {
                dbTransaction.Rollback();
            }
            throw;
        }
        finally
        {
            if (null != connection)
            {
                connection.Dispose();
            }
            if (null != dbTransaction)
            {
                dbTransaction.Dispose();
            }
            command.Dispose();
        }
    }
}

五、三种事务控制的性能

我们现在来测试批量操作在System.Transactions.TransactionScope、Artech.Transactions.TransactionScope和针对单独操作的DbTransaction的性能。我们在目标数据库中创建一个只包含Id和Name两个字段的数据表Users，并通过如下的CreateUser为该表添加一笔记录。

static void CreateUser(string id, string name)
{
    string sql = "INSERT Users(ID, Name) Values(@id, @name)";
    Dictionary<string, object> parameters = new Dictionary<string, object>();
    parameters.Add("id", id);
    parameters.Add("name", name);
    DbHelper.ExecuteNonQuery(sql, parameters);
}

而如下三个方法分别通过上述三种事务方式执行上面的这个方法，其中参数count为添加的数据量。

private static void AddUsers1(int count)
{
    using (System.Transactions.TransactionScope transactionScope = new System.Transactions.TransactionScope())
    {
        for (int i = 0; i < count; i++)
        {
            CreateUser(Guid.NewGuid().ToString(), Guid.NewGuid().ToString());
        }
        transactionScope.Complete();
    }
}

private static void AddUsers2(int count)
{
    using (Artech.Transactions.TransactionScope transactionScope = new Artech.Transactions.TransactionScope("TestDb"))
    {
        for (int i = 0; i < count; i++)
        {
            CreateUser(Guid.NewGuid().ToString(), Guid.NewGuid().ToString());
        }
        transactionScope.Complete();
    }
}

private static void AddUsers3(int count)
{
    for (int i = 0; i < count; i++)
    {
        CreateUser(Guid.NewGuid().ToString(), Guid.NewGuid().ToString());
    }
}

为了剔除由于数据表现有数据量对数据访问性能的影响，我们在每次进行数据批量插入之前都回调用具有如下定义的DeleteAllUsers方法将表中的数据删除殆尽。

private static void DeleteAllUsers()
{
    string sql = "DELETE USERS";
    DbHelper.ExecuteNonQuery(sql, null);
}

下面是我们最终的测试程序，我们分别测试了数据量为100、1，000、10，000和100，000的数据写入操作分别在上述三种事务控制方式的耗时。

Stopwatch stopWatch = new Stopwatch();

//100
Console.WriteLine("100");
DeleteAllUsers();
stopWatch.Restart();
AddUsers1(100);
Console.WriteLine("{0, -36}: {1}", "System.Transactions.TransactionScope", stopWatch.ElapsedMilliseconds);

DeleteAllUsers();
stopWatch.Restart();
AddUsers2(100);
Console.WriteLine("{0, -36}: {1}", "Artech.Transactions.TransactionScope", stopWatch.ElapsedMilliseconds);

DeleteAllUsers();
stopWatch.Restart();
AddUsers3(100);
Console.WriteLine("{0, -36}: {1}\n", "Single Transnaction", stopWatch.ElapsedMilliseconds);

//1000
Console.WriteLine("1000");
DeleteAllUsers();
stopWatch.Restart();
AddUsers1(1000);
Console.WriteLine("{0, -36}: {1}", "System.Transactions.TransactionScope", stopWatch.ElapsedMilliseconds);

DeleteAllUsers();
stopWatch.Restart();
AddUsers2(1000);
Console.WriteLine("{0, -36}: {1}", "Artech.Transactions.TransactionScope", stopWatch.ElapsedMilliseconds);

DeleteAllUsers();
stopWatch.Restart();
AddUsers3(1000);
Console.WriteLine("{0, -36}: {1}\n", "Single Transnaction", stopWatch.ElapsedMilliseconds);

//10000
Console.WriteLine("10000");
DeleteAllUsers();
stopWatch.Restart();
AddUsers1(10000);
Console.WriteLine("{0, -36}: {1}", "System.Transactions.TransactionScope", stopWatch.ElapsedMilliseconds);

DeleteAllUsers();
stopWatch.Restart();
AddUsers2(10000);
Console.WriteLine("{0, -36}: {1}", "Artech.Transactions.TransactionScope", stopWatch.ElapsedMilliseconds);

DeleteAllUsers();
stopWatch.Restart();
AddUsers3(10000);
Console.WriteLine("{0, -36}: {1}\n", "Single Transnaction", stopWatch.ElapsedMilliseconds);

//100000
Console.WriteLine("100000");
DeleteAllUsers();
stopWatch.Restart();
AddUsers1(100000);
Console.WriteLine("{0, -36}: {1}", "System.Transactions.TransactionScope", stopWatch.ElapsedMilliseconds);

DeleteAllUsers();
stopWatch.Restart();
AddUsers2(100000);
Console.WriteLine("{0, -36}: {1}", "Artech.Transactions.TransactionScope", stopWatch.ElapsedMilliseconds);

DeleteAllUsers();
stopWatch.Restart();
AddUsers3(100000);
Console.WriteLine("{0, -36}: {1}", "Single Transaction", stopWatch.ElapsedMilliseconds);

下面是测试程序输出结果：

100
System.Transactions.TransactionScope: 28
Artech.Transactions.TransactionScope: 11
Single Transnaction                 : 57

1000
System.Transactions.TransactionScope: 140
Artech.Transactions.TransactionScope: 83
Single Transnaction                 : 469

10000
System.Transactions.TransactionScope: 1530
Artech.Transactions.TransactionScope: 826
Single Transnaction                 : 4659

100000
System.Transactions.TransactionScope: 13562
Artech.Transactions.TransactionScope: 8346
Single Transaction                  : 48277

上面的输出结果表明我们自定义的TransactionScope具有最好的性能，不过优势还不是很明显，这是由于连接池机制的原因。现在我们通过如下的方式将连接字符创对连接池的支持关闭：

<configuration>
  <connectionStrings>
    <add name="TestDb"
         providerName="System.Data.SqlClient"
         connectionString="Data Source=.;Initial Catalog=TestDb;Integrated Security=True; Pooling=False;"/>
  </connectionStrings>
</configuration>

再次运行我们的程序我们就会看到三种事务处理方式在性能上的显著差异（当数据量为100，000时，采用System.Transactions.TransactionScope直接就崩溃了）

100
System.Transactions.TransactionScope: 2318
Artech.Transactions.TransactionScope: 13
Single Transnaction                 : 310

1000
System.Transactions.TransactionScope: 2949
Artech.Transactions.TransactionScope: 124
Single Transnaction                 : 3623

10000
System.Transactions.TransactionScope: 32754
Artech.Transactions.TransactionScope: 1213
Single Transnaction                 : 30631

100000

未经处理的异常:  System.Data.SqlClient.SqlException: Import of Microsoft Distributed Transaction Coordinator (MS DTC) transaction failed:...