在操作数据库的过程中，为了数据的一致性，我们可以使用Transaction，要么成功的时候全部提交，要么有任何一个操作失败立即全部回滚。不仅仅是在数据库方面，有时候操作其他的内容，比如说对于系统文件的操作，也需要把一些操作组合看做是一个事务。

现在我们看这样一个例子。现在我们需要在计算机的硬盘上创建3个目录A，B，C，要求要么3个全部创建成功，要么一个也不要创建。我们可以把这个看成是一个事务。如果我们自己写代码来操作，可以这样写。

            bool createA = false;
            bool createB = false;
            bool createC = false;

            try
            {
                //这里的操作是创建3个目录
                Directory.CreateDirectory("\\A");
                createA = true;
                Directory.CreateDirectory("\\B");
                createB = true;
                Directory.CreateDirectory("\\C");
                createC = true;
            }
            catch (System.Exception ex)
            {
                //这里在捕捉到异常时，根据运行的结果进行回滚
                if (createB)
                {
                    Directory.Delete("\\B");
                    Directory.Delete("\\A");
                }
                if (!createB && createA)
                {
                    Directory.Delete("\\A");
                }
            }

但是这里我们是把这3个操作当成一个整体来回滚，及时是简单的创建删除文件夹，我们可以看到catch中的回滚逻辑已经很复杂了。可以想象，如果A，B，C这3步不仅仅是创建目录，还有一些其他的操作，那么回滚的逻辑就非常复杂，此时，我们可以考虑把这一个分成几个小事务，分开回滚。代码可以这样写，这里我们使用了Framework提供的Transactin以及TransactioScope类。

class Program
    {
        static void Main(string[] args)
        {
            //这里就不需要了try catch,因为scope就已经完成了这个功能，
            //即当有异常发生向外抛的时候，会尝试跳出这个using代码块，
            //CLR会在向代码块外边跑异常之前，分别取调用每个transaction的
            //roolback方法，只要rollback中你定义的逻辑没有问题，那么所有
            //的已发生的操作就会安全的回滚。
            using (var scope = new TransactionScope())
            {
                var A = new OperationA();
                Transaction.Current.EnlistVolatile(A, EnlistmentOptions.None);
                A.DoWork();

                OperationB B = new OperationB();
                Transaction.Current.EnlistVolatile(B, EnlistmentOptions.None);
                B.DoWork();
                scope.Complete();
            }
        }


    }
}

class OperationA : IEnlistmentNotification
{
    private bool _isCommitSucceed = false;

    public void Commit(Enlistment enlistment)
    {
        enlistment.Done();
    }

    public void DoWork()//这是自定义的方法，不是继承IEnlistmentNotification
    {
        Directory.CreateDirectory("\\A");
        //这里还有一些其他的关于A的复杂操作
        _isCommitSucceed = true;
    }

    public void InDoubt(Enlistment enlistment)
    {
        enlistment.Done();
    }
    public void Prepare(PreparingEnlistment preparingEnlistment)
    {
        preparingEnlistment.Prepared();
    }
    public void Rollback(Enlistment enlistment)
    {
        //这里回滚A的一些操作，当然这里的操作逻辑需要你自己来写。
        //比如说查看是否创建成功，或者有一些其他的信号标记，通过这些
        //标记你来决定是删除目录还是其他的什么回滚操作。
        if (_isCommitSucceed)
            Directory.Delete("\\A");
        enlistment.Done();
    }
}

class OperationB : IEnlistmentNotification
{
    private bool _isCommitSucceed = false;

    public void Commit(Enlistment enlistment)
    {
        enlistment.Done();
    }

    public void DoWork()
    {
        //这里是关于B的一些复杂操作
        throw new Exception("test");
        //这里依然有一些操作代码，但是我们模拟的是B操作途中抛出异常，所以这里的代码不会执行
    }

    public void InDoubt(Enlistment enlistment)
    {
        enlistment.Done();
    }
    public void Prepare(PreparingEnlistment preparingEnlistment)
    {
        preparingEnlistment.Prepared();
    }
    public void Rollback(Enlistment enlistment)
    {
        if (_isCommitSucceed)
        {
            //这里回滚B的一些已经存在的操作。
        }
        enlistment.Done();
    }