我心中的核心組件（可插拔的AOP）~第十二回 IoC組件Unity

回到目錄

說在前

Ioc組件有很多，之前也介紹過autofac,castle等，今天再來說一下在微軟Nlayer DDD架構里使用的unity組件，今天主要說一下依靠注入，如果希望看攔截的用法，可以閱讀這篇文章第十三回 實現AOP的攔截組件Unity.Interception

做在后

unity的用法主要說一下接口注入方法，它包括了程序中注入和配置文件注入，而接口注入還分為普通接口注入和泛型接口注入，下面分別來說一下：

普通接口和類實現代碼

　 public interface IUser
    {
        IQueryable<WebManageUsers> GetEntities();
    }
   public class UserRepository : BackgroundRepository<WebManageUsers>, IUser
    {
        public IQueryable<WebManageUsers> GetEntities()
        {
            return this.GetModel();
        }
    }

 

普通接口注入，程序中的注入

   using (IUnityContainer container = new UnityContainer())
                {
                   container.RegisterType<IUser, DataTest.UserRepository>();
                    var repository = container.Resolve<IUser>();
                }

普通接口注入，配置文件中的注入

  <unity xmlns="http://schemas.microsoft.com/practices/2010/unity">
    <container>
      <register  type="EntityTest.IUser,EntityTest" mapTo="DataTest.UserRepository, DataTest" />
       </container>
  </unity>

 using (IUnityContainer container = new UnityContainer())
                {
                    ConfigurationManager.GetSection("unity");
                    UnityConfigurationSection.CurrentSection.Configure(container);
                    var repository = container.Resolve<IUser>();
                }

普通接口和類實現代碼

 /// <summary>
    /// 基礎的數據操作規范
    /// </summary>
    /// <typeparam name="TEntity"></typeparam>
    public interface IRepository<TEntity>
           where TEntity : class
    {
        /// <summary>
        /// 添加實體並提交到數據服務器
        /// </summary>
        /// <param name="item">Item to add to repository</param>
        void Insert(TEntity item);

        /// <summary>
        /// 移除實體並提交到數據服務器
        /// 如果表存在約束，需要先刪除子表信息
        /// </summary>
        /// <param name="item">Item to delete</param>
        void Delete(TEntity item);

        /// <summary>
        /// 修改實體並提交到數據服務器
        /// </summary>
        /// <param name="item"></param>
        void Update(TEntity item);

        /// <summary>
        /// 得到指定的實體集合（延時結果集）
        /// Get all elements of type {T} in repository
        /// </summary>
        /// <returns>List of selected elements</returns>
        IQueryable<TEntity> GetModel();

        /// <summary>
        /// 根據主鍵得到實體
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        TEntity Find(params object[] id);
    }
    public class BackgroundRepository<T> : IRepository<T> where T : class
    {
#region IRepository<TEntity> 成員

        public virtual void Insert(TEntity item)
        {
            OnBeforeSaved(new SavedEventArgs(item, SaveAction.Insert));
            Db.Entry<TEntity>(item);
            Db.Set<TEntity>().Add(item);
            this.SaveChanges();
            OnAfterSaved(new SavedEventArgs(item, SaveAction.Insert));
        }

        public virtual void Delete(TEntity item)
        {
            OnBeforeSaved(new SavedEventArgs(item, SaveAction.Delete));
            Db.Set<TEntity>().Attach(item);
            Db.Set<TEntity>().Remove(item);
            this.SaveChanges();
            OnAfterSaved(new SavedEventArgs(item, SaveAction.Delete));
        }

        public virtual void Update(TEntity item)
        {
            OnBeforeSaved(new SavedEventArgs(item, SaveAction.Update));
            Db.Set<TEntity>().Attach(item);
            Db.Entry(item).State = EntityState.Modified;
            this.SaveChanges();
            OnAfterSaved(new SavedEventArgs(item, SaveAction.Update));
        }

        /// <summary>
        /// 子類在實現時，可以重寫，加一些狀態過濾
        /// </summary>
        /// <returns></returns>
        public virtual IQueryable<TEntity> GetModel()
        {
            //  return Db.Set<TEntity>().AsNoTracking();//對象無法自動添加到上下文中，因為它是使用 NoTracking 合並選項檢索的。請在定義此關系之前，將該實體顯式附加到 ObjectContext。
            return Db.Set<TEntity>();////ObjectStateManager 中已存在具有同一鍵的對象。ObjectStateManager 無法跟蹤具有相同鍵的多個對象。
        }
        /// <summary>
        /// 得到原生態結果集
        /// </summary>
        /// <returns></returns>
        public IQueryable<TEntity> GetEntities()
        {
            return Db.Set<TEntity>();
        }
        #endregion
　｝

泛型接口注入，程序中的注入

  using (IUnityContainer container = new UnityContainer())
                {
                   container.RegisterType<IRepository<User>, BackgroundRepository<User>>();
                    var re = container.Resolve<IRepository<User>>();
                }

泛型接口注入，配置文件中的注入

  <unity xmlns="http://schemas.microsoft.com/practices/2010/unity">
    <container>
         <register  type="IRepository.Core.IRepository`1,IRepository.Core" mapTo="DataTest.BackgroundRepository`1, DataTest" />
    </container>
  </unity>

  using (IUnityContainer container = new UnityContainer())
                {
                    ConfigurationManager.GetSection("unity");
                    UnityConfigurationSection.CurrentSection.Configure(container);
                 var re = container.Resolve<IRepository<User>>();
                }

下面我們封裝一個服務定位器，讓它把Unity容器封裝一下，方便以后調用它，下面是ServiceLocator的原代碼：

  /// <summary>
    /// Represents the Service Locator.
    /// </summary>
    public sealed class ServiceLocator : IServiceProvider
    {
        #region Private Fields
        private readonly IUnityContainer _container;
        #endregion

        #region Private Static Fields
        private static readonly ServiceLocator instance = new ServiceLocator();
        #endregion

        #region Ctor
        /// <summary>
        /// Initializes a new instance of ServiceLocator class.
        /// </summary>
        private ServiceLocator()
        {
            UnityConfigurationSection section = (UnityConfigurationSection)ConfigurationManager.GetSection("unity");
            _container = new UnityContainer();
            section.Configure(_container);
        }
        #endregion

        #region Public Static Properties
        /// <summary>
        /// Gets the singleton instance of the ServiceLocator class.
        /// </summary>
        public static ServiceLocator Instance
        {
            get { return instance; }
        }
        #endregion

        #region Private Methods
        private IEnumerable<ParameterOverride> GetParameterOverrides(object overridedArguments)
        {
            List<ParameterOverride> overrides = new List<ParameterOverride>();
            Type argumentsType = overridedArguments.GetType();
            argumentsType.GetProperties(BindingFlags.Public | BindingFlags.Instance)
                .ToList()
                .ForEach(property =>
                {
                    var propertyValue = property.GetValue(overridedArguments, null);
                    var propertyName = property.Name;
                    overrides.Add(new ParameterOverride(propertyName, propertyValue));
                });
            return overrides;
        }
        #endregion

        #region Public Methods
        /// <summary>
        /// Gets the service instance with the given type.
        /// </summary>
        /// <typeparam name="T">The type of the service.</typeparam>
        /// <returns>The service instance.</returns>
        public T GetService<T>()
        {
            return _container.Resolve<T>();
        }
        /// <summary>
        /// Gets the service instance with the given type by using the overrided arguments.
        /// </summary>
        /// <typeparam name="T">The type of the service.</typeparam>
        /// <param name="overridedArguments">The overrided arguments.</param>
        /// <returns>The service instance.</returns>
        public T GetService<T>(object overridedArguments)
        {
            var overrides = GetParameterOverrides(overridedArguments);
            return _container.Resolve<T>(overrides.ToArray());
        }
        /// <summary>
        /// Gets the service instance with the given type by using the overrided arguments.
        /// </summary>
        /// <param name="serviceType">The type of the service.</param>
        /// <param name="overridedArguments">The overrided arguments.</param>
        /// <returns>The service instance.</returns>
        public object GetService(Type serviceType, object overridedArguments)
        {
            var overrides = GetParameterOverrides(overridedArguments);
            return _container.Resolve(serviceType, overrides.ToArray());
        }
        #endregion

        #region IServiceProvider Members
        /// <summary>
        /// Gets the service instance with the given type.
        /// </summary>
        /// <param name="serviceType">The type of the service.</param>
        /// <returns>The service instance.</returns>
        public object GetService(Type serviceType)
        {
            return _container.Resolve(serviceType);
        }

        #endregion
    }

下面再去使用unity時就方便多了，呵呵，看代碼：

 var model = ServiceLocator.Instance.GetService<IExtensionRepository<WebManageUsers>>().GetModel().ToList();

而使用ServiceLocator還有一個好處，就是不需要使用＂實現的程序集＂，只要把＂實現的程序集＂和它的相關依賴的程序集一起復制到ＷＥＢ項目的ＢＩＮ目錄即可，服務定位器會自己去定位的．

好了，講到這里也就差不多了，需要注意的是，如果你在項目中進行注入時，需要先注入的實現類所在的程序集也引入進來，否則也是不可以resolve出來對象的，而對於業務層（領域）層來說，不需要關心底層

的實現技術，即不需要引用實現類的程序集，而在業務層引用接口程序集即可．

 回到目錄