[转载]Windows Communication Foundation入门（Part Three）

[转自]http://www.cnblogs.com/wayfarer/archive/2006/04/17/377016.html

[感谢]张逸:晴窗笔记

《Windows Communication Foundation之旅》系列之三

示例代码下载：DuplexSample.rar

四、Service Contract编程模型

在Part Two中，我以“Hello World”为例讲解了如何定义一个Service。其核心就是为接口或类施加ServiceContractAttribute，为方法施加OperationContractAttribute。在Service的方法中，可以接受多个参数，也可以有返回类型，只要这些数据类型能够被序列化。这样一种方式通常被称为本地对象，远程过程调用（local-object, Remoting-Procedure-Call）方式，它非常利于开发人员快速地进行Service的开发。

在Service Contract编程模型中，还有一种方式是基于Message Contract的。服务的方法最多只能有一个参数，以及一个返回值，且它们的数据类型是通过Message Contract自定义的消息类型。在自定义消息中，可以为消息定义详细的Header和Body，使得对消息的交换更加灵活，也更利于对消息的控制。

一个有趣的话题是当我们定义一个Service时，如果一个private方法被施加了OperationContractAttribute，那么对于客户端而言，这个方法是可以被调用的。这似乎与private对于对象封装的意义有矛盾。但是这样的规定是有其现实意义的，因为对于一个服务而言，服务端和客户端的需求往往会不一致。在服务端，该服务对象即使允许被远程调用，但本地调用却可能会因情况而异。如下面的服务定义：

[ServiceContract]

public class BookTicket

{

[OperationContract]

public bool Check(Ticket ticket)

{

bool flag;

//logic to check whether the ticket is none;

return flag;

}

[OperationContract]

private bool Book(Ticket ticket)

{

//logic to book the ticket

}

}

在服务类BookTicket中，方法Check和Book都是服务方法，但后者被定义成为private方法。为什么呢？因为对于客户而言，首先会检查是否还有电影票，然而再预定该电影票。也就是说这两项功能都是面向客户的服务，会被远程调用。对于Check方法，除了远程客户会调用该方法之外，还有可能被查询电影票、预定电影票、出售电影票等业务逻辑所调用。而Book方法，则只针对远程客户，只可能被远程调用。为了保证该方法的安全，将其设置为private，使得本地对象不至于调用它。

因此在WCF中，一个方法是否应该被设置为服务方法，以及应该设置为public还是private，都需要根据具体的业务逻辑来判断。如果涉及到私有的服务方法较多，一种好的方法是利用设计模式的Façade模式，将这些方法组合起来。而这些方法的真实逻辑，可能会散放到各自的本地对象中，对于这些本地对象，也可以给与一定的访问限制，如下面的代码所示：

internal class BusinessObjA

{

internal void FooA(){}

}

internal class BusinessObjB

{

internal void FooB(){}

}

internal class BusinessObjC

{

internal void FooC(){}

}

[ServiceContract]

internal class Façade

{

private BusinessObjA objA = new BusinessObjA();

private BusinessObjB objB = new BusinessObjB();

private BusinessObjC objC = new BusinessObjC();

[OperationContract]

private void SvcA()

{

objA.FooA();

}

[OperationContract]

private void SvcB()

{

objB.FooB();

}

[OperationContract]

private void SvcC()

{

objC.FooC();

}

}

方法FooA，FooB，FooC作为internal方法，拒绝被程序集外的本地对象调用，但SvcA，SvcB和SvcC方法，却可以被远程对象所调用。我们甚至可以将BusinessObjA，BusinessObjB等类定义为Façade类的嵌套类。采用这样的方法，有利于这些特殊的服务方法，被远程客户更方便的调用。

定义一个Service，最常见的还是显式地将接口定义为Service。这样的方式使得服务的定义更加灵活，这一点，我已在Part Two中有过描述。当然，采用这种方式，就不存在前面所述的私有方法成为服务方法的形式了，因为在一个接口定义中，所有方法都是public的。

另外一个话题是有关“服务接口的继承”。一个被标记了[ServiceContract]的接口，在其继承链上，允许具有多个同样标记了[ServiceContract]的接口。对接口内定义的OperationContract方法，则是根据“聚合”的原则，如下的代码所示：

[ServiceContract]

public interface IOne

{

[OperationContract(IsOneWay=true)]

void A();

}

[ServiceContract]

public interface ITwo

{

[OperationContract]

void B();

}

[ServiceContract]

public interface IOneTwo : IOne, ITwo

{

[OperationContract]

void C();

}

在这个例子中，接口IOneTwo继承了接口IOne和ITwo。此时服务IOneTwo暴露的服务方法应该为方法A、B和C。

然而当我们采用Duplex消息交换模式（文章后面会详细介绍Duplex）时，对于服务接口的回调接口在接口继承上有一定的限制。WCF要求服务接口IB在继承另一个服务接口IA时，IB的回调接口IBCallBack必须同时继承IACallBack，否则会抛出InvalidContractException异常。正确的定义如下所示：

[ServiceContract(CallbackContract = IACallback)]

interface IA {}

interface IACallback {}

[ServiceContract(CallbackContract = IBCallback)]

interface IB : IA {}

interface IBCallback : IACallback {}

五、消息交换模式（Message Exchange Patterns，MEPS）

在WCF中，服务端与客户端之间消息的交换共有三种模式：Request/Reply，One-Way，Duplex。

1、Request/Reply

这是默认的一种消息交换模式，客户端调用服务方法发出请求（Request），服务端收到请求后，进行相应的操作，然后返回一个结果值（Reply）。

如果没有其它特别的设置，一个方法如果标记了OperationContract，则该方法的消息交换模式就是采用的Request/Reply方式，即使它的返回值是void。当然，我们也可以将IsOneWay设置为false，这也是默认的设置。如下的代码所示：

[ServiceContract]

public interface ICalculator

{

[OperationContract]

int Add(int a, int b);

[OperationContract]

int Subtract(int a, int b);

}

2、One-Way

如果消息交换模式为One-Way，则表明客户端与服务端之间只有请求，没有响应。即使响应信息被发出，该响应信息也会被忽略。这种方式类似于消息的通知或者广播。当一个服务方法被设置为One-Way时，如果该方法有返回值，会抛出InvalidOperationException异常。

要将服务方法设置为One-Way非常简单，只需要将OperationContractAttribute的属性IsOneWay设置为true就可以了，如下的代码所示：

public class Radio

{

[OperationContract(IsOneWay=true)]

private void BroadCast();

}

3、Duplex

Duplex消息交换模式具有客户端与服务端双向通信的功能，同时它的实现还可以使消息交换具有异步回调的作用。

要实现消息交换的Duplex，相对比较复杂。它需要定义两个接口，其中服务接口用于客户端向服务端发送消息，而回调接口则是从服务端返回消息给客户端，它是通过回调的方式来完成的。接口定义如下：

服务接口：

[ServiceContract(Namespace = "http://microsoft.servicemodel.samples/",

Session = true, CallbackContract=typeof(ICalculatorDuplexCallback))]

public interface ICalculatorDuplex

{

[OperationContract(IsOneWay=true)]

void Clear();

[OperationContract(IsOneWay = true)]

void AddTo(double n);

[OperationContract(IsOneWay = true)]

void SubtractFrom(double n);

[OperationContract(IsOneWay = true)]

void MultiplyBy(double n);

[OperationContract(IsOneWay = true)]

void DivideBy(double n);

}

回调接口：

public interface ICalculatorDuplexCallback

{

[OperationContract(IsOneWay = true)]

void Equals(double result);

[OperationContract(IsOneWay = true)]

void Equation(string equation);

}

注意在接口定义中，每个服务方法的消息转换模式均设置为One-Way。此外，回调接口是被本地调用，因此不需要定义[ServiceContract]。在服务接口中，需要设置ServiceContractAttribute的CallbackContract属性，使其指向回调接口的类型type。

对于实现服务的类，实例化模式（InstanceContextMode）究竟是采用PerSession方式，还是PerCall方式，应根据该服务对象是否需要保存状态来决定。如果是PerSession，则服务对象的生命周期是存活于一个会话期间。而PerCall方式下，服务对象是在方法被调用时创建，结束后即被销毁。然而在Duplex模式下，不能使用Single方式，否则会导致异常抛出。本例的实现如下：

[ServiceBehavior(InstanceContextMode = InstanceContextMode.PerSession)]

public class CalculatorService : ICalculatorDuplex

{

double result;

string equation;

ICalculatorDuplexCallback callback = null;

public CalculatorService()

{

result = 0.0D;

equation = result.ToString();

callback = OperationContext.Current.

GetCallbackChannel();

}

public void AddTo(double n)

{

result += n;

equation += " + " + n.ToString();

callback.Equals(result);

}

// Other code not shown.

}

在类CalculatorService中，回调接口对象callback通过OperationContext.Current.GetCallbackChannel<>()获取。然后在服务方法例如AddTo()中，通过调用该回调对象的方法，完成服务端向客户端返回消息的功能。

在使用Duplex时，Contract使用的Binding应该是系统提供的WSDualHttpBinding，如果使用BasicHttpBinding，会出现错误。因此Host程序应该如下所示：

public static void Main(string[] args)

{

Uri uri = new Uri("http://localhost:8080/servicemodelsamples");

using (ServiceHost host = new ServiceHost(typeof(CalculatorService), uri))

{

host.AddServiceEndpoint(typeof(ICalculatorDuplex),new WSDualHttpBinding(),"service.svc");

host.Open();

Console.WriteLine("Press any key to quit service.");

Console.ReadKey();

}

}

如果是使用配置文件，也应作相应的修改，如本例：

<system.serviceModel>

<client>

<endpoint name=""

address="http://localhost:8080/servicemodelsamples/service.svc"

binding="wsDualHttpBinding"

bindingConfiguration="DuplexBinding"

contract="ICalculatorDuplex" />

</client>

<bindings>

<!-- configure a binding that support duplex communication -->

<wsDualHttpBinding>

<binding name="DuplexBinding"

clientBaseAddress="http://localhost:8000/myClient/">

</binding>

</wsDualHttpBinding>

</bindings>

</system.serviceModel>

当服务端将信息回送到客户端后，对消息的处理是由回调对象来处理的，所以回调对象的实现应该是在客户端完成，如下所示的代码应该是在客户端中：

public class CallbackHandler : ICalculatorDuplexCallback

{

public void Equals(double result)

{

Console.WriteLine("Equals({0})", result);

}

public void Equation(string equation)

{

Console.WriteLine("Equation({0})", equation);

}

}

客户端调用服务对象相应的为：

class Client

{

static void Main()

{

// Construct InstanceContext to handle messages on

// callback interface.

InstanceContext site = new InstanceContext(new CallbackHandler());

// Create a proxy with given client endpoint configuration.

using (CalculatorDuplexProxy proxy =

new CalculatorDuplexProxy(site, "default"))

{

double value = 100.00D;

proxy.AddTo(value);

value = 50.00D;

proxy.SubtractFrom(value);

// Other code not shown.

// Wait for callback messages to complete before

// closing.

System.Threading.Thread.Sleep(500);

// Close the proxy.

proxy.Close();

}

}

}

注意在Duplex中，会话创建的时机并不是客户端创建Proxy实例的时候，而是当服务对象的方法被第一次调用时，会话方才建立，此时服务对象会在方法调用之前被实例化，直至会话结束，服务对象都是存在的。

以上的代码例子在WinFX的SDK Sample中可以找到。不过该例子并不能直接反映出Duplex功能。通过前面的介绍，我们知道Duplex具有客户端与服务端双向通信的功能，同时它的实现还可以使消息交换具有异步回调的作用。因此，我分别实现了两个实例来展现Duplex在两方面的作用。

（1）客户端与服务端双向通信功能——ChatDuplexWin

实例说明：一个类似于聊天室的小程序。利用Duplex支持客户端与服务端通信的特点，实现了客户端与服务端聊天的功能。

服务接口和回调接口的定义如下：

[ServiceContract(Namespace = "http://www.brucezhang.com/WCF/Samples/ChatDuplex", Session = true, CallbackContract=typeof(IChatDuplexCallback))]

public interface IChatDuplex

{

[OperationContract(IsOneWay=true)]

void Request(string cltMsg);

[OperationContract(IsOneWay = true)]

void Start();

}

public interface IChatDuplexCallback

{

[OperationContract(IsOneWay=true)]

void Reply(string srvMsg);

}

很明显，Request方法的功能为客户端向服务端发送消息，Reply方法则使服务端回送消息给客户端。服务接口IChatDuplex中的Start()方法，用于显示的建立一个会话，因为在这个方法中，我需要直接获取callback对象，使得服务端不必等待客户端先发送消息，而是可以利用callback对象主动先向客户端发送消息，从而实现聊天功能。

实现类的代码如下：

[ServiceBehavior(InstanceContextMode = InstanceContextMode.PerSession)]

public class ChatDuplex:IChatDuplex

{

public ChatDuplex()

{

m_callback = OperationContext.Current.GetCallbackChannel();

}

private IChatDuplexCallback m_callback = null;

public void Request(string cltMsg)

{

ChatRoomUtil.MainForm.FillListBox(string.Format("Client:{0}", cltMsg));

}

public void Start()

{

ChatRoomUtil.MainForm.SetIIMDuplexCallback(m_callback);

}

}

因为我要求在服务端界面中，能够将客户端发送来的消息显示在主窗体界面中。所以利用了全局变量MainForm，用来保存主窗体对象：

public static class ChatRoomUtil

{

public static ServerForm MainForm = new ServerForm();

}

而在服务端程序运行时，Application运行的主窗口也为该全局变量：

Application.Run(ChatRoomUtil.MainForm);

要实现聊天功能，最大的障碍是当服务端收到客户端消息时，不能立即Reply消息，而应等待服务端用户输入回送的消息内容，方可以Reply。也即是说，当客户端调用服务对象的Request方法时，不能直接调用callback对象。因此我利用Start()方法，将服务对象中获得的callback对象传递到主窗体对象中。这样，callback对象就可以留待服务端发送消息时调用了：

public partial class ServerForm : Form

{

private IChatDuplexCallback m_callback;

private void btnSend_Click(object sender, EventArgs e)

{

if (txtMessage.Text != string.Empty)

{

lbMessage.Items.Add(string.Format("Server:{0}", txtMessage.Text));

if (m_callback != null)

{

m_callback.Reply(txtMessage.Text);

}

txtMessage.Text = string.Empty;

}

}

public void FillListBox(string message)

{

lbMessage.Items.Add(message);

}

public void SetIIMDuplexCallback(IChatDuplexCallback callback)

{

m_callback = callback;

}

//Other code not shown;

}

对于客户端的实现，相对简单，需要注意的是回调接口的实现：

public class ChatDuplexCallbackHandler:IChatDuplexCallback

{

public ChatDuplexCallbackHandler(ListBox listBox)

{

m_listBox = listBox;

}

private ListBox m_listBox;

public void Reply(string srvMsg)

{

m_listBox.Items.Add(string.Format("Server:{0}", srvMsg));

}

}

由于我自定义了该对象的构造函数，所以在实利化proxy时会有稍微区别：

InstanceContext site = new InstanceContext(new ChatDuplexCallbackHandler(this.lbMessage));

proxy = new ChatDuplexProxy(site);

proxy.Start();

通过proxy对象的Start()方法，使得我们在建立proxy对象开始，就创建了会话，从而使得服务对象被实例化，从而得以运行下面的这行代码：

m_callback = OperationContext.Current.GetCallbackChannel();

也就是说，在proxy对象建立之后，服务端就已经获得callback对象了，这样就可以保证服务端能够先向客户端发送消息而不会因为callback为null，导致错误的发生。

（2）消息交换的异步回调功能——AsyncDuplexWin

实例说明：本实例比较简单，只是为了验证当回调对象被调用时，客户端是否可以被异步运行。调用服务对象时，服务端会进行一个累加运算。在运算未完成之前，客户端会执行显示累加数字的任务，当服务端运算结束后，只要客户端程序的线程处于Sleep状态，该回调对象就会被调用，然后根据用户选择是否再继续运行剩下的任务。本例中服务端为控制台应用程序，客户端则为Windows应用程序。

例子中的接口定义非常简单，不再赘述，而实现类的代码如下：

public class SumDuplex:ISumDuplex

{

public SumDuplex()

{

callback = OperationContext.Current.GetCallbackChannel();

}

private ISumDuplexCallback callback = null;

#region ISumDuplex Members

public void Sum(int seed)

{

int result = 0;

for (int i = 1; i < = seed; i++)

{

Thread.Sleep(10);

Console.WriteLine("now at {0}",i);

result += i;

}

callback.Equals(result);

}

#endregion

}

很显然，当客户端调用该服务对象时，会在服务端的控制台上打印出迭代值。

由于客户端需要在callback调用时，停止对当前任务的运行，所以需要用到多线程机制：

public delegate void DoWorkDelegate();

public partial class ClientForm : Form

{

public ClientForm()

{

InitializeComponent();

InstanceContext site = new InstanceContext(new SumDuplexCallbackHandler(this.lbMessage));

proxy = new SumDuplexProxy(site);

}

private SumDuplexProxy proxy;

private Thread thread = null;

private DoWorkDelegate del = null;

private int counter = 0;

private void btnStart_Click(object sender, EventArgs e)

{

proxy.Sum(100);

thread = new Thread(new ThreadStart(delegate()

{

while (true)

{

if (ClientUtil.IsCompleted)

{

if (MessageBox.Show("Game over,Exit?", "Notify", MessageBoxButtons.YesNo,

MessageBoxIcon.Question) == DialogResult.Yes)

{

break;

}

}

if (counter > 10000)

{

break;

}

if (del != null)

{

del();

}

Thread.Sleep(50);

}

}

));

del += new DoWorkDelegate(DoWork);

thread.Start();

}

private void DoWork()

{

if (lbMessage.InvokeRequired)

{

this.Invoke(new DoWorkDelegate(DoWork));

}

else

{

lbMessage.Items.Add(counter);

lbMessage.Refresh();

counter++;

}

}

private void ClientForm_FormClosing(object sender, FormClosingEventArgs e)

{

if (thread != null)

{

thread.Abort();

}

}

}

因为需要在多线程中对ListBox控件的items进行修改，由于该控件不是线程安全的，所以应使用该控件的InvokeRequired属性。此外，在线程启动时的匿名方法中，利用while(true)控制当前线程的运行，并利用全局变量ClientUtil.IsCompleted判断回调对象是否被调用，如果被调用了，则会弹出对话框，选择是否退出当前任务。这里所谓的当前任务实际上就是调用DoWork方法，向ListBox控件的items中不断添加累加的counter值。注意客户端的回调对象实现如下：

class SumDuplexCallbackHandler:ISumDuplexCallback

{

public SumDuplexCallbackHandler(ListBox listBox)

{

m_listBox = listBox;

}

private ListBox m_listBox;

#region ISumDuplexCallback Members

public void Equals(int result)

{

ClientUtil.IsCompleted = true;

m_listBox.Items.Add(string.Format("The result is:{0}", result));

m_listBox.Refresh();

}

#endregion

}

当客户端点击Start按钮，调用服务对象的Sum方法后，在服务端会显示迭代值，而客户端也开始执行自己的任务，向ListBox控件中添加累加数。一旦服务端运算完毕，就将运算结果通过回调对象传送到客户端，全局变量ClientUtil.IsCompleted将被设置为true。如果添加累加值的线程处于sleep状态，系统就会将结果值添加到ListBox控件中，同时会弹出对话框，决定是否继续剩下的任务。

注：本文示例的代码和实例均在Feb 2006 CTP版本下运行。

< 未完待续>

参考：

1、David Chappell，Introducing Windows Communication Foundation

2、Microsoft Corporation，WinFX SDK