通过一个模拟程序让你明白WCF大致的执行流程

在《通过一个模拟程序让你明白ASP.NET MVC是如何运行的》一文中我通过一个普通的ASP.NET Web程序模拟了ASP.NET MVC的执行流程，现在我们通过类似的原理创建一个用于模拟WCF服务端和客户端工作原理的模拟程序。[源代码从这里下载]

目录
一、基本的组件和执行流程
二、创建自定义HttpHandler实现对服务调用请求的处理
三、定义创建WCF组件的工厂
四、定义HttpModule映射WcfHandler
五、创建自定义的真实代理实现服务的调用
六、定义服务代理工厂
七、服务“寄宿”和调用

一、基本的组件和执行流程

我们只模拟WCF完成一个简单的服务调用所必需的组件和流程，右图反映了进行服务调用的必要步骤和使用的相关WCF组件。下面列出了服务端涉及的组件和流程：

• 请求消息的接收和回复消息的发送：服务端在传输层监听与接收来自客户的请求，并将经过编码后的回复消息通过传输层发送到客户端；
• 请求消息的解码和回复消息的编码：将接收到的字节数组通过解码生成请求消息对象，并将回复消息通过编码转化成字节数组。消息的编码和解码通过消息编码器（MessageEncoder）完成，而消息编码器工厂（MessageEncoderFactory）负责创建该对象；
• 请求消息的反序列化和回复消息的序列化：对请求消息进行反序列化，为服务操作的执行生成相应的输入参数，以及将服务操作执行的结果（返回值或输出/引用参数）序列化，并生成回复消息。序列化和反序列化通过分发消息格式化器（DispatchMessageFormatter）完成；
• 服务对象的创建：创建或激活服务对象实例，实例提供者（InstanceProvider）用于服务对象的创建或获取，本例直接通过反射创建服务实例；
• 服务操作的执行：调用创建的服务对象的操作方法，并传入经过反序列化生成的输入参数。操作调用器（OperationInvoker）完成对服务操作的最终执行。

相较于服务端的请求监听、消息接收、服务实例激活和操作调用流程，客户端的处理流程显得相对简单，仅仅包含以下3个必需的步骤：

• 请求消息的序列化和回复消息的反序列化：生成请求消息并将输入参数序列化到请求消息中，以及对回复消息进行反序列化，转化成方法调用的返回值或输出/引用参数。序列化和反序列化通过ClientMessageFormatter完成；
• 请求消息的编码和回复消息的解码：对请求消息进行编码生成字节数组供传输层发送，以及将传输层接收到的字节数组解码生成回复消息。消息的编码和解码通过消息编码器完成，而消息编码器工厂负责创建该对象；
• 请求消息的发送和回复消息的接收：在传输层将经过编码的请求消息发送到服务端，以及接收来自服务端的回复消息。

本实例的解决方法依然采用包含Service.Interface、Service和Client三个项目的结构，不过Service项目现在是一个Web应用。也就是说我们通过一个Web应用的方式实现WCF端对服务调用请求的整个处理流程。

二、创建自定义HttpHandler实现对服务调用请求的处理

对于一个ASP.NET Web应用来说，对请求的处理最终都落实到一个具体的HttpHandler对象上，所以我们通过实现接口System.Web.IHttpHandler自定义了如下一个WcfHandler用于处理针对WCF服务请求的处理。

public class WcfHandler: IHttpHandler
{
    //其他成员
    public Type ServiceType { get; private set; }
    public MessageEncoderFactory MessageEncoderFactory { get; private set; }
    public IDictionary<string, MethodInfo> Methods { get; private set; }
    public IDictionary<string, IDispatchMessageFormatter> MessageFormatters { get; private set; }
    public IDictionary<string, IOperationInvoker> OperationInvokers { get; private set; }

    public bool IsReusable
    {
        get { return false; }
    }

    public WcfHandler(Type serviceType, MessageEncoderFactory messageEncoderFactory)
    {
        this.ServiceType = serviceType;
        this.MessageEncoderFactory = messageEncoderFactory;
        this.Methods = new Dictionary<string, MethodInfo>();
        this.MessageFormatters = new Dictionary<string, IDispatchMessageFormatter>();
        this.OperationInvokers = new Dictionary<string, IOperationInvoker>();
    }
}

如上面代码所示，上述的关于WCF服务端框架所需的组件以只读属性的方式体现在WcfHandler上。ServiceType属性表示服务的类型，基于这个类型通过反射创建服务实例。消息编码器工厂通过MessageEncoderFactory属性表示，两个字典类型的属性MessageFormatters和OperationInvokers代表基于操作的分发消息格式化器和操作调用器列表，字典的Key为操作请求消息的<Action>报头的值。而Methods表示契约接口所有操作方法的MethodInfo集合。

针对WCF服务的请求处理实现在如下的ProcessRequest方法中，执行的逻辑也不算复杂。我们直接通过消息编码器工厂创建的消息编码从当前HTTP请求的输入流中读取出消息。然后根据当前消息的<Action>报头的值从MessageFormatters属性中找到与当前请求操作相匹配的分发消息格式化器对消息进行反序列化。

接着直接通过反射的方式根据服务类型创建服务实例对象。同样根据当前消息的<Action>报头从OperationInvokers属性获取出基于当前请求操作的操作调用器，并将创建的服务实例和反序列化后生成的参数作为输入执行操作方法。

操作的执行结果通过分发消息格式化器进行序列化生成的消息最终通过消息编码器写入当前HTTP回复的输出流中返回给客户端。

public class WcfHandler: IHttpHandler
{
    //其他成员
    public void ProcessRequest(HttpContext context)
    {
        //对HttpPRequest进行解码生成请求消息对象
        Message request = this.MessageEncoderFactory.Encoder.ReadMessage(context.Request.InputStream, int.MaxValue, "application/soap+xml; charset=utf-8");

        //通过请求消息得到代表服务操作的Action
        string action = request.Headers.Action;

        //通过Action从MethodInfo字典中获取服务操作对应的MethodInfo对象
        MethodInfo method = this.Methods[action];

        //得到输出参数的数量
        int outArgsCount = 0;
        foreach (var parameter in method.GetParameters())
        {
            if (parameter.IsOut)
            {
                outArgsCount++;
            }
        }

        //创建数组容器，用于保存请求消息反序列后生成的输入参数对象
        int inputArgsCount = method.GetParameters().Length - outArgsCount;
        object[] parameters = new object[inputArgsCount];
        try
        {
            this.MessageFormatters[action].DeserializeRequest(request, parameters);
        }
        catch
        {}

        List<object> inputArgs = new List<object>();
        object[] outArgs = new object[outArgsCount];
        //创建服务对象，在WCF中服务对象通过InstanceProvider创建

        object serviceInstance = Activator.CreateInstance(this.ServiceType);

        //执行服务操作
        object result = this.OperationInvokers[action].Invoke(serviceInstance,parameters, out outArgs);

        //将操作执行的结果（返回值或者输出参数）序列化生成回复消息
        Message reply = this.MessageFormatters[action].SerializeReply(request.Version, outArgs, result);
        context.Response.ClearContent();
        context.Response.ContentEncoding = Encoding.UTF8;
        context.Response.ContentType = "application/soap+xml; charset=utf-8";

        //对回复消息进行编码，并将编码后的消息通过HttpResponse返回
        this.MessageEncoderFactory.Encoder.WriteMessage(reply, context.Response.OutputStream);
        context.Response.Flush();
    }
}

三、定义创建WCF组件的工厂

对于本例来说，客户端和服务端需要的组件主要有四类，即消息编码器工厂、分发消息格式化器、客户端消息格式化器和操作调用器。我们通过具有如下定义的静态的工厂类ComponentBuilder来创建它们。我们调用操作行为DataContractSerializerOperationBehavior的GetFormatter方法来创建基于指定操作的消息格式化器。不过该方法是一个内部方法，所以我们是通过反射的方式来调用的。isProxy参数表示创建的是客户端消息格式化器（True）还是分发消息格式化器（False）。

消息编码器工厂通过基于文本编码方式绑定元素TextMessageEncodingBindingElement的CreateMessageEncoderFactory创建，传入的参数分别表示消息的版本和文本编码类型。我们采用SyncMethodInvoker以同步的方式进行操作的执行。由于SyncMethodInvoker是一个内部类型，所以我们不得不采用反射的方式来创建它。

public static class ComponentBuilder
{
    public static object GetFormatter(OperationDescription operation, bool isProxy)
    {
        bool formatRequest = false;
        bool formatReply = false;
        DataContractSerializerOperationBehavior behavior = new DataContractSerializerOperationBehavior(operation);
        MethodInfo method = typeof(DataContractSerializerOperationBehavior).GetMethod("GetFormatter", BindingFlags.Instance | BindingFlags.NonPublic);
        return method.Invoke(behavior, new object[] { operation, formatRequest, formatReply, isProxy });
    }

    public static MessageEncoderFactory GetMessageEncoderFactory(MessageVersion messageVersion, Encoding writeEncoding)
    {
        TextMessageEncodingBindingElement bindingElement = new TextMessageEncodingBindingElement(messageVersion, writeEncoding);
        return bindingElement.CreateMessageEncoderFactory();
    }
    public static IOperationInvoker GetOperationInvoker(MethodInfo method)
    {
        string syncMethodInvokerType = "System.ServiceModel.Dispatcher.SyncMethodInvoker, System.ServiceModel, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089";
        Type type = Type.GetType(syncMethodInvokerType);
        return (IOperationInvoker)Activator.CreateInstance(type, new object[]{method});
    }
}

四、定义HttpModule映射WcfHandler

我们通过HttpModule的方式将用于处理WCF服务请求的映射到相应的WCF服务调用请求，为此我们定义了如下一个实现了System.Web.IHttpModule接口的WcfHttpModule类型。WcfHttpModule通过注册HttpApplication的BeginRequest事件的方式将创建的WcfHandler映射为处理当前HTTP请求的HttpHandler。

public class WcfHttpModule: IHttpModule
{
    public void Dispose() {}

    public void Init(HttpApplication context)
    {
        context.BeginRequest += (sender, args) =>
            {
                string relativeAddress = HttpContext.Current.Request.AppRelativeCurrentExecutionFilePath.Remove(0,2);
                Type serviceType = RouteTable.Routes.Find(relativeAddress);
                if (null == serviceType)
                {
                    return;
                }
                IHttpHandler handler = this.CreateHttpHandler(serviceType);
                context.Context.RemapHandler(handler);
            };
    }
    protected IHttpHandler CreateHttpHandler(Type serviceType)
    {
        MessageEncoderFactory encoderFactory = ComponentBuilder.GetMessageEncoderFactory(MessageVersion.Default, Encoding.UTF8);
        WcfHandler handler = new WcfHandler(serviceType, encoderFactory);
        Type interfaceType = serviceType.GetInterfaces()[0];
        ContractDescription contract = ContractDescription.GetContract(interfaceType);
        foreach (OperationDescription operation in contract.Operations)
        {
            IDispatchMessageFormatter messageFormatter = (IDispatchMessageFormatter)ComponentBuilder.GetFormatter(operation, false);
            handler.MessageFormatters.Add(operation.Messages[0].Action, messageFormatter);

            IOperationInvoker operationInvoker = ComponentBuilder.GetOperationInvoker(operation.SyncMethod);
            handler.OperationInvokers.Add(operation.Messages[0].Action, operationInvoker);

            handler.Methods.Add(operation.Messages[0].Action, operation.SyncMethod);
        }
        return handler;
    }
}

至于WcfHandler的创建，需要确定服务的类型。而服务的类型只能根据请求的地址来确定，这个IIS寄宿根据.svc文件来创建ServiceHost的原理是一样的。对于本例来说，我们需要对请求的地址和服务类型作一个映射，为此我们定义了如下一个RouteMapping的类型表示这个映射。

public class RouteMapping
{
    public string Address { get; private set; }
    public Type ServiceType { get; private set; }
    public RouteMapping(string address, Type serviceType)
    {
        this.Address = address;
        this.ServiceType = serviceType;
    }
}

而映射表则通过如下一个继承自Collection<RouteMapping>的RouteTable来定义。泛型的Register<T>方法用于注册地址与服务类型的映射关系，而Find方法则根据地址获取相应的服务类型。静态属性Routes表示当前被使用的映射表，而在WcfHttpModule中正是通过这个静态属性根据解析出来的地址得到用于创建WcfHandler的服务类型的。

public class RouteTable: Collection<RouteMapping>
{
    public static RouteTable Routes{get; private set;}
    static RouteTable()
    {
        Routes = new RouteTable();
    }
    public Type Find(string address)
    {
        RouteMapping routeMapping =  (from route in this
                where string.Compare(route.Address, address,true) == 0
                select route).FirstOrDefault();
        return null == routeMapping? null: routeMapping.ServiceType;
    }

    public void Register<T>(string address)
    {
        this.Add(new RouteMapping(address, typeof(T)));
    }
}

五、创建自定义的真实代理实现服务的调用

ChannelFactory<TChannel>创建的服务代理仅仅是一个透明代理，而真实实现服务调用的是它的真实代理。为此我们创建了如下一个继承自RealProxy的泛型的ServiceChannelProxy<TChannel>，其中泛型参数为契约接口类型。

public class ServiceChannelProxy<TChannel>: RealProxy
{
    //其他成员
    public Uri Address { get; private set; }
    public MessageVersion MessageVersion { get; private set; }
    public IDictionary<string, IClientMessageFormatter> MessageFormatters { get; private set; }
    public MessageEncoderFactory MessageEncoderFactory { get; private set; }

    public ServiceChannelProxy(Uri address, MessageVersion messageVersion, MessageEncoderFactory encoderFactory): base(typeof(TChannel))
    {
        this.Address = address;
        this.MessageVersion = messageVersion;
        this.MessageEncoderFactory = encoderFactory;
        this.MessageFormatters = new Dictionary<string, IClientMessageFormatter>();
    }
}

和WcfHttpHandler类似，进行服务调用所需的组件通过相应的只读属性表示。属性MessageEncoderFactory表示消息编码器工厂，而字典类型的MessageFormatters表示基于每个操作的客户端消息格式化器列表，其中的Key为操作的名称。属性Address表示被调用服务的地址。

针对透明代理的方法调用最终都会转移到针对真实真实代理的Invoke方法，所以我们将所有的服务调用操作实现在如下的Invoke方法中。我们首先获取代表当前调用方法的MethodBase上应用的OperationContractAttribute特性，并借此获得操作名称。

根据获取的操作名称从属性MessageFormatters属性中获得基于当前操作的客户端消息格式化器，并将方法调用转化消息。接着根据Address属性表示的服务调用地址创建EndpointAddress对象并将其附加到请求消息中。除此之外，还需要为请求消息添加一些必要的报头（比如<MessageId>和<ReplyTo>）。

接下来通过消息编码器工厂创建的消息编码器对消息进行编码，并将得到的字节数据通过创建的HttpWebRequest对象发送出去。对于得到的HttpWebResponse，则通过消息编码器进行解码以生成回复消息。回复消息最终通过客户端消息格式化器进行反序列化，得到的对象映射为方法返回值和输出/引用参数返回。

public class ServiceChannelProxy<TChannel>: RealProxy
{
    //其他成员
    public override IMessage Invoke(IMessage msg)
    {
        IMethodCallMessage methodCall = (IMethodCallMessage)msg;

        //得到操作名称
        object[] attributes = methodCall.MethodBase.GetCustomAttributes(typeof(OperationContractAttribute), true);
        OperationContractAttribute attribute = (OperationContractAttribute)attributes[0];
        string operationName = string.IsNullOrEmpty(attribute.Name) ? methodCall.MethodName : attribute.Name;

        //序列化请求消息
        Message requestMessage = this.MessageFormatters[operationName].SerializeRequest(this.MessageVersion, methodCall.InArgs);

        //添加必要的WS-Address报头
        EndpointAddress address = new EndpointAddress(this.Address);
        requestMessage.Headers.MessageId = new UniqueId(Guid.NewGuid());
        requestMessage.Headers.ReplyTo = new EndpointAddress("http://www.w3.org/2005/08/addressing/anonymous");
        address.ApplyTo(requestMessage);

        //对请求消息进行编码，并将编码生成的字节发送通过HttpWebRequest向服务端发送
        HttpWebRequest webRequest = (HttpWebRequest)HttpWebRequest.Create(this.Address);
        webRequest.Method = "Post";
        webRequest.KeepAlive = true;
        webRequest.ContentType = "application/soap+xml; charset=utf-8";
        ArraySegment<byte> bytes = this.MessageEncoderFactory.Encoder.WriteMessage(requestMessage, int.MaxValue, BufferManager.CreateBufferManager(long.MaxValue, int.MaxValue));
        webRequest.ContentLength = bytes.Array.Length;
        webRequest.GetRequestStream().Write(bytes.Array, 0, bytes.Array.Length);
        webRequest.GetRequestStream().Close();
        WebResponse webResponse = webRequest.GetResponse();

        //对HttpResponse进行解码生成回复消息.
        Message responseMessage = this.MessageEncoderFactory.Encoder.ReadMessage(webResponse.GetResponseStream(), int.MaxValue);

        //回复消息进行反列化生成相应的对象，并映射为方法调用的返回值或者ref/out参数
        object[] allArgs = (object[])Array.CreateInstance(typeof(object),methodCall.ArgCount);
        Array.Copy(methodCall.Args, allArgs, methodCall.ArgCount);
        object[] refOutParameters = new object[GetRefOutParameterCount(methodCall.MethodBase)];
        object returnValue = this.MessageFormatters[operationName].DeserializeReply(responseMessage, refOutParameters);
        MapRefOutParameter(methodCall.MethodBase, allArgs, refOutParameters);

        //通过ReturnMessage的形式将返回值和ref/out参数返回
        return new ReturnMessage(returnValue, allArgs, allArgs.Length, methodCall.LogicalCallContext, methodCall);
    }

    private int GetRefOutParameterCount(MethodBase method)
    {
        int count = 0;
        foreach (ParameterInfo parameter in method.GetParameters())
        {
            if (parameter.IsOut || parameter.ParameterType.IsByRef)
            {
                count++;
            }
        }
        return count;
    }

    private void MapRefOutParameter(MethodBase method, object[] allArgs,object[] refOutArgs)
    {
        List<int> refOutParamPositionsList = new List<int>();
        foreach (ParameterInfo parameter in method.GetParameters())
        {
            if (parameter.IsOut || parameter.ParameterType.IsByRef)
            {
                refOutParamPositionsList.Add(parameter.Position);
            }
        }
        int[] refOutParamPositionArray = refOutParamPositionsList.ToArray();
        for (int i = 0; i < refOutArgs.Length; i++)
        {
            allArgs[refOutParamPositionArray[i]] = refOutArgs[i];
        }
    }
}

六、定义服务代理工厂

WCF的服务代理对象是通过ChannelFactory<TChannel>创建的，我们来创建如下一个与之对应的ServiceProxyFactory<TChannel>类，泛型参数依然表示契约接口类型。CreateChannel方法中通过表示服务地址的Uri，契约接口类型和默认消息版本创建上述的真实代理ServiceChannelProxy<TChannel>对象，并返回其透明代理作为进行服务调用的代理对象。

public class ServiceProxyFactory<TChannel>
{
    public Uri Address { get; private set; }

    public ServiceProxyFactory(Uri address)
    {
        this.Address = address;
    }
    public TChannel CreateChannel()
    {
        MessageEncoderFactory encoderFactory = ComponentBuilder.GetMessageEncoderFactory(MessageVersion.Default, Encoding.UTF8);
        ServiceChannelProxy<TChannel> proxy = new ServiceChannelProxy<TChannel>(this.Address, MessageVersion.Default, encoderFactory);
        ContractDescription contract = ContractDescription.GetContract(typeof(TChannel));
        foreach (OperationDescription operation in contract.Operations)
        {
            IClientMessageFormatter messageFormatter = (IClientMessageFormatter)ComponentBuilder.GetFormatter(operation, true);
            proxy.MessageFormatters.Add(operation.Name, messageFormatter);
        }
        return (TChannel)proxy.GetTransparentProxy();
    }
}

七、服务“寄宿”和调用

现在我们创建一个服务寄宿在我们自定义的迷你版本的WCF中。依然采用我们熟悉的计算服务，下面是分别定义的Service.Interface和Service项目中的契约接口定义和服务类型定义。

//契约接口
[ServiceContract(Namespace = "http://www.artech.com/")]
public interface ICalculator
{
    [OperationContract]
    double Add(double x, double y);
    [OperationContract]
    double Subtract(double x, double y);
    [OperationContract]
    double Multiply(double x, double y);
    [OperationContract]
    double Divide(double x, double y);
}

//服务类型
public  class CalculatorService: ICalculator
{
    public double Add(double x, double y)
    {
        return x + y;
    }
    public double Subtract(double x, double y)
    {
        return x - y;
    }
    public double Multiply(double x, double y)
    {
        return x * y;
    }
    public double Divide(double x, double y)
    {
        return x / y;
    }
}

然后我们为Web项目Service中添加一个Global.asax文件，并通过如下的定义让Web应用启动的时候注册寄宿的服务类型CalculatorService和地址（calculatorservice）之间的映射关系。然后在IIS中创建一个Web应用（比如起名为WcfServices）并将物理路径映射为Service项目的根目录。

public class Global : System.Web.HttpApplication
{
    protected void Application_Start(object sender, EventArgs e)
    {
        RouteTable.Routes.Register<CalculatorService>("calculatorservice");
    }
}

由于最终处理服务调用请求的WcfHandler是通过WcfHttpModule进行映射的，所以我们需要将WcfHttpModule类型配置在Service项目的Web.config中。

<configuration>
  <system.webServer>
    <modules>
      <add name="WcfHttpModule" type="Artech.WcfServices.Service.WcfHttpModule, Artech.WcfServices.Service"/>
    </modules>
  </system.webServer>
</configuration>

在客户端我们只需要按照如下的方式通过指定正确的调用地址（Web应用地址+在Global.asax文件中添加的路由映射的地址）创建ServiceProxyFactory<TChannel>对象，并用它来创建用于尽心服务调用的代理对象即可。

Uri address = new Uri("http://localhost/WcfServices/CalculatorService");
ServiceProxyFactory<ICalculator> factory = new ServiceProxyFactory<ICalculator>(address);
ICalculator proxy = factory.CreateChannel();
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));

上面的代码执行之后，就像你真正调用WCF服务一样，同样可以得到如下的运算结果。

x + y = 3 when x = 1 and y = 2
x - y = -1 when x = 1 and y = 2
x * y = 2 when x = 1 and y = 2
x / y = 0.5 when x = 1 and y = 2