简单的WCF程序

  http://www.cnblogs.com/artech/archive/2007/02/26/656901.html

 

步骤一：构建整个解决方案

通过VS 2008创建一个空白的解决方案，添加如下四个项目。项目的类型、承载的功能和相互引用关系如下，整个项目在VS下的结构如图2所示。

• Contracts：一个类库项目，定义服务契约（Service Contract），引用System.ServiceMode程序集（WCF框架的绝大部分实现和API定义在该程序集中）；
• Services：一个类库项目，提供对WCF服务的实现。定义在该项目中的所有WCF服务实现了定义在Contracts中相应的服务契约，所以Services具有对Contracts项目的引用；
• Hosting：一个控制台（Console）应用，实现对定义在Services项目中的服务的寄宿，该项目须要同时引用Contracts和Services两个项目和System.ServiceMode程序集；
• Client：一个控制台应用模拟服务的客户端，该项目引用System.ServiceMode程序集。

步骤二：创建服务契约

WCF采用基于契约的交互方式实现服务，以及客户端和服务端之间的松耦合。WCF包含四种类型的契约：服务契约、数据契约、消息契约和错误契约。从功能上讲，服务契约抽象了服务提供的所有操作；而站在消息交换的角度来看，服务契约则定义了基于服务调用的消息交换过程中，请求消息和回复消息的结构，以及采用的消息交换模式。

一般地，我们通过接口的形式定义服务契约。通过下面的代码，将一个接口ICalculator定义成服务契约。WCF广泛采用基于自定义特性（Custom Attribtue）的声明式编程模式，在这里我们将契约名称和命名空间设置成CalculatorService和http://www.artech.com/)。

通过应用ServiceContractAttribute特性将接口定义成服务契约之后，接口的方法成员并不能自动成为服务的操作。在此方面，WCF采用的是显式选择（Explicit Opt-in）的策略:我们须要在相应的操作方法上面显式地应用OperationContractAttribute特性。

 

using System.ServiceModel;   
namespace Artech.WcfServices.Contracts   
{      
    [ServiceContract(Name="CalculatorService", 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);          
    } 
}

 

步骤三：创建服务

当服务契约成功创建时，我们需要通过实现服务契约来创建具体的WCF服务。WCF服务CalculatorService定义在Services项目中，实现了服务契约接口ICalculator，实现了所有的服务操作。CalculatorService定义如下：

 

using Artech.WcfServices.Contracts;  
namespace Artech.WcfServices.Services  
{  
    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; 
        } 
    } 
}

 

步骤四：通过自我寄宿的方式寄宿服务

WCF服务需要依存一个运行着的进程（宿主），服务寄宿就是为服务指定一个宿主的过程。WCF是一个基于消息的通信框架，采用基于终结点（Endpoint）的通信手段。终结点由地址（Address）、绑定（Binding）和契约（Contract）三要素组成：

• 地址（Address）：地址决定了服务的位置，解决了服务寻址的问题，《WCF技术剖析(卷1)》第2章提供了对地址和寻址机制的详细介绍；
• 绑定（Binding）：绑定实现了通信的所有细节，包括网络传输、消息编码，以及其他为实现某种功能（比如安全、可靠传输、事务等）对消息进行的相应处理。WCF中具有一系列的系统定义绑定，比如BasicHttpBinding、WsHttpBinding、NetTcpBinding等，《WCF技术剖析(卷1)》第3章提供对绑定的详细介绍；
• 契约（Contract）：契约是对服务操作的抽象，也是对消息交换模式以及消息结构的定义。《WCF技术剖析(卷1)》第4章提供对服务契约的详细介绍。

服务寄宿的目的就是开启一个进程，为WCF服务提供一个运行的环境。通过为服务添加一个或多个终结点，使之暴露给潜给的服务消费者。服务消费者最终通过相匹配的终结点对该服务进行调用。我们可以完全通过代码的方式完成所有的服务寄宿工作，下面的代码体现了通过一个控制台应用对CalculatorService的寄宿：

 

using System;
using System.Collections.Generic;
using System.Text;
using System.ServiceModel;  
using System.ServiceModel.Description;  
using Artech.WcfServices.Contracts;  
using Artech.WcfServices.Services;

namespace Artech.WcfServices.Hosting
{
    class Program
    {
        static void Main(string[] args)
        {
            //基于WCF服务的类型（typeof(CalculatorService)）创建了ServieHost对象
            using (ServiceHost host = new ServiceHost(typeof(CalculatorService))) 
            {
                host.AddServiceEndpoint(typeof(ICalculator), new WSHttpBinding(), "http://127.0.0.1:9999/CalculatorService"); 
                if (host.Description.Behaviors.Find<ServiceMetadataBehavior>() == null) 
                { 
                    ServiceMetadataBehavior behavior = new ServiceMetadataBehavior(); 
                    behavior.HttpGetEnabled = true;
                    behavior.HttpGetUrl = new Uri("http://127.0.0.1:9999/CalculatorService/gmetadata"); 
                    host.Description.Behaviors.Add(behavior); 
                }
                host.Opened += delegate 
                {
                    Console.WriteLine("CalculaorService已经启动，按任意键终止服务！"); 
                }; 
               
                host.Open(); 
                Console.Read(); 
            }
        }
    }
}

 

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形式体现的服务元数据

在进行真正的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: }

 步骤五：创建客户端调用服务

服务被成功寄宿后，服务端便开始了服务调用请求的监听工作。此外，服务寄宿将服务描述通过元数据的形式发布出来，相应的客户端就可以获取这些元数据创建客户端程序进行服务的消费。在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为客户端生成的服务契约接口类型）的服务代理类。

我们可以创建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: }

 

 

客户端通过服务代理对象进行服务的调用，上面的例子通过创建自动生成的、继承自ClientBase<T>的类型对象进行服务调用。实际上，我们还具有另外一种创建服务代理的方法，就是通过ChannelFactory<T>。此外，WCF采用基于契约的服务调用方法，从上面的例子我们也可以看到，VS在进行服务引用添加的过程中，会在客户端创建一个与服务端等效的服务契约接口。在我们的例子中，由于服务端和客户端都是在同一个解决方案中，完全可以让服务端和客户端引用相同的契约