深入理解WCF系统体系(之二:WCF客户端如何构建？(下))

前一节介绍了WCF客户端构建的过程，其间又说明了WCF框架中核心ClientRuntime对象建立过程，以及客户端所采用的ClientMessageInspectors、ClientMessageFormatter、ClientOperationSelector等等基础。

---

 

 

本节目录：

1、RealProxy建立的过程

2、TransparentProxy建立的过程

3、服务调用过程。

4、总结 

 

 

1、RealProxy建立的过程

 

通过之前的介绍，大家都应该有个共识：客户端通过透明代理建立对应的实际代理对服务进行调用，而在WCF在实际代理对象类型为ServiceChannelProxy。实际代理对象ServiceChannelProxy的建立又是通过它的构造函数完成。先来看看它的构造函数：

 

  internal ServiceChannelProxy(Type interfaceType, Type proxiedType, MessageDirection direction, ServiceChannel serviceChannel) :  base(proxiedType)
    {
         if (!MessageDirectionHelper.IsDefined(direction))
        {
             throw DiagnosticUtility.ExceptionUtility.ThrowHelperError( new ArgumentOutOfRangeException( " direction "));
        }
         this.interfaceType = interfaceType;
         this.proxiedType = proxiedType;
         this.serviceChannel = serviceChannel;
         this.proxyRuntime = serviceChannel.ClientRuntime.GetRuntime();
         this.methodDataCache =  new MethodDataCache();
         this.objectWrapper =  new MbrObject( this, proxiedType);

    } 

 

在WCF客户端中，ChannelFactory通过绑定创建； 在  ChannelFactory创建的过程中，会初始化ServiceEndpoint；通过ServiceEndpoint又创建ServiceChannelFactory；通过ServiceChannelFactory

创建ServiceChannel。而ServiceChannelProxy接口中的Type类型就是契约接口类型，MessageDirection

是一个枚举类型，有Input\Output两个枚举值。这些类型，真实代理对象就创建成功。

通过以上述过程，真实代理对象就创建成功。

 

2、TransparentProxy建立的过程

 

首先看看一下代码：

 

var instanceContext =  new InstanceContext( new CalculatorCallback());
using ( var channkeFactory =  new DuplexChannelFactory<ICalculator>(instanceContext, " calculator "))
{                
    ICalculator proxy = channkeFactory.CreateChannel();        
}

通过上节的分析，通过channkeFactory.CreateChannel()得到的proxy就是TransparentProxy对象。那么channkeFactory通过CreateChannel创建TransparentProxy对象都经过了那些过程呢。？要了解这个过程，还得从源

码分析得出：

public  class DuplexChannelFactory<TChannel> : ChannelFactory<TChannel>
{
     public TChannel CreateChannel(InstanceContext callbackInstance)
    {
          return  this.CreateChannel(callbackInstance,  base.CreateEndpointAddress( base.Endpoint),  null);
    }

     public  static TChannel CreateChannel( object callbackObject,  string endpointConfigurationName)
    {
         return DuplexChannelFactory<TChannel>.CreateChannel(DuplexChannelFactory<TChannel>.GetInstanceContextForObject(callbackObject), endpointConfigurationName);
    }

     public  override TChannel CreateChannel(EndpointAddress address, Uri via)
    {
         return  this.CreateChannel( base.CallbackInstance, address, via);
    }

     public TChannel CreateChannel(InstanceContext callbackInstance, EndpointAddress address)
    {
         if (address ==  null)
        {
             throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull( " address ");
        }
         return  this.CreateChannel(callbackInstance, address, address.Uri);
    }

     public  static TChannel CreateChannel(InstanceContext callbackInstance,  string endpointConfigurationName)
    {
        TChannel channel =  new DuplexChannelFactory<TChannel>(callbackInstance, endpointConfigurationName).CreateChannel();
        ChannelFactory<TChannel>.SetFactoryToAutoClose(channel);
         return channel;
    }

     public  static TChannel CreateChannel( object callbackObject, Binding binding, EndpointAddress endpointAddress)
    {
         return DuplexChannelFactory<TChannel>.CreateChannel(DuplexChannelFactory<TChannel>.GetInstanceContextForObject(callbackObject), binding, endpointAddress);
    }

     public  static TChannel CreateChannel(InstanceContext callbackInstance, Binding binding, EndpointAddress endpointAddress)
    {
        TChannel channel =  new DuplexChannelFactory<TChannel>(callbackInstance, binding, endpointAddress).CreateChannel();
        ChannelFactory<TChannel>.SetFactoryToAutoClose(channel);
         return channel;
    }

     public  virtual TChannel CreateChannel(InstanceContext callbackInstance, EndpointAddress address, Uri via)
    {
         if (address ==  null)
        {
             throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull( " address ");
        }
         if (( base.CallbackType !=  null) && (callbackInstance ==  null))
        {
             throw DiagnosticUtility.ExceptionUtility.ThrowHelperError( new InvalidOperationException(SR.GetString( " SFxCreateDuplexChannelNoCallback1 ")));
        }
         if (callbackInstance ==  null)
        {
             throw DiagnosticUtility.ExceptionUtility.ThrowHelperError( new InvalidOperationException(SR.GetString( " SFxCreateDuplexChannelNoCallback ")));
        }
         if (callbackInstance.UserObject ==  null)
        {
             throw DiagnosticUtility.ExceptionUtility.ThrowHelperError( new InvalidOperationException(SR.GetString( " SFxCreateDuplexChannelNoCallbackUserObject ")));
        }
         if (! base.HasDuplexOperations())
        {
             throw DiagnosticUtility.ExceptionUtility.ThrowHelperError( new InvalidOperationException(SR.GetString( " SFxCreateDuplexChannel1 ",  new  object[] {  base.Endpoint.Contract.Name })));
        }
        Type c = callbackInstance.UserObject.GetType();
        Type callbackContractType =  base.Endpoint.Contract.CallbackContractType;
         if ((callbackContractType !=  null) && !callbackContractType.IsAssignableFrom(c))
        {
             throw DiagnosticUtility.ExceptionUtility.ThrowHelperError( new InvalidOperationException(SR.GetString( " SFxCreateDuplexChannelBadCallbackUserObject ",  new  object[] { callbackContractType })));
        }
         base.EnsureOpened();
        TChannel local = (TChannel)  base.ServiceChannelFactory.CreateChannel( typeof(TChannel), address, via);
        IDuplexContextChannel channel = local  as IDuplexContextChannel;
         if (channel !=  null)
        {
            channel.CallbackInstance = callbackInstance;
        }
         return local;
    }

     public  static TChannel CreateChannel( object callbackObject, Binding binding, EndpointAddress endpointAddress, Uri via)
    {
         return DuplexChannelFactory<TChannel>.CreateChannel(DuplexChannelFactory<TChannel>.GetInstanceContextForObject(callbackObject), binding, endpointAddress, via);
    }

     public  static TChannel CreateChannel(InstanceContext callbackInstance, Binding binding, EndpointAddress endpointAddress, Uri via)
    {
        TChannel channel =  new DuplexChannelFactory<TChannel>(callbackInstance, binding).CreateChannel(endpointAddress, via);
        ChannelFactory<TChannel>.SetFactoryToAutoClose(channel);
         return channel;
    }

}

查看以上代码，我们发现DuplexChannelFactory<TChannel>类的CreateChannel()方法中没有不带参数的，那它通过CreateChannel()方法创建TransparentProxy时，肯定是调用了基类的方法。

接下去分析ChannelFactory<TChannel>的CreateChannel方法。代码如下：

public  class ChannelFactory<TChannel> : ChannelFactory, IChannelFactory<TChannel>, IChannelFactory, ICommunicationObject
{
     public TChannel CreateChannel()
    {
         return  this.CreateChannel( base.CreateEndpointAddress( base.Endpoint),  null);
    }
     public  virtual TChannel CreateChannel(EndpointAddress address, Uri via)
    {
        TChannel local;
         bool traceOpenAndClose =  base.TraceOpenAndClose;
         try
        {
             using (ServiceModelActivity activity = (DiagnosticUtility.ShouldUseActivity &&  base.TraceOpenAndClose) ? ServiceModelActivity.CreateBoundedActivity() :  null)
            {
                 if (DiagnosticUtility.ShouldUseActivity)
                {
                    ServiceModelActivity.Start(activity,  this.OpenActivityName,  this.OpenActivityType);
                     base.TraceOpenAndClose =  false;
                }
                 if (address ==  null)
                {
                     throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull( " address ");
                }
                 if ( base.HasDuplexOperations())
                {
                     throw DiagnosticUtility.ExceptionUtility.ThrowHelperError( new InvalidOperationException(SR.GetString( " SFxCreateNonDuplexChannel1 ",  new  object[] {  base.Endpoint.Contract.Name })));
                }
                 base.EnsureOpened();
                local = (TChannel)  this.ServiceChannelFactory.CreateChannel( typeof(TChannel), address, via);
            }
        }
         finally
        {
             base.TraceOpenAndClose = traceOpenAndClose;
        }
         return local;
    }
}

 

注意到这一句：

local = (TChannel) this.ServiceChannelFactory.CreateChannel(typeof(TChannel), address, via);

继续分析ServiceChannelFactory.CreateChannel(typeof(TChannel), address, via)的过程：

internal  abstract  class ServiceChannelFactory : ChannelFactoryBase
{
     public  object CreateChannel(Type channelType, EndpointAddress address, Uri via)
    {
         if (via ==  null)
        {
            via =  this.ClientRuntime.Via;
             if (via ==  null)
            {
                via = address.Uri;
            }
        }
        ServiceChannel serviceChannel =  this.CreateServiceChannel(address, via);
        serviceChannel.Proxy = CreateProxy(channelType, channelType, MessageDirection.Input, serviceChannel);
        serviceChannel.ClientRuntime.GetRuntime().InitializeChannel((IClientChannel) serviceChannel.Proxy);
        OperationContext current = OperationContext.Current;
         if ((current !=  null) && (current.InstanceContext !=  null))
        {
            current.InstanceContext.WmiChannels.Add((IChannel) serviceChannel.Proxy);
            serviceChannel.WmiInstanceContext = current.InstanceContext;
        }
         return serviceChannel.Proxy;
    }

        [SecuritySafeCritical]
     internal  static  object CreateProxy(Type interfaceType, Type proxiedType, MessageDirection direction, ServiceChannel serviceChannel)
    {
      if (!proxiedType.IsInterface)
        {
             throw DiagnosticUtility.ExceptionUtility.ThrowHelperError( new InvalidOperationException(SR.GetString( " SFxChannelFactoryTypeMustBeInterface ")));
        }
        ServiceChannelProxy proxy =  new ServiceChannelProxy(interfaceType, proxiedType, direction, serviceChannel);
         return proxy.GetTransparentProxy();
    }
}

 

CreateChannel方法返回的是serviceChannel.Proxy，而serviceChannel.Proxy又是

proxy.GetTransparentProxy()获取到的TransparentProxy.

 

3、服务调用过程。

WCF客户端对服务接口的调用最终通过RealProxy对象，也就是ServiceChannelProxy的Invoke方法来完成。

下面来看看Invoke方法。

  public  override IMessage Invoke(IMessage message)
    {
        IMessage message3;
         try
        {
            IMethodCallMessage methodCall = message  as IMethodCallMessage;
             if (methodCall ==  null)
            {
                 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError( new ArgumentException(SR.GetString( " SFxExpectedIMethodCallMessage ")));
            }
            MethodData methodData =  this.GetMethodData(methodCall);
             switch (methodData.MethodType)
            {
                 case MethodType.Service:
                     return  this.InvokeService(methodCall, methodData.Operation);

                 case MethodType.BeginService:
                     return  this.InvokeBeginService(methodCall, methodData.Operation);

                 case MethodType.EndService:
                     return  this.InvokeEndService(methodCall, methodData.Operation);

                 case MethodType.Channel:
                     return  this.InvokeChannel(methodCall);

                 case MethodType.Object:
                     return  this.InvokeObject(methodCall);

                 case MethodType.GetType:
                     return  this.InvokeGetType(methodCall);
            }
             throw DiagnosticUtility.ExceptionUtility.ThrowHelperError( new InvalidOperationException( string.Format(CultureInfo.InvariantCulture,  " Invalid proxy method type ",  new  object[ 0])));
        }
         catch (Exception exception)
        {
             if (Fx.IsFatal(exception))
            {
                 throw;
            }
            message3 =  this.CreateReturnMessage(exception, message  as IMethodCallMessage);
        }
         return message3;
    }

 

 

 

3.1、MethodData的Service类型

 

MethodType.Service为同步调用方式；MethodType.BeginService、MethodType.EndService为异步方式。

首先看看MethodType.Service，它调用了ServiceChannelProxy的InvokeService方法完成。InvokeService方法定义如下：

     private IMethodReturnMessage InvokeService(IMethodCallMessage methodCall, ProxyOperationRuntime operation)
    {
         object[] objArray;
         object[] ins = operation.MapSyncInputs(methodCall,  out objArray);
         object ret =  this.serviceChannel.Call(operation.Action, operation.IsOneWay, operation, ins, objArray);
         object[] returnArgs = operation.MapSyncOutputs(methodCall, objArray,  ref ret);
         return  this.CreateReturnMessage(ret, returnArgs, methodCall);
    }

 

可以看出，在  InvokeService中，通过serviceChannel.Call返回调用结果，最有又通过ServerChannelProxy的

CreateReturnMessage方法返回Message。

ProxyOperationRuntime在WCF中也是很重要的对象。它的定义以及构造函数如下：

internal  class ProxyOperationRuntime
{
     //  Fields
     private  string action;
     private MethodInfo beginMethod;
     private  bool deserializeReply;
     internal  static  readonly  object[] EmptyArray =  new  object[ 0];
     private ParameterInfo[] endOutParams;
     private  readonly IClientFaultFormatter faultFormatter;
     private  readonly IClientMessageFormatter formatter;
     private ParameterInfo[] inParams;
     private  readonly  bool isInitiating;
     private  readonly  bool isOneWay;
     private  readonly  bool isTerminating;
     private  readonly  string name;
     internal  static  readonly ParameterInfo[] NoParams =  new ParameterInfo[ 0];
     private ParameterInfo[] outParams;
     private  readonly IParameterInspector[] parameterInspectors;
     private  readonly ImmutableClientRuntime parent;
     private  string replyAction;
     private ParameterInfo returnParam;
     private  bool serializeRequest;
     private MethodInfo syncMethod;

     //  Methods
     internal ProxyOperationRuntime(ClientOperation operation, ImmutableClientRuntime parent)
    {
         if (operation ==  null)
        {
             throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull( " operation ");
        }
         if (parent ==  null)
        {
             throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull( " parent ");
        }
         this.parent = parent;
         this.formatter = operation.Formatter;
         this.isInitiating = operation.IsInitiating;
         this.isOneWay = operation.IsOneWay;
         this.isTerminating = operation.IsTerminating;
         this.name = operation.Name;
         this.parameterInspectors = EmptyArray<IParameterInspector>.ToArray(operation.ParameterInspectors);
         this.faultFormatter = operation.FaultFormatter;
         this.serializeRequest = operation.SerializeRequest;
         this.deserializeReply = operation.DeserializeReply;
         this.action = operation.Action;
         this.replyAction = operation.ReplyAction;
         this.beginMethod = operation.BeginMethod;
         this.syncMethod = operation.SyncMethod;
         if ( this.beginMethod !=  null)
        {
             this.inParams = ServiceReflector.GetInputParameters( this.beginMethod,  true);
             if ( this.syncMethod !=  null)
            {
                 this.outParams = ServiceReflector.GetOutputParameters( this.syncMethod,  false);
            }
             else
            {
                 this.outParams = NoParams;
            }
             this.endOutParams = ServiceReflector.GetOutputParameters(operation.EndMethod,  true);
             this.returnParam = operation.EndMethod.ReturnParameter;
        }
         else  if ( this.syncMethod !=  null)
        {
             this.inParams = ServiceReflector.GetInputParameters( this.syncMethod,  false);
             this.outParams = ServiceReflector.GetOutputParameters( this.syncMethod,  false);
             this.returnParam =  this.syncMethod.ReturnParameter;
        }
         if (( this.formatter ==  null) && ( this.serializeRequest ||  this.deserializeReply))
        {
             throw DiagnosticUtility.ExceptionUtility.ThrowHelperError( new InvalidOperationException(SR.GetString( " ClientRuntimeRequiresFormatter0 ",  new  object[] {  this.name })));
        }
    }

    [SecurityCritical]
     internal  object[] MapSyncInputs(IMethodCallMessage methodCall,  out  object[] outs)
    {
         if ( this.outParams.Length ==  0)
        {
            outs = EmptyArray;
        }
         else
        {
            outs =  new  object[ this.outParams.Length];
        }
         if ( this.inParams.Length ==  0)
        {
             return EmptyArray;
        }
         return methodCall.InArgs;
    }

        [SecurityCritical]
     internal  object[] MapSyncOutputs(IMethodCallMessage methodCall,  object[] outs,  ref  object ret)
    {
         return  this.MapOutputs( this.outParams, methodCall, outs,  ref ret);
    }

        [SecurityCritical]
     private  object[] MapOutputs(ParameterInfo[] parameters, IMethodCallMessage methodCall,  object[] outs,  ref  object ret)
    {
         if ((ret ==  null) && ( this.returnParam !=  null))
        {
            ret = GetDefaultParameterValue(TypeLoader.GetParameterType( this.returnParam));
        }
         if (parameters.Length ==  0)
        {
             return  null;
        }
         object[] args = methodCall.Args;
         for ( int i =  0; i < parameters.Length; i++)
        {
             if (outs[i] ==  null)
            {
                args[parameters[i].Position] = GetDefaultParameterValue(TypeLoader.GetParameterType(parameters[i]));
            }
             else
            {
                args[parameters[i].Position] = outs[i];
            }
        }
         return args;
    }

    /
    ****/
 }

 

IMethodCallMessage的InArgs：获取未标记为 out 参数的参数数组；Args：获取传递给该方法的参数数组（MSDN中的定义）。

 

那么最核心的ServiceChannel的Call方法又做了什么事情呢。。？让我们看看它的定义：

internal  object Call( string action,  bool oneway, ProxyOperationRuntime operation,  object[] ins,  object[] outs)
    {
         return  this.Call(action, oneway, operation, ins, outs,  this.operationTimeout);
    }

     internal  object Call( string action,  bool oneway, ProxyOperationRuntime operation,  object[] ins,  object[] outs, TimeSpan timeout)
    {
         this.ThrowIfDisallowedInitializationUI();
         this.ThrowIfIdleAborted(operation);
        ProxyRpc rpc =  new ProxyRpc( this, operation, action, ins, timeout);
         using (rpc.Activity = DiagnosticUtility.ShouldUseActivity ? ServiceModelActivity.CreateBoundedActivity() :  null)
        {
             if (DiagnosticUtility.ShouldUseActivity)
            {
                ServiceModelActivity.Start(rpc.Activity, SR.GetString( " ActivityProcessAction ",  new  object[] { action }), ActivityType.ProcessAction);
            }
             this.PrepareCall(operation, oneway,  ref rpc);
             if (! this.explicitlyOpened)
            {
                 this.EnsureDisplayUI();
                 this.EnsureOpened(rpc.TimeoutHelper.RemainingTime());
            }
             else
            {
                 this.ThrowIfOpening();
                 base.ThrowIfDisposedOrNotOpen();
            }
             try
            {
                ConcurrencyBehavior.UnlockInstanceBeforeCallout(OperationContext.Current);
                 if (oneway)
                {
                     this.binder.Send(rpc.Request, rpc.TimeoutHelper.RemainingTime());
                }
                 else
                {
                    rpc.Reply =  this.binder.Request(rpc.Request, rpc.TimeoutHelper.RemainingTime());
                     if (rpc.Reply ==  null)
                    {
                         base.ThrowIfFaulted();
                         throw DiagnosticUtility.ExceptionUtility.ThrowHelperError( new CommunicationException(SR.GetString( " SFxServerDidNotReply ")));
                    }
                }
            }
             finally
            {
                 this.CompletedIOOperation();
                CallOnceManager.SignalNextIfNonNull( this.autoOpenManager);
                ConcurrencyBehavior.LockInstanceAfterCallout(OperationContext.Current);
            }
            rpc.OutputParameters = outs;
             this.HandleReply(operation,  ref rpc);
        }
         return rpc.ReturnValue;

} 

上面代码中有至关重要的一段：

 

if (oneway) 

                {
                    this.binder.Send(rpc.Request, rpc.TimeoutHelper.RemainingTime());
                }
                else
                {
                    rpc.Reply = this.binder.Request(rpc.Request, rpc.TimeoutHelper.RemainingTime());
         }

  

 通过是否单程oneway，来进行Send或者Request。那binder由是什么对象呢。。？

在ServiceChannel中，定义：

privatereadonly IChannelBinder binder。这点可以从RealProxy对象中可以看出来：

 

 

在本例中使用netTcpBinding绑定，所以binder为DuplexChannelBinder。不同的协议类型，

binder就不一样。以wsHttpBinding为例，它的binder为RequestChannelBinder。

 

 DuplexChannelBinder的Send与Request定义如下：

 

       public  void Send(Message message, TimeSpan timeout) 

      {
        this.channel.Send(message, timeout);
      }

     public Message Request(Message message, TimeSpan timeout)
     {
        SyncDuplexRequest request = null;
        bool flag = false;
        RequestReplyCorrelator.PrepareRequest(message);
        lock (this.ThisLock)
        {
            if (!this.Pumping)
            {
                flag = true;
                this.syncPumpEnabled = true;
            }
            if (!flag)
            {
                request = new SyncDuplexRequest(this);
            }
            this.RequestStarting(message, request);
        }
        if (flag)
        {
            TimeoutHelper helper = new TimeoutHelper(timeout);
            UniqueId messageId = message.Headers.MessageId;
            try
            {
                this.channel.Send(message, helper.RemainingTime());
                if ((DiagnosticUtility.ShouldUseActivity && (ServiceModelActivity.Current != null)) && (ServiceModelActivity.Current.ActivityType == ActivityType.ProcessAction))
                {
                    ServiceModelActivity.Current.Suspend();
                }
                while (true)
                {
                    Message message2;
                    do
                    {
                        TimeSpan span = helper.RemainingTime();
                        if (!this.channel.TryReceive(span, out message2))
                        {
                            throw TraceUtility.ThrowHelperError(this.GetReceiveTimeoutException(timeout), message);
                        }
                        if (message2 == null)
                        {
                            this.AbortRequests();
                            return null;
                        }
                        if (message2.Headers.RelatesTo == messageId)
                        {
                            this.ThrowIfInvalidReplyIdentity(message2);
                            return message2;
                        }
                    }
                    while (this.HandleRequestAsReply(message2));
                    if (DiagnosticUtility.ShouldTraceInformation)
                    {
                        EndpointDispatcher endpointDispatcher = null;
                        if ((this.ChannelHandler != null) && (this.ChannelHandler.Channel != null))
                        {
                            endpointDispatcher = this.ChannelHandler.Channel.EndpointDispatcher;
                        }
                        TraceUtility.TraceDroppedMessage(message2, endpointDispatcher);
                    }
                    message2.Close();
                }
            }
            finally
            {
                lock (this.ThisLock)
                {
                    this.RequestCompleting(null);
                    this.syncPumpEnabled = false;
                    if (this.pending > 0)
                    {
                        this.EnsurePumping();
                    }
                }
            }
        }
    TimeoutHelper helper2 = new TimeoutHelper(timeout);
        this.channel.Send(message, helper2.RemainingTime());
        this.EnsurePumping();
        return request.WaitForReply(helper2.RemainingTime());
    }

 

在Request中，除了调用Channel的Send方法以外，还调用了SyncDuplexRequest的WaitForReply返回消息。

SyncDuplexRequest的WaitForReply定义如下：

 

    

     internal Message WaitForReply(TimeSpan timeout)

    {
        try
        {
            if (!TimeoutHelper.WaitOne(this.wait, timeout))
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(this.parent.GetReceiveTimeoutException(timeout));
            }
        }
        finally
        {
            this.CloseWaitHandle();
        }
        this.parent.ThrowIfInvalidReplyIdentity(this.reply);
        return this.reply;
    }

 

 

3.2MethodData的Channel类型：

 

  private IMethodReturnMessage InvokeChannel(IMethodCallMessage methodCall)
    {
         string str =  null;
        ActivityType unknown = ActivityType.Unknown;
         if (DiagnosticUtility.ShouldUseActivity && ((ServiceModelActivity.Current ==  null) || (ServiceModelActivity.Current.ActivityType != ActivityType.Close)))
        {
            MethodData methodData =  this.GetMethodData(methodCall);
             if ((methodData.MethodBase.DeclaringType ==  typeof(ICommunicationObject)) && methodData.MethodBase.Name.Equals( " Close ", StringComparison.Ordinal))
            {
                str = SR.GetString( " ActivityClose ",  new  object[] {  this.serviceChannel.GetType().FullName });
                unknown = ActivityType.Close;
            }
        }
         using (ServiceModelActivity activity =  string.IsNullOrEmpty(str) ?  null : ServiceModelActivity.CreateBoundedActivity())
        {
             if (DiagnosticUtility.ShouldUseActivity)
            {
                ServiceModelActivity.Start(activity, str, unknown);
            }
             return  this.ExecuteMessage( this.serviceChannel, methodCall);
        }
    }

         private IMethodReturnMessage ExecuteMessage( object target, IMethodCallMessage methodCall)
    {
        MethodBase methodBase = methodCall.MethodBase;
         object[] args = methodCall.Args;
         object ret =  null;
         try
        {
            ret = methodBase.Invoke(target, args);
        }
         catch (TargetInvocationException exception)
        {
             return  this.CreateReturnMessage(exception.InnerException, methodCall);
        }
         return  this.CreateReturnMessage(ret, args, args.Length,  null, methodCall);
    }

 

对于Channel，直接调用methodBase.Invoke进行调用

 

 

3.3、MethodData的Object类型

 

private IMethodReturnMessage InvokeObject(IMethodCallMessage methodCall)
    {
         return RemotingServices.ExecuteMessage( this.objectWrapper, methodCall);
    }
RemotingServices中ExecuteMessage的定义如下：
    [SecurityPermission(SecurityAction.LinkDemand, Flags=SecurityPermissionFlag.Infrastructure)]
     public  static IMethodReturnMessage ExecuteMessage(MarshalByRefObject target, IMethodCallMessage reqMsg)
    {
         if (target ==  null)
        {
             throw  new ArgumentNullException( " target ");
        }
        RealProxy realProxy = GetRealProxy(target);
         if ((realProxy  is RemotingProxy) && !realProxy.DoContextsMatch())
        {
             throw  new RemotingException(Environment.GetResourceString( " Remoting_Proxy_WrongContext "));
        }
        StackBuilderSink sink =  new StackBuilderSink(target);
         return (IMethodReturnMessage) sink.SyncProcessMessage(reqMsg,  0,  true);
    }
StackBuilderSink中SyncProcessMessage的处理过程：
         public  virtual IMessage SyncProcessMessage(IMessage msg)
    {
         return  this.SyncProcessMessage(msg,  0,  false);
    }

         internal  virtual IMessage SyncProcessMessage(IMessage msg,  int methodPtr,  bool fExecuteInContext)
    {
        IMessage message3;
        IMessage message = InternalSink.ValidateMessage(msg);
         if (message !=  null)
        {
             return message;
        }
        IMethodCallMessage message2 = msg  as IMethodCallMessage;
        LogicalCallContext threadCallContext =  null;
         object obj2 = CallContext.GetLogicalCallContext().GetData( " __xADCall ");
         bool flag =  false;
         try
        {
             object server =  this._server;
            VerifyIsOkToCallMethod(server, message2);
            LogicalCallContext callCtx =  null;
             if (message2 !=  null)
            {
                callCtx = message2.LogicalCallContext;
            }
             else
            {
                callCtx = (LogicalCallContext) msg.Properties[ " __CallContext "];
            }
            threadCallContext = CallContext.SetLogicalCallContext(callCtx);
            flag =  true;
            callCtx.PropagateIncomingHeadersToCallContext(msg);
            PreserveThreadPrincipalIfNecessary(callCtx, threadCallContext);
             if ( this.IsOKToStackBlt(message2, server) && ((Message) message2).Dispatch(server, fExecuteInContext))
            {
                message3 =  new StackBasedReturnMessage();
                ((StackBasedReturnMessage) message3).InitFields((Message) message2);
                LogicalCallContext context4 = CallContext.GetLogicalCallContext();
                context4.PropagateOutgoingHeadersToMessage(message3);
                ((StackBasedReturnMessage) message3).SetLogicalCallContext(context4);
                 return message3;
            }
            MethodBase methodBase = GetMethodBase(message2);
             object[] outArgs =  null;
             object ret =  null;
            RemotingMethodCachedData reflectionCachedData = InternalRemotingServices.GetReflectionCachedData(methodBase);
             object[] args = Message.CoerceArgs(message2, reflectionCachedData.Parameters);
            ret =  this.PrivateProcessMessage(methodBase.MethodHandle, args, server, methodPtr, fExecuteInContext,  out outArgs);
             this.CopyNonByrefOutArgsFromOriginalArgs(reflectionCachedData, args,  ref outArgs);
            LogicalCallContext logicalCallContext = CallContext.GetLogicalCallContext();
             if (((obj2 !=  null) && (( bool) obj2)) && (logicalCallContext !=  null))
            {
                logicalCallContext.RemovePrincipalIfNotSerializable();
            }
            message3 =  new ReturnMessage(ret, outArgs, (outArgs ==  null) ?  0 : outArgs.Length, logicalCallContext, message2);
            logicalCallContext.PropagateOutgoingHeadersToMessage(message3);
            CallContext.SetLogicalCallContext(threadCallContext);
        }
         catch (Exception exception)
        {
            message3 =  new ReturnMessage(exception, message2);
            ((ReturnMessage) message3).SetLogicalCallContext(message2.LogicalCallContext);
             if (flag)
            {
                CallContext.SetLogicalCallContext(threadCallContext);
            }
        }
         return message3;

 

 

3.4MethodData的GetType类型

 

private IMethodReturnMessage InvokeGetType(IMethodCallMessage methodCall)
    {
         return  this.CreateReturnMessage( this.proxiedType,  null,  0, SetActivityIdInLogicalCallContext(methodCall.LogicalCallContext), methodCall);
    }
      private IMethodReturnMessage CreateReturnMessage( object ret,  object[] outArgs,  int outArgsCount, LogicalCallContext callCtx, IMethodCallMessage mcm)
    {
         return  new ReturnMessage(ret, outArgs, outArgsCount, callCtx, mcm);
    }

 

它调用了ReturnMessage的如下构造函数：

 

   public ReturnMessage( object ret,  object[] outArgs,  int outArgsCount, LogicalCallContext callCtx, IMethodCallMessage mcm)   

 {
        this._ret = ret;
        this._outArgs = outArgs;
        this._outArgsCount = outArgsCount;
        if (callCtx != null)
        {
            this._callContext = callCtx;
        }
        else
        {
            this._callContext = CallContext.GetLogicalCallContext();
        }
        if (mcm != null)
        {
            this._URI = mcm.Uri;
            this._methodName = mcm.MethodName;
            this._methodSignature = null;
            this._typeName = mcm.TypeName;
            this._hasVarArgs = mcm.HasVarArgs;
            this._methodBase = mcm.MethodBase;
        }
    }

 

4、总结：

  WCF的客户端框架中介绍了很多MS封装的内部对象，整个流程的说明介绍这些对象时根据流程的介绍的需要进行

了一些介绍。下面对这些对象做个总结以认清它们之间的关系。

4.1、WCF客户端流程：

WCF客户端流程如下图：

 

上图流程说明：

    1、由DuplexChannelFactory的父类：ChannelFactory<TChannel>的父类ChannelFactory初始化

Endpoint。

 2、ChannelFactory调用ServiceChannelFactroy的BuildChannelFactory,通过初始化的Endpoint创建

ServiceChannelFactroy。（根据契约需要的通道形状，会生成继承自ServiceChannelFactory的

ServiceChannelFactoryOverX，）

   3、ServiceChannelFactroy创建ServiceChannelFactroy的过程中，会初始化ClientRuntime对象

    4、ServiceChannelFactoryOverX通过CreateInnerChannelBinder创建IChannelBinder对象。

   5、ServiceChannelFactoryOverX通过CreateInnerChannelBinder方法创建IChannelBinder对象

   6、ServiceChannelFactoryOverX通过CreateChannel创建ServiceChannel,并通过ImmutableClientRuntime初始化Channel。

   7、实际代理ServiceChannelProxy 通过ServiceChannel对象，契约接口定义生成RealProxy。

   8、通过RealProxy获取TransparentProxy对象

   9、TransparentProxy对象调用服务

   10、ServiceChannel通过IChannelBinder对象发送消息

 

4.2、WCF客户端使用到的对象关系

在这两节分析WCF客户端时，介绍了很多内部 对象。通过UML关系图描述一下这些类型之间的关系：

 

在上图中，以接口为分界线，上半部分生成ServiceChannel；下半部分生成调用服务的代理。 

 4.3、ServiceChannel生成时序图

最后后通过时序图介绍一下ServiceChannel、IChannelBinder对象生成过程：

 

 

备注：本节以及前一节中所有流程的说明都是以netTcpBiding作为传输协议来进行的，其他协议也类似。

分类:  WCF架构体系