一、实例上下文模式概述
实例上下文(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选择单例模式
只有应用程序域符合单例模式场景才能使用单例对象。一个纯粹的单例对象一种性质单一且唯一的资源。典型的例子就是 全局日志。