IOC的容器确实不少，unity,autofac,Castle 等等，前两种组件如何实现ＩＯＣ在我之前的文章中已经做过说明了，今天主要来说一下Castle如何去实现IoC，事实上Castle是小微的一个开源项目，最早接触它是在orchard项目中，在orchard里主要用在动态代理方法拦截上，当然这是castle最重要的作用，事实上它当然也可以实现IoC了，不过，你要下载一个Castle.Windsor.dll，它主要实现ioc功能的。
说干就干，事情和前两个组件的工作场景是相似的，一个irepository，多种实现方式，ef,linq,nhibernate,ado.net等等，你可以根据你的需要去实现它，这只是最大层次上的多态，代码可能是这样：
泛型类版本
1 #region 泛型注入 2 public interface IRepository<T> 3 { 4 void Insert(T entity); 5 } 6 7 public class EFRepository<T> : IRepository<T> 8 { 9 #region IRepository<T> 成员 10 11 public void Insert(T entity) 12 { 13 Console.WriteLine("EFRepository泛型注入" + entity); 14 } 15 16 #endregion 17 } 18 #endregion
非泛型版本（泛型方法版本）
1 #region 非泛型注入 2 public interface IRepository 3 { 4 void Insert<T>(T entity); 5 } 6 7 public class EFRepository : IRepository 8 { 9 #region IRepository<T> 成员 10 11 public void Insert<T>(T entity) 12 { 13 Console.WriteLine("EFRepository非泛型注入" + entity); 14 } 15 16 #endregion 17 } 18 19 public class LINQRespository : IRepository 20 { 21 #region IRepository<T> 成员 22 23 public void Insert<T>(T entity) 24 { 25 Console.WriteLine("LINQRepository非泛型注入" + entity); 26 } 27 28 #endregion 29 } 30 #endregion
对于这两种类型，在castle配置上也略有不同，看代码：
<component id="非泛型" service="Test.IRepository,Test" type="Test.EFRepository,Test" /> <component id="泛型" service="Test.IRepository`1,Test" type="Test.EFRepository`1,Test" />
上面的代码是架构层次的，而对于具体的业务，如用户方面的业务可能有多个版本的考虑，可能有代缓存的，不代缓存的，可能有发邮件的，也可能有发短信的，这是具体业务层次的多态，代码可能是这样的：
1 #region 服务是泛型，类型不是泛型 2 3 public interface IMessageService<T> 4 { 5 void Sending(T entity); 6 } 7 public class UserService : IMessageService<User> 8 { 9 10 11 #region IMessageService<User> 成员 12 13 public void Sending(User entity) 14 { 15 Console.WriteLine("用户模块发消息，采用Ｅ－Ｍail方式"); 16 } 17 18 #endregion 19 } 20 21 public class ProductService : IMessageService<Product> 22 { 23 #region IMessageService<Product> 成员 24 25 public void Sending(Product entity) 26 { 27 Console.WriteLine("产品模块发消息采用短信"); 28 } 29 30 #endregion 31 } 32 #endregion
看上面的代码，一个发消息的业务，它对于不同的业务对象，可能有不同的实现方式，而这种方法，我们可以在配置文件中进行设置：
1 <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" });
运行的结果为：
感谢您的阅读！
本文转自博客园张占岭（仓储大叔）的博客，原文链接：Castle~实现IoC容器，如需转载请自行联系原博主。
