静坐常思己过,闲谈莫论人非,能受苦乃为志士,肯吃亏不是痴人,敬君子方显有德,怕小人不算无能,退一步天高地阔,让三分心平气和,欲进步需思退步,若着手先虑放手,如得意不宜重往,凡做事应有余步。持黄金为珍贵,知安乐方值千金,事临头三思为妙,怒上心忍让最高。切勿贪意外之财,知足者人心常乐。若能以此去处事,一生安乐任逍遥。

[转载]《Windows Communication Foundation之旅》系列之三

作者:大鹏 发布于:2007-2-11 11:21 Sunday 分类:考试相关

[quote]注:本文转载于Bruce Zhang's Blog http://wayfarer.cnblogs.com/[/quote]
四、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对于对象封装的意义有矛盾。但是这样的规定是有其现实意义的,因为对于一个服务而言,服务端和客户端的需求往往会不一致。在服务端,该服务对象即使允许被远程调用,但本地调用却可能会因情况而异。如下面的服务定义:

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

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

[code]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();
}
}[/code]
方法FooA,FooB,FooC作为internal方法,拒绝被程序集外的本地对象调用,但SvcA,SvcB和SvcC方法,却可以被远程对象所调用。我们甚至可以将BusinessObjA,BusinessObjB等类定义为Façade类的嵌套类。采用这样的方法,有利于这些特殊的服务方法,被远程客户更方便的调用。

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

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

[code][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();
}[/code]

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

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

[code][ServiceContract(CallbackContract = IACallback)]
interface IA {}
interface IACallback {}

[ServiceContract(CallbackContract = IBCallback)]
interface IB : IA {}
interface IBCallback : IACallback {}[/code]

五、消息交换模式(Message Exchange Patterns,MEPS)
在WCF中,服务端与客户端之间消息的交换共有三种模式:Request/Reply,One-Way,Duplex。

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

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

[code][ServiceContract]
public interface ICalculator
{
[OperationContract]
int Add(int a, int b);

[OperationContract]
int Subtract(int a, int b);
}[/code]

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

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

[code]public class Radio
{
[OperationContract(IsOneWay=true)]
private void BroadCast();
}[/code]

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

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

[code][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);
}[/code]

回调接口:

[code]public interface ICalculatorDuplexCallback
{
   [OperationContract(IsOneWay = true)]
   void Equals(double result);

   [OperationContract(IsOneWay = true)]
   void Equation(string equation);
}[/code]

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

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

[code][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.
}[/code]

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

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

[code]    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();
       }
   }[/code]

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

[code] <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/”&gt;
       </binding>
     </wsDualHttpBinding>
   </bindings>
 </system.serviceModel>
[/code]

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

[code]    public class CallbackHandler : ICalculatorDuplexCallback
   {
       public void Equals(double result)
       {
           Console.WriteLine(”Equals({0})”, result);
       }
       public void Equation(string equation)
       {
           Console.WriteLine(”Equation({0})”, equation);
       }
   }[/code]

客户端调用服务对象相应的为:
   
[code]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();
           }
       }
   }[/code]

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

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

(1)客户端与服务端双向通信功能——ChatDuplexWin
实例说明:一个类似于聊天室的小程序。利用Duplex支持客户端与服务端通信的特点,实现了客户端与服务端聊天的功能。

服务接口和回调接口的定义如下:
   
[code][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);
   }[/code]
很明显,Request方法的功能为客户端向服务端发送消息,Reply方法则使服务端回送消息给客户端。服务接口IChatDuplex中的Start()方法,用于显示的建立一个会话,因为在这个方法中,我需要直接获取callback对象,使得服务端不必等待客户端先发送消息,而是可以利用callback对象主动先向客户端发送消息,从而实现聊天功能。

实现类的代码如下:
   
[code][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);
       }
   }[/code]

因为我要求在服务端界面中,能够将客户端发送来的消息显示在主窗体界面中。所以利用了全局变量MainForm,用来保存主窗体对象:
   
[code]public static class ChatRoomUtil
   {
       public static ServerForm MainForm = new ServerForm();
   }[/code]
而在服务端程序运行时,Application运行的主窗口也为该全局变量:
Application.Run(ChatRoomUtil.MainForm);

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

对于客户端的实现,相对简单,需要注意的是回调接口的实现:
   
[code]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));
       }
   }[/code]
由于我自定义了该对象的构造函数,所以在实利化proxy时会有稍微区别:

[code]InstanceContext site = new InstanceContext(new ChatDuplexCallbackHandler(this.lbMessage));
proxy = new ChatDuplexProxy(site);
proxy.Start();[/code]

通过proxy对象的Start()方法,使得我们在建立proxy对象开始,就创建了会话,从而使得服务对象被实例化,从而得以运行下面的这行代码:
m_callback = OperationContext.Current.GetCallbackChannel();

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

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

例子中的接口定义非常简单,不再赘述,而实现类的代码如下:
   
[code]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
   }[/code]
很显然,当客户端调用该服务对象时,会在服务端的控制台上打印出迭代值。

由于客户端需要在callback调用时,停止对当前任务的运行,所以需要用到多线程机制:
   
[code]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();
           }
       }
   }[/code]

因为需要在多线程中对ListBox控件的items进行修改,由于该控件不是线程安全的,所以应使用该控件的InvokeRequired属性。此外,在线程启动时的匿名方法中,利用while(true)控制当前线程的运行,并利用全局变量ClientUtil.IsCompleted判断回调对象是否被调用,如果被调用了,则会弹出对话框,选择是否退出当前任务。这里所谓的当前任务实际上就是调用DoWork方法,向ListBox控件的items中不断添加累加的counter值。注意客户端的回调对象实现如下:
   
[code]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
   }[/code]
当客户端点击Start按钮,调用服务对象的Sum方法后,在服务端会显示迭代值,而客户端也开始执行自己的任务,向ListBox控件中添加累加数。一旦服务端运算完毕,就将运算结果通过回调对象传送到客户端,全局变量ClientUtil.IsCompleted将被设置为true。如果添加累加值的线程处于sleep状态,系统就会将结果值添加到ListBox控件中,同时会弹出对话框,决定是否继续剩下的任务。

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

< 未完待续>

[quote]参考:
1、David Chappell,Introducing Windows Communication Foundation
2、Microsoft Corporation,WinFX SDK [/quote]


标签: 免费资源 收藏

et_highlighter
发表评论 »本文目前尚无任何评论

发表评论

干净网络从你做起,切勿黏贴小广告