EntityFramework用法探索（七）線程安全實踐

在前文中，我們通過Unity來注冊各種類型和WiringUp。

      IUnityContainer container = new UnityContainer()
        .RegisterType(typeof(IRepository<>), typeof(Repository<>), new ContainerControlledLifetimeManager())
        .RegisterType<IUnitOfWork, UnitOfWork>(new ContainerControlledLifetimeManager())
        .RegisterType<DbContext, RETAILContext>(new ContainerControlledLifetimeManager())
        .RegisterType<DbContextAdapter>(new ContainerControlledLifetimeManager())
        .RegisterType<IObjectSetFactory, DbContextAdapter>(new ContainerControlledLifetimeManager())
        .RegisterType<IObjectContext, DbContextAdapter>(new ContainerControlledLifetimeManager())
        .RegisterType<ICustomerRepository, CustomerRepository>(new ContainerControlledLifetimeManager());

      UnityServiceLocator locator = new UnityServiceLocator(container);
      ServiceLocator.SetLocatorProvider(() => locator);

      ICustomerRepository customerRepository = container.Resolve<ICustomerRepository>();

但選擇使用了ContainerControlledLifetimeManager對象生命周期管理器，其將每個對象存儲為Singleton。這導致在多線程環境下會產生異常。

例如我們嘗試在多線程條件下更新Customer表：

      List<Task> tasks = new List<Task>();
      for (int i = 0; i < 16; i++)
      {
        DomainModels.Customer modifiedCustomer = Mapper.Map<DomainModels.Customer, DomainModels.Customer>(customer1);
        modifiedCustomer.Name = modifiedCustomer.Name + i;

        Task t = Task.Factory.StartNew(() =>
        {
          try
          {
            customerRepository.UpdateCustomer(modifiedCustomer);
          }
          catch (Exception ex)
          {
            Console.WriteLine("Exception occurred in thread " + Thread.CurrentThread.ManagedThreadId);
            Console.WriteLine(ex.Message);
          }
        });
        tasks.Add(t);
      }
      Task.WaitAll(tasks.ToArray());

但由於我們仍然需要EntityFramework的Local功能，即在當前線程環境下始終使用當前上下文中的對象。我們可能還無法選擇其他Unity對象生命期管理模型。

此時，我們考慮一種新的方法，引入線程Scope功能，即在給定線程中，使用同一個UnityContainer來維護對象，這樣間接利用的EntityFramework的上下文功能。

原理很簡單，就是為每個線程生成一個單獨的ChildUnityContainer。

  public class UnityContainerScope : IDisposable
  {
    private static ConcurrentDictionary<int, bool> scopeMapping
      = new ConcurrentDictionary<int, bool>();

    protected UnityContainerScope()
    {
      ScopeId = Thread.CurrentThread.ManagedThreadId;
      scopeMapping.Add(ScopeId, true);
    }

    public int ScopeId { get; private set; }
    public static int ScopeCount { get { return scopeMapping.Count; } }

    public static UnityContainerScope NewScope()
    {
      return new UnityContainerScope();
    }

    public static bool InScope(int scopeId)
    {
      return scopeMapping.ContainsKey(scopeId);
    }

    public void Dispose()
    {
      UnityContainerDispatcher.DisposeContainer();
      scopeMapping.Remove(ScopeId);
    }
  }

這里同時需要一個UnityContainerDispatcher來負責為線程生成Container容器。

  public static class UnityContainerDispatcher
  {
    private static IUnityContainer parentContainer = null;
    private static ConcurrentDictionary<int, IUnityContainer> containerMapping
      = new ConcurrentDictionary<int, IUnityContainer>();

    public static void InjectParentContainer(IUnityContainer unity)
    {
      if (unity == null)
        throw new ArgumentNullException("unity");

      parentContainer = unity;
    }

    public static IUnityContainer GetContainer()
    {
      int key = Thread.CurrentThread.ManagedThreadId;

      if (!UnityContainerScope.InScope(key))
      {
        throw new UnityContainerNotInScopeException(
          string.Format(CultureInfo.InvariantCulture,
          "The specified scope id [{0}] is not in scope.", key));
      }

      if (!containerMapping.ContainsKey(key))
      {
        BuildUpContainer(key);
      }

      return containerMapping.Get(key);
    }

    public static void DisposeContainer()
    {
      int key = Thread.CurrentThread.ManagedThreadId;
      IUnityContainer container = containerMapping.Remove(key);
      if (container != null)
      {
        container.Dispose();
      }
    }

    private static void BuildUpContainer(int key)
    {
      if (parentContainer == null)
        throw new InvalidProgramException("The parent container cannot be null.");

      IUnityContainer childContainer = parentContainer.CreateChildContainer();
      containerMapping.Add(key, childContainer);
    }
  }

在注入的根UnityContainer中，我們通過使用CreateChildContainer方法來獲取一個新的Container，同時繼承所有根容器的注冊配置信息。這要求使用HierarchicalLifetimeManager生命期管理器。

此時，我們的代碼修改為，

      IUnityContainer container = new UnityContainer()
        .RegisterType(typeof(IRepository<>), typeof(Repository<>), new HierarchicalLifetimeManager())
        .RegisterType<IUnitOfWork, UnitOfWork>(new HierarchicalLifetimeManager())
        .RegisterType<DbContext, RETAILContext>(new HierarchicalLifetimeManager())
        .RegisterType<DbContextAdapter>(new HierarchicalLifetimeManager())
        .RegisterType<IObjectSetFactory, DbContextAdapter>(new HierarchicalLifetimeManager())
        .RegisterType<IObjectContext, DbContextAdapter>(new HierarchicalLifetimeManager())
        .RegisterType<ICustomerRepository, CustomerRepository>(new HierarchicalLifetimeManager());

      UnityContainerDispatcher.InjectParentContainer(container);

      ICustomerRepository customerRepository = container.Resolve<ICustomerRepository>();

創建多線程測試代碼，

      List<Task> tasks = new List<Task>();
      for (int i = 0; i < 16; i++)
      {
        DomainModels.Customer modifiedCustomer = Mapper.Map<DomainModels.Customer, DomainModels.Customer>(customer1);
        modifiedCustomer.Name = modifiedCustomer.Name + i;

        Task t = Task.Factory.StartNew(() =>
        {
          try
          {
            using (UnityContainerScope scope = UnityContainerScope.NewScope())
            {
              customerRepository.UpdateCustomer(modifiedCustomer);
              Console.WriteLine("Modified " + modifiedCustomer.Name + " in thread " + Thread.CurrentThread.ManagedThreadId);
            }
          }
          catch (Exception ex)
          {
            Console.WriteLine("Exception occurred in thread " + Thread.CurrentThread.ManagedThreadId);
            Console.WriteLine(ex.Message);
          }
        });
        tasks.Add(t);
      }
      Task.WaitAll(tasks.ToArray());

測試結果表明已經可以安全的在多線程條件下工作了。

完整代碼和索引

EntityFramework用法探索系列

• （一）DatabaseFirst
• （二）CodeFirst
• （三）CodeFirst流暢API
• （四）Repository和UnitOfWork
• （五）引入Unity
• （六）靜態Repository
• （七）線程安全實踐
• （八）事務處理

完整代碼下載