DDD：管理“工作单元实例”的两种模式

概念介绍

类图如下：

在常见的用例场景下，类图的对象图如下：

问题

在一个用例执行过程中，如何保证同一个界限上下文内的所有仓储实例可以共享同一个工作单元实例？

解决方案1

 仓储采用依赖注入模式 + 使用IOC管理工作单元的生命周期（PerRequest或其它）。

代码示例

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

using Autofac;

namespace AutoFacStudy
{
    class Program
    {
        static void Main(string[] args)
        {
            var buider = new ContainerBuilder();
            buider.RegisterType<服务>();
            buider.RegisterType<仓储A>();
            buider.RegisterType<仓储B>();
            buider.RegisterType<工作单元>().InstancePerLifetimeScope();

            var container = buider.Build();

            dynamic 服务 = container.Resolve<服务>();

            //下边两行代码输出一样
            Console.WriteLine(服务.仓储A.工作单元.GetHashCode());
            Console.WriteLine(服务.仓储B.工作单元.GetHashCode());
        }
    }

    public class 服务
    {
        private readonly 仓储A _仓储A;
        private readonly 仓储B _仓储B;

        public 服务(仓储A 仓储A, 仓储B 仓储B)
        {
            _仓储A = 仓储A;
            _仓储B = 仓储B;
        }

        public 仓储A 仓储A
        {
            get { return _仓储A; }
        }

        public 仓储B 仓储B
        {
            get { return _仓储B; }
        }
    }

    public class 工作单元 { }

    public class 仓储A
    {
        private readonly 工作单元 _工作单元;

        public 仓储A(工作单元 工作单元)
        {
            _工作单元 = 工作单元;
        }

        public 工作单元 工作单元
        {
            get { return _工作单元; }
        }
    }

    public class 仓储B
    {
        private readonly 工作单元 _工作单元;

        public 仓储B(工作单元 工作单元)
        {
            _工作单元 = 工作单元;
        }

        public 工作单元 工作单元
        {
            get { return _工作单元; }
        }
    }
}

解决方案2

 仓储采用服务定位器模式 + 使用服务定位器或简单工厂管理工作单元的生命周期（PerRequest或其它）。

代码示例

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

using Autofac;

namespace AutoFacStudy
{
    class Program
    {
        public static IContainer 服务定位器;

        static void Main(string[] args)
        {
            var buider = new ContainerBuilder();
            buider.RegisterType<服务>();
            buider.RegisterType<仓储A>();
            buider.RegisterType<仓储B>();
            buider.RegisterType<工作单元>().InstancePerLifetimeScope();

            服务定位器 = buider.Build();

            dynamic 服务 = 服务定位器.Resolve<服务>();

            //下边两行代码输出一样
            Console.WriteLine(服务.仓储A.工作单元.GetHashCode());
            Console.WriteLine(服务.仓储B.工作单元.GetHashCode());
        }
    }

    public class 服务
    {
        private readonly 仓储A _仓储A;
        private readonly 仓储B _仓储B;

        public 服务(仓储A 仓储A, 仓储B 仓储B)
        {
            _仓储A = 仓储A;
            _仓储B = 仓储B;
        }

        public 仓储A 仓储A
        {
            get { return _仓储A; }
        }

        public 仓储B 仓储B
        {
            get { return _仓储B; }
        }
    }

    public class 工作单元 { }

    public class 仓储A
    {
        private readonly 工作单元 _工作单元;

        public 仓储A()
        {
            _工作单元 = Program.服务定位器.Resolve<工作单元>();
        }

        public 工作单元 工作单元
        {
            get { return _工作单元; }
        }
    }

    public class 仓储B
    {
        private readonly 工作单元 _工作单元;

        public 仓储B()
        {
            _工作单元 = Program.服务定位器.Resolve<工作单元>();
        }

        public 工作单元 工作单元
        {
            get { return _工作单元; }
        }
    }
}

由此示例可以看出，服务定位器和依赖注入可以混合在一起使用。这个例子我为了简单，服务定位器和IOC容器是同一个实例。

有些系统将服务定位器的实现换成简单工厂模式，他们本质上是一样的（服务定位器是一个万能工厂）。

代码示例

public class 工作单元工厂
{
    public static 工作单元 创建()
    {
        var 工作单元 = (工作单元)CallContext.GetData("工作单元");

        if (工作单元 == null)
        {
            工作单元 = new 工作单元();
            CallContext.SetData("工作单元", 工作单元);
        }

        return 工作单元;
    }
}