[WCF编程]7.实例上下文模式

一、实例上下文模式概述

        实例上下文(IntanceContext Mode)表示服务端的服务实例与客户端的服务代理的绑定方式。

        在实例化服务器对象时，WCF采用了3种不同的模式：单调(Per-Call)模式,会话(Per-Session)模式和单例(Single)模式.其中会话模式是默认的。

        服务器实例化模式的选择只在服务端是可见的，并没有反映到WSDL文档中。由于每当客户端调用一个方法时，它并不知道接受对象是否来自同一个实例，也不知道以前设置的值是否保留了下来，更不知道每次调用的实例是否否是重新创建的，因此，在设计时必须要特别小心。

?

1 2 3 4

[ServiceBehavior(InstanceContextMode=InstanceContextMode.PerCall)] public class HelloWorldService : IHelloWorldService { }

二、单调(Per-Call)模式

       对于单调的实例上下文模式，WCF服务端运行时总是创建一个全新的InstanceContext来处理每一个请求，不管该请求是否来自相同的客户端。所以在单调实例上下文模式下，根本就不存在对某个InstanceContext的并发调用的情况发生。

        每当客户端发出请求(即WCF契约的方法调用)，就会获得一个新的专门的服务实例。

        以下列出了单调模式的执行细节：

        (1)客户端调用代理，代理将调用转发给服务。

        (2)WCF创建一个服务实例，然后调用服务实例的方法。

        (3)当方法调用返回时，如果对象实现了IDisposable接口，则WCF将自动调用IDisposable.Dispose()方法。WCF随后销毁上下文。

        (4)客户端调用代理，代理将调用转发给服务。

        (5)WCF创建一个服务实例，然后调用服务实例的方法。

      需要关注的是服务实例的销毁。如果服务实现了IDisposable接口，WCF会自动调用Dispose()方法，允许服务执行所有必要的清除工作。注意，调用Dispose()方法的现场与分发原有方法调用的线程是相同的，同时，Dispose()还包含了一个操作上下文。一旦调用了Dispose()方法，WCF就会断开实例与其它WCF基础架构的连接，然后将它放到垃圾回收器中等待回收。

单调模式的优势

        (1) 能够最大限度的发挥资源的利用，避免了资源的闲置及相互争用

        (2) 如果每次调用都需要事务资源和事务编程，那么单调服务会强行要求服务实例重新分配或连接资源，从而减轻同步实例状态的任务。

        (3) 它可以用于队列离线调用，因为它能够建立服务实例与离散队列消息之间的简单映射。

使用单调模式

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

////////////////////服务端代码////////////////////     [ServiceContract(Namespace = "www.cnblogs.com")]     public interface IService1     {         [OperationContract]         void MyMethod();     } [ServiceBehavior(InstanceContextMode=InstanceContextMode.PerCall)] public class Service1:IService1,IDisposable {     int m_Counter = 0;     public Service1()     {         Debug.WriteLine("Service1.Service1()");     }     public void MyMethod()     {         m_Counter++;         Debug.WriteLine("Counter=" + m_Counter);     }       public void Dispose()     {         Debug.WriteLine("Service1.Dispose()");     } }   ////////////////////客户端代码//////////////////// Service1Client client = new Service1Client(); client.MyMethod(); client.MyMethod(); client.Close(); ////////////////////输出//////////////////// Service1.Service1() Counter=1 Service1.Dispose() Service1.Service1() Counter=1 Service1.Dispose()

设计单调模式

        虽然理论上可以将单调实例激活模式应用到任意一个服务类型上，但实际上，需要在一开始就将服务以及服务的契约设置为支持这一模式。主要问题是客户端并不知道是否需要发出调用时获取一个新的实例。单调服务必须是状态相关的，也就是说，它必须积极的管理自己的状态，并在持续的会话过程中给出客户端一个提示，一个状态相关的服务与状态无关的服务迥然不同。事实上，正是这种状态相关，才需要使用单调模式。单调服务的一个实例创建于每个方法调用之前，调用完成后会立即销毁该服务实例。因此，在每次调用之初就要获取存储在某处的值用来初始化它的状态。

        使用单调模式，对于操作的设计而言是一个重要的启示，那就是每个操作都必须定义一个参数，用来识别哪些是需要重新获取状态的服务实例。因此，状告太存储通常都具有键值，如订单号，银行帐号参数等。

        如下实例的一个单调模式范例：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37

[ServiceContract(Namespace = "www.cnblogs.com")]     public interface IService1     {         [OperationContract]         void MyMethod();     } [ServiceBehavior(InstanceContextMode=InstanceContextMode.PerCall)] public class Service1:IService1,IDisposable {     public void MyMethod()     {         GetState(state);         DoWork();         SaveState(state)     }       void GetState(Param state)     {         ....     }     void DoWork()     {         ....     }     void SaveState(Param state)     {         ....     }     public void Dispose()     {         Trace.WriteLine("Service1.Dispose()");     } }</pre>   单调服务会为每次方法调用获取与保存实例状态，这势必影响系统的性能，但换来了可伸缩性，这是因为它持有了服务的所以来的状态与资源。 选择单调服务         在客户端/服务端开发者的眼中，单调服务的编程模型似乎有点违背常理，但对于大多数服务而言，单调服务才是最好的实例管理模式。这仅仅是因为单调服务更有利于系统的伸缩性，至少它可以保证规模不变。

三、会话(Per-Session)模式

       会话模式表示，每个客户端代理都与服务端的一个专用实例进行通信。只要客户端不执行代理的Close方法，或者会话的超时时间还没到(默认10分钟)，此对象在服务器端就会一直持续下去。

       当通过调用Close方法关闭此客户端到服务器的连接后忙超时已删除了PerSession服务对象之后，代理就不可以继续使用了。如果试图再次调用一个方法，就会产生一个通信异常错误。

       因为在整个会话期间，服务实例都保留了内存空间，并用它来维持会话的状态，这就是的这种编程模型更近似于经典的客户端/服务端模式。因此，它与客户端/服务端模式一样，仍然存在可伸缩性及事务处理的问题。一个配置了私有会话的服务通常无法支持多大几十个(或者上百个)独立的客户端，只因为创建专门的服务实例的代价太大。

配置私有会话

?

1 2 3

[ServiceBehavior(InstanceContextMode=InstanceContextMode.PerSession)]    public class Service2:IService2    {...}

        InstanceContextMode的默认值为InstanceContextMode.PerSession，那么以下是等效的：

?

1 2 3 4 5 6 7 8

public class Service2:IService2,IDisposable     {...} [ServiceBehavior]     public class Service2:IService2,IDisposable     {...} [ServiceBehavior(InstanceContextMode=InstanceContextMode.PerSession)]     public class Service2:IService2,IDisposable     {...}

        为了关联所有从特定客户端发送到特定实例的消息，WCF需要具有识别客户端的能力。ServiceContract特性提供了SessionMode枚举类型，即

?

1 2 3 4 5 6 7 8 9

public enum SessionMode {     // 指定当传入绑定支持会话时，协定也支持会话。     Allowed = 0,     // 指定协定需要会话绑定。 如果绑定并未配置为支持会话，则将引发异常。     Required = 1,     // 指定协定永不支持启动会话的绑定。     NotAllowed = 2, }

        SessionMode的默认值为SessionMode.Allowed。当客户端导入契约元数据时，服务元数据将包含SessionMode的值，并会如是反映它的内容。

SessionMode.Allowed值

        SessionMode.Allowed是SessionMode的默认值。所以，以下是等效的。

?

1 2 3 4 5

public interface IService2    {...} [ServiceContract(SessionMode=SessionMode.Allowed)]    public interface IService2    {...}

       所有的绑定都允许将终结点上的契约配置为SessionMode.Allowed。当SeesionMode互相被配置为该值时，才允许传输会话，但不是强制。BasicHttpBinding绑定由于HTTP协议本质是无连接的，因此它永远不可能拥有传输层会话，即使服务配置为InstanceContextMode.PerSession，并且契约的SessionMode值为SessionMode.Allowed，服务仍然会采用单调服务的执行方式。

SessionMode.Required值

       SessionMode.Required值要求必须使用传输层会话，但对应用层会话却不是必须的。然而，我们仍然可以将服务配置为单调服务，服务实例会在每次客户端调用期间创建与销毁实例。只有当服务被配置为会话服务时，服务实例才会存活于整个客户端会话中。如：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

public class Service2:IService2,IDisposable {...}</pre> public class Service2:IService2,IDisposable {     int m_Counter = 0;     public Service2()     {         Trace.WriteLine("Service2.Service1()");     }     public void MyMethod()     {         m_Counter++;         Debug.WriteLine("Counter=" + m_Counter);     }       public void Dispose()     {         Debug.WriteLine("Service2.Dispose()");     } } [ServiceBehavior(InstanceContextMode=InstanceContextMode.PerCall)] public class Service2:IService2 {...}</pre>

四、单例(Single)模式

        Single模式下，不管有多少个客户端代理，只有一个实例，服务对象只实例化一次，服务的生命周期有ServiceHost来决定。

        Single模式是一种极端的共享式服务。当一个服务被配置为单例时，所有客户端都将独自连接相同的单个实例，而不考虑它们连接的是服务的哪一个终结点。单例服务会在创建宿主时创建，且它的生存期是无限的：只有关闭宿主时，单例服务才会被释放。

        使用单例服务不需要客户端维护单例实例的逻辑会话，也不需要使用支持传输层会话的绑定。如果客户端调用的契约拥有一个会话，那么在调用期间，单例服务将与拥有一个与客户端相同的会话ID。关闭客户端代理只能终止传送会话，不能终止单例实例，单例服务的会话永远不会过期。

       如下代码，单例服务同时实现了两个契约，其中一个契约需要会话，另一个不需要会话。从客户端的调用可以看出，在两个终结点上的调用都经有相同的实例进行传递，即使关闭代理，仍然不会终止单例服务。

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

//////////////////////服务端代码////////////////////// [ServiceContract(SessionMode=SessionMode.Required)]     public interface IService3     {         [OperationContract]         void MyMethod();     } [ServiceContract(SessionMode = SessionMode.NotAllowed)] public interface IOtherService3 {     [OperationContract]     void MyOtherMethod(); }   public class Service3:IService3,IOtherService3,IDisposable {     int m_Counter = 0;     public Service3()     {         Trace.WriteLine("Service3.Service3()");     }     public void MyMethod()     {         m_Counter++;         Trace.WriteLine("Counter=" + m_Counter);     }        public void MyOtherMethod()     {         m_Counter++;         Trace.WriteLine("Counter=" + m_Counter);     }       public void Dispose()     {         Trace.WriteLine("Service1.Dispose()");     } }   //////////////////////客户端代码////////////////////// Service3Client client = new Service3Client(); client.MyMethod(); client.Close(); OtherService3Client client1 = new OtherService3Client(); client1.MyMethod(); client1.Close(); //////////////////////输出////////////////////// Service3.Service3() Counter=1 Counter=2

?

1

初始化单例服务

有时，我们无法使用默认的构造函数创建和初始化单例服务，ServiceHost类提供了专门的构造函数，以接收一个object对象。

?

1 2 3 4 5 6

public class ServiceHost : ServiceHostBase {     public ServiceHost(object singletonInstance, params Uri[]     baseAddresses);     public object SingletonInstance { get; }     //... }

注意，object参数对象必须配置为单例方式。

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

//服务端 [ServiceContract]     public interface IService4     {         [OperationContract]         void MyMethod();     } public class Service4:IService3 {     public int Counter { get; set; }     public void MyMethod()     {         Counter++;         Trace.WriteLine("Counter=" + Counter);     } }   //宿主 Service.Service4 singleton = new Service.Service4(); singleton.Counter = 287; ServiceHost host = new ServiceHost(singleton); host.Open(); //客户端 Service4Client client = new Service4Client(); client.MyMethod(); client.Close(); //输出 Counter=287

选择单例模式

只有应用程序域符合单例模式场景才能使用单例对象。一个纯粹的单例对象一种性质单一且唯一的资源。典型的例子就是 全局日志。