WCF代理是怎么工做的？用代码说话

时间 2019-11-09

标签 wcf 代理怎么代码说话繁體版

原文原文链接

1.WCF生成代理的方式html

2.WCF代理原理缓存

第一个问题引用一篇Robin's博文[WCF生成客户端对象方式解析] 讲述了建立客户端服务对象的方法app

1.代理构造法async

       a.开启服务后，添加服务引用ide

       b.知道元数据地址，经过svcutli.exe生成代理类和配置文件函数

       c.从服务契约DLL中导出元数据，而后更具本地的元数据文件生成代理类和配置文件测试

       d.知道元数据地址，本身编写代码生成（使用ServiceContractGenerator类等），生成代理类和配置文件优化

2.通道工厂（ChannelFactory<T>）ui

       a.知道终结点地址，绑定协议（ABC中的A和B）this

       b.只知道元数据终结点地址（代码中使用MetadataResover类获取服务信息）

文章最后附有代码：代码，能够下下来运行测试等。

下边来看看生成的代理是什么样的。

1.添加服务引用生成了一个继承自 System.ServiceModel.ClientBase<Wcf.Client.ServiceReference1.IService> 的 ServiceClient

public interface IService {
        
        [System.ServiceModel.OperationContractAttribute(Action="http://tempuri.org/IService/DoWork", ReplyAction="http://tempuri.org/IService/DoWorkResponse")]
        void DoWork();
        
        [System.ServiceModel.OperationContractAttribute(Action="http://tempuri.org/IService/GetData", ReplyAction="http://tempuri.org/IService/GetDataResponse")]
        Wcf.Client.ServiceReference1.MyData GetData(int field);
    }

 [System.Diagnostics.DebuggerStepThroughAttribute()]
    [System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "4.0.0.0")]
    public partial class ServiceClient : System.ServiceModel.ClientBase<Wcf.Client.ServiceReference1.IService>, Wcf.Client.ServiceReference1.IService {
        
        public ServiceClient() {
        }
        
        public ServiceClient(string endpointConfigurationName) : 
                base(endpointConfigurationName) {
        }
        
        public ServiceClient(string endpointConfigurationName, string remoteAddress) : 
                base(endpointConfigurationName, remoteAddress) {
        }
        
        public ServiceClient(string endpointConfigurationName, System.ServiceModel.EndpointAddress remoteAddress) : 
                base(endpointConfigurationName, remoteAddress) {
        }
        
        public ServiceClient(System.ServiceModel.Channels.Binding binding, System.ServiceModel.EndpointAddress remoteAddress) : 
                base(binding, remoteAddress) {
        }
        
        public void DoWork() {
            base.Channel.DoWork();
        }
        
        public Wcf.Client.ServiceReference1.MyData GetData(int field) {
            return base.Channel.GetData(field);
        }
    }
}

生成的代码中有接口，服务客户端（ServiceClient）

调用DoWork()和GetData(int field) 方法，是调用的 ClientBase<T>中Channel对象的DoWork()和GetData(field)方法

ClientBase<T>

public abstract class ClientBase<TChannel> : ICommunicationObject, IDisposable where TChannel : class
{
    ……//其余内容   
    protected TChannel Channel { get; }
    public ChannelFactory<TChannel> ChannelFactory { get; }
}

Channel 的类型是TChannel ，同时能够发现内部有个ChannelFactory。

2.使用ChannelFactory<T>

ChannelFactory<Proxys.IService> channelFactory = new ChannelFactory<Proxys.IService>(bind);
var channel = channelFactory.CreateChannel(address);
 using (channel as IDisposable)
 {
    channel.DoWork();
    Wcf.Proxys.MyData myData = channel.GetData(10);
}

每次咱们看代码都只能看到这里，却不能知道ClientBase<T>,ChannelFatctory<T>是怎么起到代理做用的，怎么把方法的调用转换成底层的交互的。

咱们来找找源头：(原本是想反编译ServiceModel.dll,反编译之后却不能看到代码方法体，好在Mono下有相应的模块内容,能够在“开源中国社区”看到一些代码)

ClientBase<T> Mono开源代码地址

212  protected TChannel Channel {
213  get { return (TChannel) (object) InnerChannel; }
214 }

看到212行代码，channel返回的属性InnerChannel

204  public IClientChannel InnerChannel {
205　　get {
206         if (inner_channel == null)
207                inner_channel = (IClientChannel) (object) CreateChannel ();
208              return inner_channel;
209          }
210     }

经过CreateChannel ()建立的对象

304     protected virtual TChannel CreateChannel ()
305     {
306         return ChannelFactory.CreateChannel ();
307     }

CreateChannel (）方法是用ChannelFactory.CreateChannel (); 建立对象

188     public ChannelFactory<TChannel> ChannelFactory {
189         get { return factory; }
190         internal set {
191             factory = value;
192             factory.OwnerClientBase = this;
193         }
194     }

跳转到 ChannelFactory<T>类地址

104     public TChannel CreateChannel ()
105     {
106         EnsureOpened ();
107
108         return CreateChannel (Endpoint.Address);
109     }

CreateChannel方法的一个重载方法

133     public virtual TChannel CreateChannel (EndpointAddress address, Uri via)
134     {
135
　　　#if MONOTOUCH
136         throw new InvalidOperationException ("MonoTouch does not support dynamic proxy code generation. Override this method or its caller to return specific client proxy instance");
137
　　#else
138         var existing = Endpoint.Address;
139         try {
140
141         Endpoint.Address = address;
142         EnsureOpened ();
143         Endpoint.Validate ();
144         Type type = ClientProxyGenerator.CreateProxyType (typeof (TChannel), Endpoint.Contract, false);
145         // in .NET and SL2, it seems that the proxy is RealProxy.
146         // But since there is no remoting in SL2 (and we have
147         // no special magic), we have to use different approach
148         // that should work either.
149         object proxy = Activator.CreateInstance (type, new object [] {Endpoint, this, address ?? Endpoint.Address, via});
150         return (TChannel) proxy;
151         } catch (TargetInvocationException ex) {
152             if (ex.InnerException != null)
153                 throw ex.InnerException;
154             else
155                 throw;
156         } finally {
157             Endpoint.Address = existing;
158         }
159
　　#endif
160     }

翻一下一下注释：在.NET和SL2.0中，看来好像这个代理是真实代理，由于在SL2.0中没有是用Remoting（而且也没有独特魔力），咱们必须是用不一样的方式使它依然可以工做运行起来。

这里注意两点：

    1.Type type = ClientProxyGenerator.CreateProxyType (typeof (TChannel), Endpoint.Contract, false);

2.object proxy = Activator.CreateInstance (type, new object [] {Endpoint, this, address ?? Endpoint.Address, via});

先来看看简单一点的第二个方法的解释：

MSDN中对对该Activator.CreateInstance(type,object[]) 的解释是”使用与指定参数匹配程度最高的构造函数建立指定类型的实例”

两个参数分别是：须要生成的对象的类；构造函数传入的参数，系统会更具参数的数量、顺序和类型的匹配程度调用相应的构造函数。

看看第一个方法原型是什么样子：

069     public static Type CreateProxyType (Type requestedType, ContractDescription cd, bool duplex)
070     {
071         ClientProxyKey key = new ClientProxyKey (requestedType, cd, duplex);
072         Type res;
073         lock (proxy_cache) {
074             if (proxy_cache.TryGetValue (key, out res))
075                 return res;
076         }
077
078         string modname = "dummy";
079         Type crtype =
080
#if !NET_2_1
081             duplex ? typeof (DuplexClientRuntimeChannel) :
082
#endif
083             typeof (ClientRuntimeChannel);
084
085         // public class __clientproxy_MyContract : (Duplex)ClientRuntimeChannel, [ContractType]
086         var types = new List<Type> ();
087         types.Add (requestedType);
088         if (!cd.ContractType.IsAssignableFrom (requestedType))
089             types.Add (cd.ContractType);
090         if (cd.CallbackContractType != null && !cd.CallbackContractType.IsAssignableFrom (requestedType))
091             types.Add (cd.CallbackContractType);
092         CodeClass c = new CodeModule (modname).CreateClass ("__clientproxy_" + cd.Name, crtype, types.ToArray ());
093
094         //
095         // public __clientproxy_MyContract (
096         //  ServiceEndpoint arg1, ChannelFactory arg2, EndpointAddress arg3, Uri arg4)
097         //  : base (arg1, arg2, arg3, arg4)
098         // {
099         // }
100         //
101         Type [] ctorargs = new Type [] {typeof (ServiceEndpoint), typeof (ChannelFactory), typeof (EndpointAddress), typeof (Uri)};
102         CodeMethod ctor = c.CreateConstructor (
103             MethodAttributes.Public, ctorargs);
104         CodeBuilder b = ctor.CodeBuilder;
105         MethodBase baseCtor = crtype.GetConstructors (
106             BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance) [0];
107         if (baseCtor == null) throw new Exception ("INTERNAL ERROR: ClientRuntimeChannel.ctor() was not found.");
108         b.Call (
109             ctor.GetThis (),
110             baseCtor,
111             new CodeArgumentReference (typeof (ServiceEndpoint), 1, "arg0"),
112             new CodeArgumentReference (typeof (ChannelFactory), 2, "arg1"),
113             new CodeArgumentReference (typeof (EndpointAddress), 3, "arg2"),
114             new CodeArgumentReference (typeof (Uri), 4, "arg3"));
115         res = CreateProxyTypeOperations (crtype, c, cd);
116
117         lock (proxy_cache) {
118             proxy_cache [key] = res;
119         }
120         return res;
121     }
122 }
123

注意内容：

1.内部使用了缓存。

2.使用了动态编译.

3.根据具不一样的duplex [in]生成不一样的类（代理）类型:

4.看看res = CreateProxyTypeOperations (crtype, c, cd); 这句话发生了什么

126     protected static Type CreateProxyTypeOperations (Type crtype, CodeClass c, ContractDescription cd)
127     {
128         // member implementation
129         BindingFlags bf = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
130         foreach (OperationDescription od in cd.Operations) {
131             // FIXME: handle properties and events.
132
#if !NET_2_1
133             if (od.SyncMethod != null)
134                 GenerateMethodImpl (c, crtype.GetMethod ("Process", bf), od.Name, od.SyncMethod);
135
#endif
136             if (od.BeginMethod != null)
137                 GenerateBeginMethodImpl (c, crtype.GetMethod ("BeginProcess", bf), od.Name, od.BeginMethod);
138             if (od.EndMethod != null)
139                 GenerateEndMethodImpl (c, crtype.GetMethod ("EndProcess", bf), od.Name, od.EndMethod);
140         }
141
142         Type ret = c.CreateType ();
143         return ret;
144     }

259     static void GenerateEndMethodImpl (CodeClass c, MethodInfo endProcessMethod, string name, MethodInfo mi)
260     {
261         CodeMethod m = c.ImplementMethod (mi);
262         CodeBuilder b = m.CodeBuilder;
263         ParameterInfo [] pinfos = mi.GetParameters ();
264
265         ParameterInfo p = pinfos [0];
266         CodeArgumentReference asyncResultRef = m.GetArg (0);
267          
268         CodeVariableDeclaration paramsDecl = new CodeVariableDeclaration (typeof (object []), "parameters");
269         b.CurrentBlock.Add (paramsDecl);
270         CodeVariableReference paramsRef = paramsDecl.Variable;
271         b.Assign (paramsRef,
272               new CodeNewArray (typeof (object), new CodeLiteral (pinfos.Length - 1)));
273         /**
274         for (int i = 0; i < pinfos.Length - 2; i++) {
275             ParameterInfo par = pinfos [i];
276             if (!par.IsOut)
277                 b.Assign (
278                     new CodeArrayItem (paramsRef, new CodeLiteral (i)),
279                     new CodeCast (typeof (object),
280                         new CodeArgumentReference (par.ParameterType, par.Position + 1, "arg" + i)));
281         }
282         */
283
#if USE_OD_REFERENCE_IN_PROXY
284         CodePropertyReference argMethodInfo = GetOperationMethod (m, b, name, "EndMethod");
285
#else
286         CodeMethodCall argMethodInfo = new CodeMethodCall (typeof (MethodBase), "GetCurrentMethod");
287
#endif
288         CodeLiteral argOperName = new CodeLiteral (name);
289          
290         CodeVariableReference retValue = null;
291        if (mi.ReturnType == typeof (void))
292             b.Call (m.GetThis (), endProcessMethod, argMethodInfo, argOperName, paramsRef, asyncResultRef);
293         else {
294             CodeVariableDeclaration retValueDecl = new CodeVariableDeclaration (mi.ReturnType, "retValue");
295             b.CurrentBlock.Add (retValueDecl);
296             retValue = retValueDecl.Variable;
297             b.Assign (retValue,
298                 new CodeCast (mi.ReturnType,
299                     b.CallFunc (m.GetThis (), endProcessMethod, argMethodInfo, argOperName, paramsRef, asyncResultRef)));
300         }
301         // FIXME: fill out parameters
302         if (retValue != null)
303             b.Return (retValue);
304     }

CreateProxyTypeOperations 看方法名就大概清楚：建立代理的操做（方法）。

GenerateEndMethodImpl 方法的具体实现。（最后这个方法很重要，不过部分代码我没有看明白，还请看明白的人还望不吝赐教）

ClientBase<T> 内部使用了 ChannelFactory<T>

这里使用的Mono代码说明、若是与.Net有区别也是有可能的。

至少基本说明了一个问题，代理是根据描述（元数据、接口等来源）动态生成“接口的对象”，

该对象的方法体（方法名、参数、返回值）都与接口一致，方法体对方法传入的值进行了处理。

只要获取到了传递过来的方法、参数、返回值信息等，就能够想怎么样就怎么样、随心所欲了。

C#客户端在调用WCF服务的时候，不少状况使用Remoting下RealProxy，RealProxy具备一个抽象的Invoke方法：public abstract IMessage Invoke(IMessage msg);

MSDN对RealProxy.Invoke(IMessage msg)方法的解释是地址

当调用受 RealProxy 支持的透明代理时，它将调用委托给 Invoke 方法。 Invoke 方法将 msg 参数中的消息转换为 IMethodCallMessage，并将其发送至 RealProxy 的当前实例所表示的远程对象。

好比：

public class CalculatorServiceRealProxy : RealProxy
    {
        public CalculatorServiceRealProxy():base(typeof(ICalculatorService)){}
        public override IMessage Invoke(IMessage msg)
        {
            IMethodReturnMessage methodReturn = null;
            IMethodCallMessage methodCall = (IMethodCallMessage)msg;
            var client = new ChannelFactory<ICalculatorService>("CalculatorService");
            var channel = client.CreateChannel();
            try
            {
                object[] copiedArgs = Array.CreateInstance(typeof(object), methodCall.Args.Length) as object[];
                methodCall.Args.CopyTo(copiedArgs, 0);
                object returnValue = methodCall.MethodBase.Invoke(channel, copiedArgs);
                methodReturn = new ReturnMessage(returnValue,
                                                copiedArgs,
                                                copiedArgs.Length,
                                                methodCall.LogicalCallContext,
                                                methodCall);
                //TODO:Write log
            }
            catch (Exception ex)
            {
                var exception = ex;
                if (ex.InnerException != null)
                    exception = ex.InnerException;
                methodReturn = new ReturnMessage(exception, methodCall);
            }
            finally
            {
                var commObj = channel as ICommunicationObject;
                if (commObj != null)
                {
                    try
                    {
                        commObj.Close();
                    }
                    catch (CommunicationException)
                    {
                        commObj.Abort();
                    }
                    catch (TimeoutException)
                    {
                        commObj.Abort();
                    }
                    catch (Exception)
                    {
                        commObj.Abort();
                        //TODO:Logging exception
                        throw;
                    }
                }
            }
            return methodReturn;
        }
    }

static void Main(string[] args)
        {

            ICalculatorService proxy = (ICalculatorService)new CalculatorServiceRealProxy().GetTransparentProxy();

            Console.WriteLine("x + y = {2} when x = {0} and y = {1}", 1, 2, proxy.Add(1, 2));
            Console.WriteLine("x - y = {2} when x = {0} and y = {1}", 1, 2, proxy.Subtract(1, 2));
            Console.WriteLine("x * y = {2} when x = {0} and y = {1}", 1, 2, proxy.Multiply(1, 2));
            Console.WriteLine("x / y = {2} when x = {0} and y = {1}", 1, 2, proxy.Divide(1, 2));


            Console.ReadKey();
        }

ICalculatorService proxy = (ICalculatorService)new CalculatorServiceRealProxy().GetTransparentProxy(); 获取到动态“实现”ICalculatorService 的实体对象，

每次调用的时候都会调用实现的RealProxy的Invoke方法

IMethodCallMessage methodCall = (IMethodCallMessage)msg; 把msg转换成 IMethodCallMessage ；

var channel = client.CreateChannel();这句话建立了代理对象；

object returnValue = methodCall.MethodBase.Invoke(channel, copiedArgs); 执行这个代理对象；

methodReturn = new ReturnMessage(returnValue,
                                                copiedArgs,
                                                copiedArgs.Length,
                                                methodCall.LogicalCallContext,
                                                methodCall); 返回值处理

这样的状况下使用了两次代理。

这样作就具备了AOP的特征，好处也不少

       1.作日志记录；

       2.异常处理；

       3.这个地方作了全部的远程链接操做，对调用这来说，与一般的非服务调用没有区别，好比这里的“关闭链接”；

上边的代码值得优化一下，好比：

1.CalculatorServiceRealProxy 应该改为CalculatorServiceRealProxy <T>，ICalculatorService 经过 T传入，这样灵活性增长很多。

2.endpointConfigurationName 应该也放到CalculatorServiceRealProxy 的构造函数上；或者系统作默认规则处理，好比：配置节点名称就是去掉相应接口名称前的“I”，等等。

但愿与你们多多交流 QQ:373934650;群Q:227231436

若是有用请大伙儿帮忙推荐一下，谢谢！

2014-7-24 03:00:43（待续）