为了使读者对基于WCF的编程模型有一个直观的映像，我将带领读者一步一步地建立一个完整的WCF应用。本应用功能虽然简单，但它涵盖了一个完整WCF应用的基本结构。对那些对WCF不是很了解的读者来讲，这个例子将带领你正式进入WCF的世界。html
在这个例子中，咱们将实现一个简单的计算服务（CalculatorService），提供基本的加、减、乘、除的运算。和传统的分布式通讯框架同样，WCF本质上提供一个跨进程、跨机器以至跨网络的服务调用。在本例中，客户端和服务经过运行在相同的同一台机器上不一样进程模拟，图1体现了客户端和服务端进程互相调用的关系。编程
图1 计算服务应用运行环境安全
WCF的服务不能孤立地存在，须要寄宿于一个运行着的进程中，咱们把承载WCF服务的进程称为宿主，为服务指定宿主的过程称为服务寄宿（Service Hosting）。在咱们的计算服务应用中，采用了两种服务寄宿方式：经过自我寄宿（Self-Hosting）的方式建立一个控制台应用做为服务的宿主（寄宿进程为Hosting.exe）；经过IIS寄宿方式将服务寄宿于IIS中（寄宿进程为IIS的工做进行W3wp.exe）。客户端经过另外一个控制台应用模拟（进程为Client.exe）。接下来，咱们就一步一步来构建这样的一个WCF应用。微信
步骤一：构建整个解决方案网络
经过VS 2008建立一个空白的解决方案，添加以下四个项目。项目的类型、承载的功能和相互引用关系以下，整个项目在VS下的结构如图2所示。app
- Contracts：一个类库项目，定义服务契约（Service Contract），引用System.ServiceMode程序集（WCF框架的绝大部分实现和API定义在该程序集中）；
- Services：一个类库项目，提供对WCF服务的实现。定义在该项目中的全部WCF服务实现了定义在Contracts中相应的服务契约，因此Services具备对Contracts项目的引用；
- Hosting：一个控制台（Console）应用，实现对定义在Services项目中的服务的寄宿，该项目需要同时引用Contracts和Services两个项目和System.ServiceMode程序集；
- Client：一个控制台应用模拟服务的客户端，该项目引用System.ServiceMode程序集。
图2 计算服务在VS中的结构框架
步骤二：建立服务契约编辑器
WCF采用基于契约的交互方式实现了服务的自治，以及客户端和服务端之间的松耦合。WCF包含四种类型的契约：服务契约、数据契约、消息契约和错误契约，这里着重于服务契约。从功能上讲，服务契约抽象了服务提供的全部操做；而站在消息交换的角度来看，服务契约则定义了基于服务调用的消息交换过程当中，请求消息和回复消息的结构，以及采用的消息交换模式。第4章将提供对服务契约的详细介绍。分布式
通常地，咱们经过接口的形式定义服务契约。经过下面的代码，将一个接口ICalculator定义成服务契约。WCF普遍采用基于自定义特性（Custom Attribtue）的声明式编程模式，咱们经过在接口上应用System.ServiceModel.ServiceContractAttribute特性将一个接口定义成服务契约。在应用ServiceContractAttribute特性的同时，还能够指定服务契约的名称和命名空间。至于契约名称和命名空间的含义和做用，在本人拙著《WCF技术剖析(卷1)》第4章，在这里咱们将契约名称和命名空间设置成CalculatorService和http://www.artech.com/)。ide
经过应用ServiceContractAttribute特性将接口定义成服务契约以后，接口的方法成员并不能自动成为服务的操做。在此方面，WCF采用的是显式选择（Explicit Opt-in）的策略:咱们需要在相应的操做方法上面显式地应用OperationContractAttribute特性。
1: using System.ServiceModel;
2: namespace Artech.WcfServices.Contracts
3: {
4: [ServiceContract(Name="CalculatorService", Namespace="http://www.artech.com/")]
5: public interface ICalculator
6: {
7: [OperationContract]
8: double Add(double x, double y);
9:
10: [OperationContract]
11: double Subtract(double x, double y);
12:
13: [OperationContract]
14: double Multiply(double x, double y);
15:
16: [OperationContract]
17: double Divide(double x, double y);
18: }
19: }
步骤三：建立服务
当服务契约成功建立时，咱们须要经过实现服务契约来建立具体的WCF服务。WCF服务CalculatorService定义在Services项目中，实现了服务契约接口ICalculator，实现了全部的服务操做。CalculatorService定义以下：
1: using Artech.WcfServices.Contracts;
2: namespace Artech.WcfServices.Services
3: {
4: public class CalculatorService:ICalculator
5: {
6: public double Add(double x, double y)
7: {
8: return x + y;
9: }
10:
11: public double Subtract(double x, double y)
12: {
13: return x - y;
14: }
15:
16: public double Multiply(double x, double y)
17: {
18: return x * y;
19: }
20:
21: public double Divide(double x, double y)
22: {
23: return x / y;
24: }
25: }
26: }
步骤四：经过自我寄宿的方式寄宿服务
WCF服务须要依存一个运行着的进程（宿主），服务寄宿就是为服务指定一个宿主的过程。WCF是一个基于消息的通讯框架，采用基于终结点（Endpoint）的通讯手段。终结点由地址（Address）、绑定（Binding）和契约（Contract）三要素组成，如图3所示。因为三要素应为首字母分别为ABC，因此就有了易于记忆的公式：Endpoint = ABC。一个终结包含了实现通讯所必需的全部信息，咱们能够这样认识终结点的ABC：
- 地址（Address）：地址决定了服务的位置，解决了服务寻址的问题，《WCF技术剖析(卷1)》第2章提供了对地址和寻址机制的详细介绍；
- 绑定（Binding）：绑定实现了通讯的全部细节，包括网络传输、消息编码，以及其余为实现某种功能（好比安全、可靠传输、事务等）对消息进行的相应处理。WCF中具备一系列的系统定义绑定，好比BasicHttpBinding、WsHttpBinding、NetTcpBinding等，《WCF技术剖析(卷1)》第3章提供对绑定的详细介绍；
- 契约（Contract）：契约是对服务操做的抽象，也是对消息交换模式以及消息结构的定义。《WCF技术剖析(卷1)》第4章提供对服务契约的详细介绍。
图3 终结点三要素
服务寄宿的目的就是开启一个进程，为WCF服务提供一个运行的环境。经过为服务添加一个或多个终结点，使之暴露给潜给的服务消费者。服务消费者最终经过相匹配的终结点对该服务进行调用。咱们能够彻底经过代码的方式完成全部的服务寄宿工做，下面的代码体现了经过一个控制台应用对CalculatorService的寄宿：
1: using System;
2: using System.ServiceModel;
3: using System.ServiceModel.Description;
4: using Artech.WcfServices.Contracts;
5: using Artech.WcfServices.Services;
6: namespace Artech.WcfServices.Hosting
7: {
8: class Program
9: {
10: static void Main(string[] args)
11: {
12: using (ServiceHost host = new ServiceHost(typeof(CalculatorService)))
13: {
14: host.AddServiceEndpoint(typeof(ICalculator), new WSHttpBinding(), "http://127.0.0.1:9999/calculatorservice");
15: if (host.Description.Behaviors.Find<ServiceMetadataBehavior>() == null)
16: {
17: ServiceMetadataBehavior behavior = new ServiceMetadataBehavior();
18: behavior.HttpGetEnabled = true;
19: behavior.HttpGetUrl = new Uri("http://127.0.0.1:9999/calculatorservice/metadata");
20: host.Description.Behaviors.Add(behavior);
21: }
22: host.Opened += delegate
23: {
24: Console.WriteLine("CalculaorService已经启动，按任意键终止服务！");
25: };
26:
27: host.Open();
28: Console.Read();
29: }
30: }
31: }
32: }
WCF服务寄宿经过一个特殊的对象完成：ServiceHost。在上面的例子中，基于WCF服务的类型（typeof(CalculatorService)）建立了ServieHost对象，并添加了一个终结点。具体的地址为http://127.0.0.1:9999/calculatorservice，采用了WSHttpBinding，并指定了服务契约的类型ICalculator。
松耦合是SOA的一个基本的特征，WCF应用中客户端和服务端的松耦合体如今客户端只需要了解WCF服务基本的描述，而无须知道具体的实现细节，就能够实现正常的服务调用。WCF服务的描述经过元数据（Metadata）的形式发布出来。WCF中元数据的发布经过一个特殊的服务行为ServiceMetadataBehavior实现。在上面提供的服务寄宿代码中，咱们为建立的ServiceHost添加了ServiceMetadataBehavior，并采用了基于HTTP-GET的元数据获取方式，元数据的发布地址经过ServiceMetadataBehavior的HttpGetUrl指定。在调用ServiceHost的Open方法对服务成功寄宿后，咱们能够经过该地址获取服务相关的元数据。在IE地址栏上键入http://127.0.0.1:9999/calculatorservice/metadata，你将会获得以WSDL形式体现的服务元数据，如图4所示。
图4 经过HTTP-GET的方式获取WCF服务的元数据
在进行真正的WCF应用开发时，通常不会直接经过编码的方式进行终结点的添加和服务行为的定义，而是经过配置的方式进行。上面添加终结点和定义服务行为的代码能够用下面的配置代替：
1: <?xml version="1.0" encoding="utf-8" ?>
2: <configuration>
3: <system.serviceModel>
4: <behaviors>
5: <serviceBehaviors>
6: <behavior name="metadataBehavior">
7: <serviceMetadata httpGetEnabled="true" httpGetUrl="http://127.0.0.1:9999/calculatorservice/metadata" />
8: </behavior>
9: </serviceBehaviors>
10: </behaviors>
11: <services>
12: <service behaviorConfiguration="metadataBehavior" name="Artech.WcfServices.Services.CalculatorService">
13: <endpoint address="http://127.0.0.1:9999/calculatorservice" binding="wsHttpBinding" contract="Artech.WcfServices.Contracts.ICalculator" />
14: </service>
15: </services>
16: </system.serviceModel>
17: </configuration>
对于初学者来讲，WCF的配置显得过于复杂，直接对配置文件进行手工编辑不太现实。在这种状况下，能够直接使用VS提供的配置工具。你能够经过VS的工具（Tools）菜单，选择“WCF Service Configuration Editor”子项，开启这样的一个配置编辑器，如图5所示。
若是采用了上诉的配置，服务寄宿代码将会获得极大的精简，只需包含下面几行代码：
1: namespace Artech.WcfServices.Hosting
2: {
3: class Program
4: {
5: static void Main(string[] args)
6: {
7: using (ServiceHost host = new ServiceHost(typeof(CalculatorService)))
8: {
9: host.Opened += delegate
10: {
11: Console.WriteLine("CalculaorService已经启动，按任意键终止服务！");
12: };
13:
14: host.Open();
15: Console.Read();
16: }
17: }
18: }
19: }
图5 如何得到WCF服务配置编辑器
步骤五：建立客户端调用服务
服务被成功寄宿后，服务端便开始了服务调用请求的监听工做。此外，服务寄宿将服务描述经过元数据的形式发布出来，相应的客户端就能够获取这些元数据建立客户端程序进行服务的消费。在VS下，当咱们添加服务引用的时候，VS在内部帮咱们实现元数据的获取，并借助这些元数据经过代码生成工具（SvcUtil.exe）自动生成用于服务调用的服务代理相关的代码和相应的配置。
在运行服务寄宿程序（Hosting.exe）的状况下，右键点击Client项目，在弹出的上下文菜单中选择“添加服务引用（Add Service References）”，如图6所示的添加服务引用的对话会显示出来。在地址栏上键入服务元数据发布的源地址：http://127.0.0.1:9999/calculatorservice/metadata，并指定一个命名空间，点击OK按钮，VS为为你生成一系列用于服务调用的代码和配置。
图6 添加服务引用
在一系列自动生成的类中，包含一个服务契约接口、一个服务代理对象和其余相关的类。被客户端直接用于服务调用的是一个继承自ClientBase<CalculatorService>并实现了CalculatorService接口（CalculatorService为客户端生成的服务契约接口类型）的服务代理类。ClientBase<CalculatorService>的定义以下所示：
1: namespace Artech.WcfServices.Client.CalculatorServices
2: {
3: //其余类型成员
4: [System.Diagnostics.DebuggerStepThroughAttribute()]
5: [System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "4.0.0.0")]
6: public partial class CalculatorServiceClient : System.ServiceModel.ClientBase<Artech.WcfServices.Client.CalculatorServices.CalculatorService>, Artech.WcfServices.Client.CalculatorServices.CalculatorService {
7:
8: public CalculatorServiceClient() {
9: }
10:
11: public CalculatorServiceClient(string endpointConfigurationName) :
12: base(endpointConfigurationName) {
13: }
14:
15: public CalculatorServiceClient(string endpointConfigurationName, string remoteAddress) :
16: base(endpointConfigurationName, remoteAddress) {
17: }
18:
19: public CalculatorServiceClient(string endpointConfigurationName, System.ServiceModel.EndpointAddress remoteAddress) :
20: base(endpointConfigurationName, remoteAddress) {
21: }
22:
23: public CalculatorServiceClient(System.ServiceModel.Channels.Binding binding, System.ServiceModel.EndpointAddress remoteAddress) :
24: base(binding, remoteAddress) {
25: }
26:
27: public double Add(double x, double y) {
28: return base.Channel.Add(x, y);
29: }
30:
31: public double Subtract(double x, double y) {
32: return base.Channel.Subtract(x, y);
33: }
34:
35: public double Multiply(double x, double y) {
36: return base.Channel.Multiply(x, y);
37: }
38:
39: public double Divide(double x, double y) {
40: return base.Channel.Divide(x, y);
41: }
42: }
咱们能够建立CalculatorServiceClient对象，执行相应方法调用服务操做。客户端进行服务调用的代码以下：
1: using System;
2: using Artech.WcfServices.Client.CalculatorServices;
3: namespace Artech.WcfServices.Client
4: {
5: class Program
6: {
7: static void Main(string[] args)
8: {
9: using (CalculatorServiceClient proxy = new CalculatorServiceClient())
10: {
11: Console.WriteLine("x + y = {2} when x = {0} and y = {1}", 1, 2, proxy.Add(1, 2));
12: Console.WriteLine("x - y = {2} when x = {0} and y = {1}", 1, 2, proxy.Subtract(1, 2));
13: Console.WriteLine("x * y = {2} when x = {0} and y = {1}", 1, 2, proxy.Multiply(1, 2));
14: Console.WriteLine("x / y = {2} when x = {0} and y = {1}", 1, 2, proxy.Divide(1, 2));
15: }
16: }
17: }
18: }
运行后输出：
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
客户端经过服务代理对象进行服务的调用，上面的例子经过建立自动生成的、继承自ClientBase<T>的类型对象进行服务调用。实际上，咱们还具备另一种建立服务代理的方法，就是经过ChannelFactory<T>。此外，WCF采用基于契约的服务调用方法，从上面的例子咱们也能够看到，VS在进行服务引用添加的过程当中，会在客户端建立一个与服务端等效的服务契约接口。在咱们的例子中，因为服务端和客户端都是在同一个解决方案中，彻底可让服务端和客户端引用相同的契约。
为了演示这种场景，咱们将添加的服务引用移除，并为Client项目添加对Contracts项目的引用。借助于这个服务契约，并经过ChannelFactory<ICalculator>建立服务代理对象，直接进行相应的服务调用。下面的代码演示了基于ChannelFacotory<T>进行服务代理的建立和服务调用的方式。
1: using System;
2: using System.ServiceModel;
3: using Artech.WcfServices.Contracts;
4: namespace Artech.WcfServices.Client
5: {
6: class Program
7: {
8: static void Main(string[] args)
9: {
10: using (ChannelFactory<ICalculator> channelFactory = new ChannelFactory<ICalculator>(new WSHttpBinding(), "http://127.0.0.1:9999/calculatorservice"))
11: {
12: ICalculator proxy = channelFactory.CreateChannel();
13: using (proxy as IDisposable)
14: {
15: Console.WriteLine("x + y = {2} when x = {0} and y = {1}", 1, 2, proxy.Add(1, 2));
16: Console.WriteLine("x - y = {2} when x = {0} and y = {1}", 1, 2, proxy.Subtract(1, 2));
17: Console.WriteLine("x * y = {2} when x = {0} and y = {1}", 1, 2, proxy.Multiply(1, 2));
18: Console.WriteLine("x / y = {2} when x = {0} and y = {1}", 1, 2, proxy.Divide(1, 2));
19: }
20: }
21: }
22: }
23: }
因为终结点是WCF进行通讯的惟一手段，ChannelFactory<T>本质上是经过指定的终结点建立用于进行服务调用的服务代理。在上面的代码中，在建立ChannelFactory<T>的时候再在构造函数中指定终结点的相关要素（契约经过范型类型表示，地址和绑定则经过参数指定）。在真正的WCF应用中，大都采用配置的方式进行终结点的定义。咱们能够经过下面的配置指定终结点的三要素，并为相应的终结点指定一个终结点配置名称（calculatorservice）。
1: <?xml version="1.0" encoding="utf-8" ?>
2: <configuration>
3: <system.serviceModel>
4: <client>
5: <endpoint address="http://127.0.0.1:9999/calculatorservice" binding="wsHttpBinding" contract="Artech.WcfServices.Contracts.ICalculator" name="calculatorservice" />
6: </client>
7: </system.serviceModel>
8: </configuration>
那么在建立ChannelFactory<T>的时候，就无须再指定终结点的绑定和地址了，而只须制定对应的终结点配置名称。
1: using System;
2: using System.ServiceModel;
3: using Artech.WcfServices.Contracts;
4: namespace Artech.WcfServices.Client
5: {
6: class Program
7: {
8: static void Main(string[] args)
9: {
10: using (ChannelFactory<ICalculator> channelFactory = new ChannelFactory<ICalculator>( "calculatorservice"))
11: {
12: //省略代码
13: }
14: }
15: }
16: }
步骤六：经过IIS寄宿服务
上面演示了经过自我寄宿的方式寄宿服务，如今咱们来演示如何将WCF服务寄宿到IIS中。寄宿IIS的服务寄宿比较简单，基本上包含两个步骤：为WCF服务建立.svc文件和建立IIS虚拟目录。
一、为WCF服务建立.svc文件
咱们知道，每个ASP.NET Web服务都具备一个.asmx文本文件，客户端经过访问.asmx文件实现对相应Web服务的调用。与之相似，每一个WCF服务也具备一个对应的文本文件，其文件扩展名为.svc。基于IIS的服务寄宿要求相应的WCF服务具备相应的.svc文件，.svc文件部署于IIS站点中，对WCF服务的调用体如今对.svc文件的访问上。
.svc文件的内容很简单，仅仅包含一个ServiceHost指令（Directive），该指令具备一个必须的Service属性和一些可选的属性。因此最简单的.svc仅仅具备一个包含Service属性（该属性指明了相应的WCF服务的有效类型）的ServiceHost指令。CalculatorService对应的.svc以下所示，咱们把该.svc放在Services项目的根目录下，并将文件命名为CalculatorService.svc。
1: <%@ServiceHost Service="Artech.WcfServices.Services.CalculatorService"%>
二、为WCF服务建立虚拟目录
和通常的寄宿于IIS下的Web应用同样，须要在IIS下建立相应的虚拟目录。在本应用中，为了方便，咱们直接把Services项目的根目录映射为IIS虚拟目录，并把该虚拟目录的命名为WcfServices。
接下来须要为经过IIS寄宿的CalculatorService建立配置文件，咱们只须在Services的根目录下建立一个Web.config，将WCF相应的配置添加到该配置文件中便可。Web.config全部配置内容以下所示，能够看出，这基本上和上面经过自我寄宿方式定义的配置一致。惟一不一样的是在添加的终结点中无须指定地址，由于.svc所在的地址就是服务的地址。也就是说，CalculatorService的地址为http://127.0.0.1/wcfservices/calculatorservice.svc。你能够经过http://127.0.0.1/wcfservices/calculatorservice.svc?wsdl获得相应的元数据。因为WSHttpBinding在默认状况下采用Windows认证，因此在IIS中将Windows集成认证开启。
1: <?xml version="1.0" encoding="utf-8" ?>
2: <configuration>
3: <system.serviceModel>
4: <behaviors>
5: <serviceBehaviors>
6: <behavior name="metadataBehavior">
7: <serviceMetadata httpGetEnabled="true"/>
8: </behavior>
9: </serviceBehaviors>
10: </behaviors>
11: <services>
12: <service behaviorConfiguration="metadataBehavior" name="Artech.WcfServices.Services.CalculatorService">
13: <endpoint binding="wsHttpBinding" contract="Artech.WcfServices.Contracts.ICalculator" />
14: </service>
15: </services>
16: </system.serviceModel>
17: </configuration>
因为在建立Services项目的时候，咱们并未曾引用System.ServiceMode程序集，因此需要加上这样一个引用。此外，一个Web应用在运行的时候会默认从位于根目录下的Bin目录加载程序集，而默认的状况下，咱们编译后的程序集会自动保存到Bin\Debug|Release目录下，因此需要经过VS修改Services项目属性，将编译输出目录设置成Bin。
客户端仅仅需要修改终结点的地址，从而转向对寄宿于IIS下的CalculatorService的访问，该地址即为.svc文件的网络地址：http://127.0.0.1/wcfservices/calculatorservice.svc。
1: <?xml version="1.0" encoding="utf-8" ?>
2: <configuration>
3: <system.serviceModel>
4: <client>
5: <endpoint address="http://127.0.0.1/wcfservices/calculatorservice.svc" binding="wsHttpBinding" contract="Artech.WcfServices.Contracts.ICalculator" name="calculatorservice" />
6: </client>
7: </system.serviceModel>
8: </configuration>
摘自；蒋金楠
微信公众帐号：大内老A
微博：www.weibo.com/artech