基于Autofac, Castle.DynamicProxy的动态WCF解决方案(原创)

本方案解决了下面3个主要的问题：

1、减少配置，为了避免每次新增service都需要去修改配置文件，包括服务器端跟各个客户端的。

2、能够使用函数重载，泛型函数，以及泛型类。

3、使项目能够快速地在wcf与直接调用dll之间切换。

整个解决方案分为四块内容：1、客户端，2、契约层，3、服务端，4、实现层

1、客户端：只能看到契约层，而看不到具体的实现；但也可以通过直接引用实现层，从而脱离wcf（需要修改工厂方法，也可以改进一下，通过配置文件来做这个事情，但这个不是本解决方案的重点，有兴趣的可以自己去实现）。

2、契约层：包含DTO对象模型跟各个服务接口

3、服务端：能看到契约层跟实现层

4、实现层：使用Autofac跟Castle.DynamicProxy进行IOC跟AOP（动态代理中的拦截器）

为解决第一个问题，早些年，已有人通过只暴露WCF的一个服务，而向该服务传递类名，函数名，参数数组来解决这一问题，但是用字符串在我看来实在是不太好，谁能保证自己在编码的时候不会把字符串给写错呢，而且万一需要更改服务名，vs的代码重构机制也处理不了字符串。所以我觉得利用接口，应该是最好的解决方案，但问题是谁又能在不知道具体的实现类的情况下，而针对接口凭空实例化出来一个对象呢。答案是有的，用Emit指令，不过Emit指令实在是有点难。此时我又想到了单元测试中常用的Rhino Mocks跟moq框架，便去查看了它们的源代码，我发现其中一个用的.net自带的真实代理(RealProxy)，另外个用的是Castle.DynamicProxy，个人比较喜欢Castle.DynamicProxy，就用了它的CreateInterfaceProxyWithoutTarget，然后在自定义的拦截器中去调用实际的WCF服务，将返回回来的值设置给invocation.ReturnValue。

并且针对方法中的传引用的参数，进行了处理，使其能够对传引用的参数进行赋值。

下图为整个解决方案的结构：

测试的接口：

 public interface IMyTest
     {
         int Test1();
         void Test2();
         int Test3(int value);
         TestModel Test4(ref TestModel T);
         void Test5(TestModel T);
         void Test6(out int value);
         void Test7(ref int value);
         int Test8(int value = );
         int Test9(int value1 = , int value2 = );
         int Test10(params int[] values);
         int Test11(ref List<int> lst);
         int Test12(TestEnumModel m);
         TestEnumModel Test13(TestEnumModel m);
         T Test14<T>(T m);
         string Test14<T>(T m, int value);
         string Test14<T>(T m, string value);
         string Test14<T>(T m, TestModel model);
     }

IMyTest接口

 public interface IMyTest2<T>
     {
         T Test(T aa);
     }

IMyTest2泛型接口

DTO对象：

 public class TestModel
     {
         public int A { get; set; }
     }

 public class TestImpModel : TestModel
     {
         public string B { get; set; }
     }

 public enum TestEnumModel
     {
         A = ,
         B =
     }

DTO对象们

具体实现：

 internal class MyTest : IMyTest
     {
         public int Test1()
         {
             return ;
         }

         public void Test2()
         {

         }

         public int Test3(int value)
         {
             return value + ;
         }

         public TestModel Test4(ref TestModel T)
         {
             T.A = T.A + ;
             return T;
         }

         public void Test5(TestModel T)
         {
             T.A = T.A + ;
         }

         public void Test6(out int value)
         {
             value = ;
         }

         public void Test7(ref int value)
         {
             value++;
         }

         public int Test8(int value = )
         {
             return value;
         }

         public int Test9(int value1 = , int value2 = )
         {
             return value1 + value2;
         }

         public int Test10(params int[] values)
         {
             return values.Sum();
         }

         public int Test11(ref List<int> lst)
         {
             lst.Add();
             return lst.Sum();
         }

         public int Test12(TestEnumModel m)
         {
             return (int)m;
         }

         public TestEnumModel Test13(TestEnumModel m)
         {
             return m;
         }

         public T Test14<T>(T m)
         {
             return m;
         }

         public string Test14<T>(T m, int value)
         {
             return m.ToString() + value.ToString();
         }

         public string Test14<T>(T m, string value)
         {
             return m.ToString() + value;
         }

         public string Test14<T>(T m, TestModel model)
         {
             model.A += ;
             return m.ToString() + model.A.ToString();
         }
     }

实现了IMyTest的MyTest类

 internal class MyTest2<T> : IMyTest2<T>
     {
         public T Test(T aa)
         {
             return aa;
         }
     }

实现了IMyTest2的MyTest2泛型类

测试用例：

 [TestMethod]
         public void TestMethod1()
         {
             Assert.AreEqual(, MyCreator.Create<IMyTest>().Test1());
         }

         [TestMethod]
         public void TestMethod2()
         {
             MyCreator.Create<IMyTest>().Test2();
         }

         [TestMethod]
         public void TestMethod3()
         {
             Assert.AreEqual(, MyCreator.Create<IMyTest>().Test3());
             Assert.AreEqual(, MyCreator.Create<IMyTest>().Test3());
         }

         [TestMethod]
         public void TestMethod4()
         {
             var tm = new TestModel() { A =  };
             var t = MyCreator.Create<IMyTest>().Test4(ref tm);
             Assert.AreEqual(, t.A);
             Assert.AreEqual(, tm.A);
         }

         [TestMethod]
         public void TestMethod5()
         {
             var t = new TestModel() { A =  };
             MyCreator.Create<IMyTest>().Test5(t);
             Assert.AreEqual(, t.A);
         }

         [TestMethod]
         public void TestMethod6()
         {
             int i = ;
             MyCreator.Create<IMyTest>().Test6(out i);
             Assert.AreEqual(, i);
         }

         [TestMethod]
         public void TestMethod7()
         {
             int i = ;
             MyCreator.Create<IMyTest>().Test7(ref i);
             Assert.AreEqual(, i);
         }

         [TestMethod]
         public void TestMethod8()
         {
             Assert.AreEqual(, MyCreator.Create<IMyTest>().Test8());
         }

         [TestMethod]
         public void TestMethod9()
         {
             Assert.AreEqual(, MyCreator.Create<IMyTest>().Test9(value2: ));
         }

         [TestMethod]
         public void TestMethod10()
         {
             Assert.AreEqual(, MyCreator.Create<IMyTest>().Test10(, ));
         }

         [TestMethod]
         public void TestMethod11()
         {
             List<int> lst = new List<int>();
             Assert.AreEqual(, MyCreator.Create<IMyTest>().Test11(ref lst));
             Assert.AreEqual(, lst.Count);
             Assert.AreEqual(, lst[]);
         }

         [TestMethod]
         public void TestMethod12()
         {
             Assert.AreEqual(, MyCreator.Create<IMyTest>().Test12(TestEnumModel.B));
         }

         [TestMethod]
         public void TestMethod13()
         {
             Assert.AreEqual(TestEnumModel.B, MyCreator.Create<IMyTest>().Test13(TestEnumModel.B));
         }

         [TestMethod]
         public void TestMethod14()
         {
             Assert.AreEqual(TestEnumModel.B, MyCreator.Create<IMyTest>().Test14(TestEnumModel.B));
         }

         [TestMethod]
         public void TestMethod15()
         {
             Assert.AreEqual("B123", MyCreator.Create<IMyTest>().Test14(TestEnumModel.B, ));
         }

         [TestMethod]
         public void TestMethod16()
         {
             Assert.AreEqual("Baaaaa", MyCreator.Create<IMyTest>().Test14(TestEnumModel.B, "aaaaa"));
         }

         [TestMethod]
         public void TestMethod17()
         {
             TestImpModel m = new TestImpModel() { A = , B = "" };
             Assert.AreEqual("B2", MyCreator.Create<IMyTest>().Test14(TestEnumModel.B, m));
             Assert.AreEqual(, m.A);
             Assert.AreEqual("", m.B);
         }

         [TestMethod]
         public void TestMethod18()
         {
             TestImpModel m = new TestImpModel() { A = , B = "" };
             var n = MyCreator.Create<IMyTest2<TestImpModel>>().Test(m);
             Assert.AreEqual(, n.A);
             Assert.AreEqual("", n.B);
         }

18个简单的测试用例

项目源代码：DynamicWCF.rar