Castle~實現IoC容器

IOC的容器確實不少，unity,autofac,Castle 等等，前兩種組件如何實現ＩＯＣ在我之前的文章中已經做過說明了，今天主要來說一下Castle如何去實現IoC，事實上Castle是小微的一個開源項目，最早接觸它是在orchard項目中，在orchard里主要用在動態代理方法攔截上，當然這是castle最重要的作用，事實上它當然也可以實現IoC了，不過，你要下載一個Castle.Windsor.dll，它主要實現ioc功能的。

說干就干，事情和前兩個組件的工作場景是相似的，一個irepository，多種實現方式，ef,linq,nhibernate,ado.net等等，你可以根據你的需要去實現它，這只是最大層次上的多態，代碼可能是這樣：

泛型類版本

#region 泛型注入
    public interface IRepository<T>
    {
        void Insert(T entity);
    }

    public class EFRepository<T> : IRepository<T>
    {
        #region IRepository<T> 成員

        public void Insert(T entity)
        {
            Console.WriteLine("EFRepository泛型注入" + entity);
        }

        #endregion
    }
 #endregion

非泛型版本（泛型方法版本）

#region 非泛型注入
    public interface IRepository
    {
        void Insert<T>(T entity);
    }

    public class EFRepository : IRepository
    {
        #region IRepository<T> 成員

        public void Insert<T>(T entity)
        {
            Console.WriteLine("EFRepository非泛型注入" + entity);
        }

        #endregion
    }

    public class LINQRespository : IRepository
    {
        #region IRepository<T> 成員

        public void Insert<T>(T entity)
        {
            Console.WriteLine("LINQRepository非泛型注入" + entity);
        }

        #endregion
    }
    #endregion

對於這兩種類型，在castle配置上也略有不同，看代碼：

      <component   id="非泛型"   service="Test.IRepository,Test"   type="Test.EFRepository,Test" />
      <component   id="泛型"   service="Test.IRepository`1,Test"   type="Test.EFRepository`1,Test" />

上面的代碼是架構層次的，而對於具體的業務，如用戶方面的業務可能有多個版本的考慮，可能有代緩存的，不代緩存的，可能有發郵件的，也可能有發短信的，這是具體業務層次的多態，代碼可能是這樣的：

#region 服務是泛型，類型不是泛型

    public interface IMessageService<T>
    {
        void Sending(T entity);
    }
    public class UserService : IMessageService<User>
    {


        #region IMessageService<User> 成員

        public void Sending(User entity)
        {
            Console.WriteLine("用戶模塊發消息，采用Ｅ－Ｍail方式");
        }

        #endregion
    }

    public class ProductService : IMessageService<Product>
    {
        #region IMessageService<Product> 成員

        public void Sending(Product entity)
        {
            Console.WriteLine("產品模塊發消息采用短信");
        }

        #endregion
    }
    #endregion

看上面的代碼，一個發消息的業務，它對於不同的業務對象，可能有不同的實現方式，而這種方法，我們可以在配置文件中進行設置：

      <component   id="具體業務，接口為泛型，實現非泛型"   service="Test.IMessageService`1[[Test.User,Test]],Test"  
　　　　　 type="Test.UserService,Test" />

整個配置文件內容如下：

<configuration>
  <configSections>
    <section name="castle" type="Castle.Windsor.Configuration.AppDomain.CastleSectionHandler, Castle.Windsor"/>
  </configSections>
  <castle>
    <components>
      <component   id="非泛型"   service="Test.IRepository,Test"   type="Test.EFRepository,Test" />
      <component   id="泛型"   service="Test.IRepository`1,Test"   type="Test.EFRepository`1,Test" />
      <component   id="具體業務，接口為泛型，實現非泛型"   service="Test.IMessageService`1[[Test.User,Test]],Test"   type="Test.UserService,Test" />

    </components>
  </castle>
</configuration>

而castle容器的代碼也封裝了一下，改了上人的低版本的，呵呵　

    /// <summary>
    /// IOC容器
    /// </summary>
    public sealed class Container
    {
        #region Fields & Properies
        /// <summary>
        /// WindsorContainer object
        /// </summary>
        private WindsorContainer windsor;
        private IKernel kernel;
        public IKernel Kernel
        {
            get { return kernel; }
        }

        /// <summary>
        /// 容器實例
        /// </summary>
        private static readonly Container instance = new Container();
        public static Container Instance
        {
            get { return Container.instance; }
        }

        #endregion

        #region Constructors
        /// <summary>
        /// Constructor Method.
        /// Initialization IOC.
        /// </summary>
        public Container()
        {
            try
            {
                Castle.Core.Resource.ConfigResource source = new Castle.Core.Resource.ConfigResource();
                XmlInterpreter interpreter = new XmlInterpreter(source);
                windsor = new WindsorContainer(interpreter);
                kernel = windsor.Kernel;
            }
            catch (Exception)
            {
                throw;
            }
        }
        #endregion

        #region Public Methods
        /// <summary>
        /// Returns a component instance by the type of service.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public T Resolve<T>()
        {
            return kernel.Resolve<T>();
        }
        /// <summary>
        /// Release resource that be container used.
        /// </summary>
        public void Dispose()
        {
            kernel.Dispose();
        }
        #endregion

        #region Private Methods
        /// <summary>
        /// Returns a component instance by the service name.
        /// </summary>
        /// <param name="service"></param>
        /// <returns></returns>
        private object Resolve(Type service)
        {
            return kernel.Resolve(service);
        }

        /// <summary>
        /// Returns a component instance by the service name.
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        private object Resolve(String key)
        {
            return kernel.Resolve<object>(key);
        }
        #endregion

    }

在程序中調用它的代碼為：

 　　　　　　 IRepository iRepository = Container.Instance.Resolve<IRepository>();
            iRepository.Insert<User>(new User { Name = "ok" });

            IRepository<User> iRepository1 = Container.Instance.Resolve<IRepository<User>>();
            iRepository1.Insert(new User { Name = "ok" });

            IMessageService<User> r = (IMessageService<User>)Container.Instance.Resolve<IMessageService<User>>();
            r.Sending(new User { Name = "ok" });

運行的結果為：

感謝您的閱讀！