我这里介绍一个.netcore的事务管理小组件，目的是借助于事务中包装的步骤编写更好的代码。提供的小功能主要是“事务执行顺序的设置”和“事务执行状态监听”。

使用方式就是，在nuget中引入DeepTransactionCore包。咱们以一个项目示例进行说明。

1，新建一个.netcore的控制台程序，引入DeepTransactionCore、Newtonsoft.Json两个包。

2、为了进行测试，咱们先创建一个对象实体类，咱们通过在事务内操作这个对象，进而达到演示功能的效果

    public class Person
    {
        public string FirstName { get; set; }
        public string LastName { get; set; }
    }

3、根据组件使用要求，在使用之前需要创建一个类来继承IDependencyResolver接口。其功能就是“根据对象类型，创建一个对象”。这个类必须实现。

    public class DependecyResolver : IDependencyResolver
    {
        public TOut Resolve<TOut>()
        {
            Type type = typeof(TOut);
            return (TOut)System.Activator.CreateInstance(type);
        }
    }

你可以根据实际情况进行Resolve接口方法的实现，比如你有DI框架，可以使用DI容器来实现，我这边只是简单的使用了.net系统提供的方法来根据对象类型创建一个对象。

4、定义一些事务用来测试，需要实现ITransactionStep接口（基本事务Tran_Step1、Tran_Step1。组合事务：Tran_Combine。异常事务：Tran_Exception）

    /// <summary>
    /// 事务1：设置FirstName姓名
    /// </summary>
    public class Tran_Step1 : ITransactionStep
    {
        public void Before(dynamic input)
        {
            //事务执行前
        }
        public TransactionContext Execute(dynamic input)
        {
            input.Person = new Person()
            {
                FirstName = input.Name,
                LastName = input.DiyField//自定义字段，名字随便起
            };
            Console.WriteLine("Step1-返回input：" + Newtonsoft.Json.JsonConvert.SerializeObject(input.Person));
            return input;
        }
    }

    /// <summary>
    /// 事务2：设置LastName姓名
    /// </summary>
    public class Tran_Step2 : ITransactionStep
    {
        public void Before(dynamic input)
        {
            //事务执行前
        }
        public TransactionContext Execute(dynamic input)
        {
            input.Person = new Person()
            {
                LastName = input.Name,
                FirstName = input.DiyField//自定义字段，名字随便起
            };
            Console.WriteLine("Step2-返回input：" + Newtonsoft.Json.JsonConvert.SerializeObject(input.Person));
            return input;
        }
    }

    /// <summary>
    /// “组合事务”：合并事务到一个“事务”内在按顺序执行
    /// </summary>
    public class Tran_Combine: BaseTransaction
    {
        public Tran_Combine() : base("My Transaction")
        {
            this.AddStep<Tran_Step1>().AddStep<Tran_Step2>();
        }
    }

    /// <summary>
    /// 用来“测试异常”的事务
    /// </summary>
    public class Tran_Exception : ITransactionStep
    {
        public void Before(dynamic input)
        {
            //事务执行前
        }
        public TransactionContext Execute(dynamic input)
        {
            try
            {
                input.Person = new Person()
                {
                    FirstName = input.Name,
                    LastName = input.DiyField//自定义字段，名字随便起
                };
                Convert.ToInt32("123asd");//故意出现异常，好用来测试
                Console.WriteLine("Step1-返回input：" + Newtonsoft.Json.JsonConvert.SerializeObject(input.Person));
                return input;
            }
            catch (Exception)
            {
                throw new Exception("我是事务发的异常信息：我执行的时候可能出错");
            }
        }
    }

5、演示一个事务分步骤

    public class TestTrain
    {
        /// <summary>
        /// 构造函数，必须要“初始化依赖解析程序”
        /// </summary>
        public TestTrain()
        {
            DeepBootstrapper.MapResolver(new DependecyResolver());
        }
        /// <summary>
        /// 测试“逐步事务”
        /// </summary>
        public void TestStypeFun()
        {
            dynamic tranContext = new TransactionContext();
            tranContext.Name = "Alex";//用来向事务传递数据
            tranContext.DiyField = "hhh";//用来向事务传递数据
            var response = TransactionWorker.Define("自定义事务工作组名字")//起个名
                .AddStep<Tran_Step1>().AddStep<Tran_Step2>().AddStep<Tran_Combine>()//先执行事务Step1,在Step2，最后执行CombineStepTrans
                .Process(tranContext);
            //Console.Read();
        }
    }

6、演示一个异常事务监听测试

      a、如果要进行“异常事务监听”，先定义一个监听类，需要实现IListener接口

    public class MyListener : IListener
    {
        public void After(ListenerModel listenerModel)
        {
            Console.WriteLine("after"); ;
        }

        public void Before(ListenerModel listenerModel)
        {
            Console.WriteLine("before"); ;
        }

        public void OnError(ListenerModel listenerModel, Exception exception)
        {
            Console.WriteLine("我监听到出现了错误了！！！"); ;
        }
    }

       b、开始编写调用代码

    public class TestTrain
    {
        /// <summary>
        /// 构造函数，必须要“初始化依赖解析程序”
        /// </summary>
        public TestTrain()
        {
            DeepBootstrapper.MapResolver(new DependecyResolver());
        }

        /// <summary>
        /// 测试监听“事务异常”
        /// </summary>
        public void TestListenerFun()
        {
            //实例化一个监听器
            MyListener _listener = new MyListener();
            //创建上下文
            dynamic tranContext = new TransactionContext();
            tranContext.Name = "Alex";
            tranContext.DiyField = "hhh";//自定义字段，名字随便起
            //创建事务容器
            var tw = TransactionWorker.Define("Some transaction").AddStep<Tran_Exception>();
            tw.WithListener(_listener);
            try
            {
                //执行
                var rs = tw.Process(tranContext);
            }
            catch (Exception)
            {

            }
        }

    }

测试代码源码：ConsoleTestDeepTransaction.rar (10.22 mb)