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

一、实例上下文模式概述

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

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

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

[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) 它可以用于队列离线调用，因为它能够建立服务实例与离散队列消息之间的简单映射。

使用单调模式

////////////////////服务端代码////////////////////
    [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()

设计单调模式

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

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

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

[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服务对象之后，代理就不可以继续使用了。如果试图再次调用一个方法，就会产生一个通信异常错误。

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

配置私有会话

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

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

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

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

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

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

SessionMode.Allowed值

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

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

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

SessionMode.Required值

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

    [ServiceContract(SessionMode=SessionMode.Required)]
    public interface IService2
    {...}
public class Service2:IService2,IDisposable
{...}</pre>

        若要设计一个会话契约，主张使用SessionMode.Required值，而非SessionMode.Allowed值
/////////////////////服务端代码/////////////////////
[ServiceContract(SessionMode=SessionMode.Required)]
    public interface IService2
    {
        [OperationContract]
        void MyMethod();
    }
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()");
    }
}

/////////////////////服务端代码/////////////////////

Service2Client client = new Service2Client();

client.MyMethod();

client.MyMethod();

client.Close();

/////////////////////输出/////////////////////

Service2.Service1()

1

2

Service2.Dispose()

SessionMode.NotAllowed值
        SessionMode.NotAllowed值用于禁止使用传输层会话，也不允许使用应用层会话。不管如何配置，使用该值的服务总是采用单调服务方式。
        考虑到代码的可读性，建议在选择使用SessionMode.NotAllowed值的同时，总是将服务配置为单调服务，即：
 [ServiceContract(SessionMode=SessionMode.NotAllowed)]
    public interface IService2
    {...}
[ServiceBehavior(InstanceContextMode=InstanceContextMode.PerCall)]
public class Service2:IService2
{...}</pre>

绑定、契约配置和服务行为与它们对应的实例模式

四、单例(Single)模式

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

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

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

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

 //////////////////////服务端代码//////////////////////
[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

初始化单例服务

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

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

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

//服务端
[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

选择单例模式

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