实现框架之前，我想先讲一讲为什么我会写这篇文章。

　　暑假期间，我在一家软件公司实习。在8月15这天（周一）早上，项目小组组长对我说：“IOC和AOP在项目中经常用到，我希望你能用这两种技术实现一个简单框架”。

　　"IOC”、"AOP"，我的天，我听都没听过，这是什么。组长说："我一会儿会发给你一些资料和一个例子，你再查查资料，学习学习，给你两周时间"。好吧，只能这样，框架还是听过，但没做过，对于一些没做过的东西，人总是觉得很神秘、很深奥，不容易做，但当你做过之后才发现，它们只是人们用一些已有的技术手段实现的一些想法，并不太难。

　　IOC：(Inversion of Control)  中文意思是“控制反转” 还有一个原理相同的概念是：Dependency Injection（依赖注入）

　　AOP：Aspect Oriented Programming-面向方面编程，确切的说应是：面向切面编程。

　　上面这两个概念要想详细了解解决什么问题可以查资料，在这就不多说了。

　　在查资料和学习的过程中我很痛苦，为什么呢？因为我除了懂得这些原理以外，我还想找个确切的实例，但是找个确切的例子凭的是人品，一般网上说的例子都很零散，有的只给其中的一段代码，你不能看到程序运行的过程；有的只是给出了其中一方面的例子，你也不知道怎样有机的结合起来，你还是不能完全看到整个过程；有的虽然给出了整个实现代码，但还是引用了一些dll文件，你也不能看到这些dll文件中是怎样实现的。有些人说的云里雾里的，不是很懂。于是我经过两周实现一个简单框架之后就想将这个例子共享出来，让后来学习的人能容易入手。

　　IOC实际好处就是消除耦合或者降低耦合，减轻以后软件维护的难度，一般主要用到反射。

　　可以使用反射动态地创建类型的实例，将类型绑定（其实就是对象引用实例，绑定我刚开始也不懂）到现有对象，然后，可以调用实例的方法等。

　　首先我们先做一个通用的可以得到实例的类：Instance.cs

View Code 
 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Text;
 5 using System.Xml;
 6 using System.Reflection;
 7 
 8 namespace MyIOC.IOC
 9 {
10     class Instance
11     {
12         public static object GetInstance(String key)
13         {
14             String className = null;
15             object obj = null;
16             XmlDocument doc = new XmlDocument();
17 
18             // 加载配置文件
19             doc.Load("App.config");
20 
21             XmlNode classNode;
22 
23             // 得到根节点
24             XmlNode root = doc.DocumentElement;
25             
26             classNode = root.SelectSingleNode("descendant::class[key='" + key + "']");
27 
28             //得到子节点集
29             XmlNodeList list = classNode.ChildNodes;
30 
31             // 得到类名
32             foreach(XmlNode node in list)
33             {
34                 // 得到节点名为“class-name”的节点
35                 if (node.Name.Equals("class-name"))
36                 {
37                     className = node.InnerText;
38                 }     
39             }
40 
41             if (className != null)
42             {
43                 // 得到UserPerssion的类型
44                 Type t = Type.GetType(className);
45 
46                 // 得到UserPermission的实例
47                 obj = Activator.CreateInstance(t);
48             }
49             
50             return obj;
51         }
52     }
53 }

　　配置文件主要写反射所需要的类的信息

　　App.config配置文件内容如下：

View Code 
 1 <?xml version="1.0" encoding="utf-8" ?>
 2 <configuration xmlns:bk="urn:samples">
 3   
 4   <class>
 5     <key>IUserPermission</key>
 6     <class-name>MyIOC.IOC.UserPermission</class-name>
 7   </class>
 8   
 9   <class>
10     <key>IData</key>
11     <class-name>MyIOC.Data</class-name>
12   </class>
13   
14 </configuration>

　　为了方便演示，我们反射项目中的一个类，你可以看到和上面配置文件的关系,实际应用中一般是引用外部dll文件，一般这些dll是处理日志记录，性能统计，安全控制，事务处理，异常处理这些与业务逻辑无关的东西，比如我们要验证一个人的权限，我们就不需要满世界的写验证权限的代码。下面给出的就是反射时需要验证权限的接口与实现类

　　IUserPermission.cs

View Code 
 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Text;
 5 
 6 namespace MyIOC.IOC
 7 {
 8     interface IUserPermission
 9     {
10         void HasPermission(String name);
11     }
12 }

　　UserPermission.cs

View Code 
 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Text;
 5 using System.Windows.Forms;
 6 
 7 namespace MyIOC.IOC
 8 {
 9     class UserPermission : IUserPermission 
10     {
11         private String name = "user";
12 
13         #region IUserPermission Members
14 
15         public void HasPermission(string name)
16         {
17             if (this.name.Equals(name))
18             {
19                 Console.WriteLine("you have the permission");
20             }
21             else
22             {
23                 Console.WriteLine("you haven't the permission");
24             }
25         }
26 
27         #endregion
28     }
29 }

　　其实使用接口也是方便日后维护，如果以后我们不用UserPermission这样验证权限，我们就可以在定义一个类UserPermission2去实现接口IUserPermission，在配置文件里用UserPermission2替换UserPermission即可，如果你不用接口，你就要修改每一处使用UserPermission的地方，这样不是很麻烦。

　　顺便说一下，这个验证权限与具体的业务逻辑无关，这里也就体现了面向切面编程的思想，假如我们要写数据，我们就要自动验证权限，看有没有写数据的权限，所以程序写到这我们还不能实现自动验证权限，下一步我们就要用拦截器进行拦截，关于拦截器的的原理和使用我建议你看这篇博文

　　首先定义一个接收器

　　InterceptorContext.cs

　　

View Code 
 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Text;
 5 using System.Runtime.Remoting.Messaging;
 6 using MyIOC.IOC;
 7 
 8 namespace AOP
 9 {
10    
11     public class InterceptorContext : IMessageSink //实现IMessageSink
12     {
13         private IMessageSink nextSink;  //保存下一个接收器
14 
15         //在构造器中初始化下一个接收器
16         public InterceptorContext(IMessageSink next)
17         {
18             nextSink = next;
19         }
20 
21         //必须实现的IMessageSink接口属性
22         public IMessageSink NextSink
23         {
24             get
25             {
26                 return nextSink;
27             }
28         }
29 
30         //实现IMessageSink的接口方法，当消息传递的时候，该方法被调用
31         public IMessage SyncProcessMessage(IMessage msg)
32         {
33             //拦截消息，做前处理
34             beforeProcess(msg);
35 
36             //传递消息给下一个接收器
37             IMessage retMsg = nextSink.SyncProcessMessage(msg);
38 
39             //调用返回时进行拦截，并进行后处理
40             afterProcess(msg, retMsg);
41             return retMsg;
42         }
43 
44         //IMessageSink接口方法，用于异步处理，我们不实现异步处理，所以简单返回null,
45         //不管是同步还是异步，这个方法都需要定义
46         public IMessageCtrl AsyncProcessMessage(IMessage msg, IMessageSink replySink)
47         {
48             return null;
49         }
50 
51         private void beforeProcess(IMessage msg)
52         {
53             //检查是否是方法调用，我们只拦截Data的WriteData方法。
54             IMethodCallMessage callMes = msg as IMethodCallMessage;
55 
56             if (callMes == null)
57                 return;
58 
59             if (callMes.MethodName == "WriteData")
60             {
61                 IUserPermission userPermission = (IUserPermission)Instance.GetInstance("IUserPermission");
62                 userPermission.HasPermission("user"); 
63                 
64             }
65         }
66 
67         // 写入日志文件
68         private void afterProcess(IMessage msg, IMessage retMsg)
69         {
70             IMethodCallMessage callMes = msg as IMethodCallMessage;
71 
72             if (callMes == null)
73                 return;
74             Console.WriteLine("Log the operation");
75         }
76     }  
77 }

　　上面61行就是使用反射得到一个UserPermission的实例。但是在这块没有扩展性，我们只能拦截Data的WriteData（）的方法，所以要提高扩展性，我们还是要配置我们的App.config文件，利用反射来确定我们拦截哪些方法，你可以试着实现。上面的写入日志文件也要使用反射来实现，为了演示，我们就这样简单处理了。你可以将它重写，so easy 啦！

　　下来我们定义上下文环境的属性，至于为什么要定义这个，请再看上面推荐的博文

　　InterceptorProperty.cs

View Code 
 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Text;
 5 using System.Runtime.Remoting.Contexts;
 6 using System.Runtime.Remoting.Messaging;
 7 
 8 namespace AOP
 9 {
10     class InterceptorProperty : IContextProperty, IContributeObjectSink
11     {
12         public InterceptorProperty()
13         {
14         }
15 
16         //IContributeObjectSink的接口方法，实例化消息接收器
17         public IMessageSink GetObjectSink(MarshalByRefObject obj, IMessageSink next)
18         {
19             return new InterceptorContext(next);
20         }
21 
22         //IContextProperty接口方法，如果该方法返回ture,在新的上下文环境中激活对象
23         public bool IsNewContextOK(Context newCtx)
24         {
25             return true;
26         }
27 
28         //IContextProperty接口方法，提供高级使用
29         public void Freeze(Context newCtx)
30         {
31         }
32 
33         //IContextProperty接口属性
34         public string Name
35         {
36             get { return "DataTrace"; }
37         }
38 
39     }
40 }

　　接着是ContextAttribute
　　InterceptorAttribute.cs

View Code 
 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Text;
 5 using System.Runtime.Remoting.Contexts;
 6 using System.Runtime.Remoting.Activation;
 7 
 8 namespace AOP
 9 {
10     [AttributeUsage(AttributeTargets.Class)]
11     class InterceptorAttribute : ContextAttribute
12     {
13         public InterceptorAttribute()
14             : base("Interceptor")
15       {
16       }
17       
18       //重载ContextAttribute方法，创建一个上下文环境属性
19       public override void GetPropertiesForNewContext(IConstructionCallMessage ctorMsg)
20       {
21           ctorMsg.ContextProperties.Add(new InterceptorProperty());
22       }
23    }    
24 }

　　至此，我们利用IOC和AOP实现的框架就完成了，虽然程序不长，但涉及的知识比较多。

　　好了，激动人心的时刻到了，我们现在可以使用我们的框架了。

　　首先我们设定一个IData接口，还是那句话，使用接口易于维护。

　　IData.cs

View Code 
 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Text;
 5 
 6 namespace MyIOC
 7 {
 8     interface IData
 9     {
10         void WriteData(String data);
11     }
12 }

　　实现它：　

　　Data.cs

View Code 
 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Text;
 5 using AOP;
 6 
 7 namespace MyIOC
 8 {
 9     [Interceptor]
10     class Data : ContextBoundObject, IData
11     {
12         public void WriteData(String data)
13         {
14             Console.WriteLine(data);
15         }
16     }
17 }

　　第9行的　[Interceptor] 是一个拦截标志，要不程序怎么知道拦截哪里的方法呢？ 在InterceptorAttribute.cs的第14行你也可以看到它。

　　最后看看我们是怎么WriteData的

　　Program.cs

View Code 
 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Text;
 5 using System.Reflection;
 6 using MyIOC.IOC;
 7 
 8 namespace MyIOC
 9 {
10     class Program
11     {
12         static void Main(string[] args)
13         {
14             IData data = (IData)Instance.GetInstance("IData");
15             data.WriteData("you have write some data");
16             Console.ReadLine();
17         }
18     }
19 }

　　在主程序中，我们只写了三句话，其实只是两句，我们利用反射得到Data的实例，然后调用WriteData的方法，当然我们的Data也在App.config需要注册，看看配置文件，是不是这样。　　

　　看看运行结果：

　　you have the permission
　　you have write some data
　　Log the operation

　　OK，我们可以看到我们只利用反射得到Data的实例，然后调用了WriteData的方法，结果在写那句话之前，拦截器拦截到了这个消息，进行了权限验证，然后输出那句话，最后在日志文件中写入的这个操作。
　　最后，我希望我这个小例子可以帮助你了解AOP、IOC和框架，当然这只是我浅浅的一些理解，如果有什么错误不足之处，希望大师批评指正，但拒绝人参公鸡。

作者: 叮咚客 发表于 2011-08-27 20:23 原文链接

关键字 利用ioc和aop实现一个简单框架,完整
推荐.NET配套的通用数据层ORM框架：CYQ.Data 通用数据层框架
新浪微博粉丝精灵，刷粉丝、刷评论、刷转发、企业商家微博营销必备工具"