WCF中，并发是一个很影响服务性能的重要方面。通过ServiceBehaviorAttribute中的ConcurrencyMode可以设置服务的并发性。

对于双工通讯来说，服务对客户端的回调也是通过代理完成的。那么这又涉及到另外一个问题：回调客户端时，能否让回调服务也并发执行呢？WCF中定义了CallbackBehaviorAttribute ，可以通过它来设置回调服务的行为。它同样定义了ConcurrencyMode，可指定回调的并发模式,但它没有定义回调的实例模式，即InstanceContextMode。本文主要探讨服务的并发与回调服务的并发。

目录：

 

1. 测试重入与回调并发 
2. 会话对 重入与回调并发 
3. 设置服务并发的ServiceBehaviorAttribute能用于回调服务吗？

通过实例进行说明：

 

契约定义：

[ServiceContract(CallbackContract = 

typeof

(IAddCallback))]   

publicinterface IAdd

{

    [OperationContract]

    void Add(int x, int y);

}

回调契约定义：

    

public 

interface

 IAddCallback  

    {

        [OperationContract]

        void ShowResult(int result);

    }

服务实现：

    

public 

class

 AddService : IAdd 

    {

        private readonly int counter;

        public AddService()

        {

            counter++;

            Console.ResetColor();

            Console.WriteLine(string.Format("AddService Construction function excute... counter is {0}", counter));

        }

        #region IAdd 成员

        public void Add(int x, int y)

        {

            var clientId = OperationContext.Current.IncomingMessageHeaders.GetHeader<int>(MessageWrapper.headerClientId,

                                                                                          MessageWrapper.headerNamespace);

            Console.ForegroundColor = ConsoleColor.Red;

            Console.WriteLine(string.Format("Time:{0};ThreadId is :{1}.Request Id is {2} Add Method Invoked,", DateTime.Now,

                                            Thread.CurrentThread.ManagedThreadId, clientId));

            Thread.Sleep(5000);

            int result = x + y;

            MessageHeader<int> header = new MessageHeader<int>(clientId);

            System.ServiceModel.Channels.MessageHeader messageHeader =

                header.GetUntypedHeader(MessageWrapper.headerClientId,

                                        MessageWrapper.headerNamespace);

            OperationContext.Current.OutgoingMessageHeaders.Add(messageHeader);

            Console.WriteLine(string.Format("Time: {1} Requst Id {0} begin Callback",clientId,DateTime.Now));

            IAddCallback callbackProxy= OperationContext.Current.GetCallbackChannel<IAddCallback>();

            callbackProxy.ShowResult(result);

            Console.WriteLine(string.Format("Time: {1} Requst Id {0} Callback finished", clientId, DateTime.Now));

            Console.WriteLine(string.Format("result is : {0}",result));

            Thread.Sleep(5000);

            Console.WriteLine("=========Excute finished=========");

            Console.WriteLine();

        }

        #endregion

    }

服务配置：

    

   

<system.serviceModel>

<services>

            <service name="Service.AddService">

                <endpoint address="http://127.0.0.1:3636/AddService" binding="wsDualHttpBinding" contract="Contract.IAdd" ></endpoint>

            </service>

        </services>

    </system.serviceModel>

客户端调用：

    

public 

class AddCallback : IAddCallback

    {

        

private 

readonly 

int counter;

        

public AddCallback()

        {

            counter++;

            Console.WriteLine(

string.Format(

"

AddCallback Construction function excute... counter is {0}

", counter));

        }

        

#region IAddCallback 成员

        

public 

void ShowResult(

int result)

        {            

            

int callbackRequestId= OperationContext.Current.IncomingMessageHeaders.GetHeader<

int>(MessageWrapper.headerClientId,

                                                                           MessageWrapper.headerNamespace);

            Console.ForegroundColor = ConsoleColor.Yellow;

            Console.WriteLine(

string.Format(

"

Time: {1} ThreadId is :{2} Callback RequestId : {0} 开始执行回调

", callbackRequestId, DateTime.Now,Thread.CurrentThread.ManagedThreadId));

            Thread.Sleep(

10000);

            Console.WriteLine(

string.Format(

"

Add result is {0}

", result));

            Console.WriteLine(

string.Format(

"

Time: {1} ThreadId is :{2} Callback RequestId : {0} 回调结束

", callbackRequestId, DateTime.Now, Thread.CurrentThread.ManagedThreadId));

            Console.WriteLine(

"

==================

");

            Console.WriteLine();

        }

#endregion 

      

}

  

回调服务实现：

static 

void InvokeWithDiffrentProxy()

        {

            InstanceContext instanceContext=

new InstanceContext(

new AddCallback());

            DuplexChannelFactory<IAdd> factory = 

new DuplexChannelFactory<IAdd>(instanceContext,

"

AddService

");

            

for (

int i = 

0; i < 

2; i++)

            {

                IAdd proxy = factory.CreateChannel();

                ThreadPool.QueueUserWorkItem(

delegate

                                                 {

                                                     

int clientId = Interlocked.Increment(

ref index);

                                                     

using (

                                                         OperationContextScope contextScope =

                                                             

new OperationContextScope(proxy 

as IContextChannel))

                                                     {

                                                         MessageHeader<

int> header = 

new MessageHeader<

int>(clientId);

                                                         System.ServiceModel.Channels.MessageHeader messageHeader =

                                                             header.GetUntypedHeader(MessageWrapper.headerClientId,

                                                                                     MessageWrapper.headerNamespace);

                                                         OperationContext.Current.OutgoingMessageHeaders.Add(messageHeader);

                                                         proxy.Add(

1, 

2);

                                                     }

                                                 });

            }

        }

注意：如果XP下，使用wsDualHttpBinding作为绑定协议，需要对绑定做一下设置：

<bindings>

    <wsDualHttpBinding>

        <bind name=

"

wsDuplexBinding

">

            <clientBaseAddress  address=

"

http://127.0.0.1:6300/addCallbackService

">

        <bind>

        <wsDualHttpBinding>

</bindings>

下面做几个测试，观察一下服务端以及回调客户端的执行。

 

测试1：

服务端：ConcurrencyMode = ConcurrencyMode.Reentrant,InstanceContextMode = InstanceContextMode.Single

客户端：ConcurrencyMode = ConcurrencyMode.Single

回调服务休眠10秒

服务端输出：

 

客户端输出：

 

 

测试2：

服务端：ConcurrencyMode = ConcurrencyMode.Reentrant,InstanceContextMode = InstanceContextMode.Single

客户端：ConcurrencyMode = ConcurrencyMode.Single

回调服务休眠1秒

服务端输出：

 

客户端输出：

 

通过测试1、2的一组图的输出可知：

Reentrant + Single 模式下：服务一次只能执行一个服务,当服务执行回调时，请求队列中的下一个请求将被服务执行。在回调服务的单实例模式下：回调也需要排队等待被处理。测试2的一组图显示：调用1的回调在时间为11：25：10的时候回调已经完成，但是回到服务端时，另外一个服务正占用锁，它只能等待。

这说明：当回调服务完成，回调客户端时，需要等待服务正在被处理的请求释放锁后才能被继续执行。

测试3：

服务端：ConcurrencyMode = ConcurrencyMode.Reentrant,InstanceContextMode = InstanceContextMode.PerSession

客户端：ConcurrencyMode = ConcurrencyMode.Single

服务端输出：

 

客户端输出：

 

通过上图分析知：服务对调用的请求通过并发的方式执行，而服务对客户端的回调还是串行的方式。

测试4：

服务端：ConcurrencyMode = ConcurrencyMode.Reentrant,InstanceContextMode = InstanceContextMode.PerCall

 客户端：ConcurrencyMode = ConcurrencyMode.Single

服务端输出：

 

客户端输出：

 

测试结果和测试3一样。

测试5：

服务端：ConcurrencyMode = ConcurrencyMode.Reentrant,InstanceContextMode = InstanceContextMode.Single

客户端：ConcurrencyMode = ConcurrencyMode.Multiple

服务端输出：

 

客户端输出：

 

通过上图分析知：服务对调用的请求通过串行的方式执行，而服务对客户端的回调是并行的方式。

测试6：

服务端：ConcurrencyMode = ConcurrencyMode.Reentrant,InstanceContextMode = InstanceContextMode.PerSession

客户端：ConcurrencyMode = ConcurrencyMode.Multiple

服务端输出：

 

客户端输出： 

 

通过上图分析知：服务对调用的请求以及服务对客户端的回调是并行的方式。

测试7：

服务端：ConcurrencyMode = ConcurrencyMode.Reentrant,InstanceContextMode = InstanceContextMode.PerSession

客户端：ConcurrencyMode = ConcurrencyMode.Multiple

服务端输出：

 

客户端输出： 

 

通过上图分析知：服务对调用的请求以及服务对客户端的回调是并行的方式。

测试8会话模式：

服务端：ConcurrencyMode = ConcurrencyMode.Reentrant,InstanceContextMode = InstanceContextMode.PerSession

客户端：ConcurrencyMode = ConcurrencyMode.Single

服务端输出：

 

客户端输出：

 

通过上图分析知：服务对调用的请求并发进行处理，服务对客户端的回调以串行的方式处理。

测试9会话模式：

服务端：ConcurrencyMode = ConcurrencyMode.Reentrant,InstanceContextMode = InstanceContextMode.PerSession

客户端：ConcurrencyMode = ConcurrencyMode.Multiple

服务端输出：

 

客户端输出：

 

服务对调用的请求以及服务对客户端的回调是并行的方式。

如果将ServiceBehaviorAttribute用于回调类型，结果会怎样呢？

测试10会话模式：

服务端：ConcurrencyMode = ConcurrencyMode.Reentrant,InstanceContextMode = InstanceContextMode.PerSession

客户端：ServiceBehavior(ConcurrencyMode = ConcurrencyMode.Single)

服务端输出：

 

客户端输出：

 

通过上图分析知：服务对调用的请求并发进行处理，服务对客户端的回调以并行的方式处理。

测试11会话模式：

服务端：ConcurrencyMode = ConcurrencyMode.Reentrant,InstanceContextMode = InstanceContextMode.PerSession

客户端：ServiceBehavior(ConcurrencyMode = ConcurrencyMode.Multiple,InstanceContextMode = InstanceContextMode.PerCall)

服务端输出：

客户端输出：

 

测试12会话模式：

服务端：ConcurrencyMode = ConcurrencyMode.Reentrant,InstanceContextMode = InstanceContextMode.PerSession

客户端：ServiceBehavior(ConcurrencyMode = ConcurrencyMode.Multiple,InstanceContextMode = InstanceContextMode.PerSession)

服务端输出：

 

客户端输出：

 

测试10、测试11、测试12分析知：服务对调用的请求并发进行处理；服务对客户端的回调以串行的方式处理，这点可以从回调的构造，以及打印出来的时间两方面得到验证。

对回调使用ServiceBehaviorAttribute无效。

测试13会话模式：

服务端：ConcurrencyMode = ConcurrencyMode.Reentrant,InstanceContextMode = InstanceContextMode.PerSession

客户端：ConcurrencyMode = ConcurrencyMode.Single

同一客户端并发调用服务，将调用代码做如下更改：

(proxy as ICommunicationObject).Open();

服务端输出：

 

客户端输出：

测试14会话模式：

ConcurrencyMode = ConcurrencyMode.Reentrant,InstanceContextMode = InstanceContextMode.PerSession

ConcurrencyMode = ConcurrencyMode.Multiple

同一客户端并发调用服务，将调用代码做如下更改：

(proxy as ICommunicationObject).Open();

服务端输出：

 

客户端输出：

测试15：

ConcurrencyMode = ConcurrencyMode.Reentrant,InstanceContextMode = InstanceContextMode.PerSession

ConcurrencyMode = ConcurrencyMode.Multiple

同一客户端并发调用服务，将调用代码做如下更改：

(proxy as ICommunicationObject).Open();

服务端输出：

 

客户端输出： 

 

测试16：

ConcurrencyMode = ConcurrencyMode.Reentrant,InstanceContextMode = InstanceContextMode.PerCall

ConcurrencyMode = ConcurrencyMode.Multiple

同一客户端并发调用服务，将调用代码做如下更改：

(proxy as ICommunicationObject).Open();

服务端输出：

 

客户端输出：

测试17：

ConcurrencyMode = ConcurrencyMode.Reentrant,InstanceContextMode = InstanceContextMode.Single

ConcurrencyMode = ConcurrencyMode.Multiple

同一客户端并发调用服务，将调用代码做如下更改：

(proxy as ICommunicationObject).Open();

服务端输出：

 

客户端输出：

 

 

测试18：

服务端：ConcurrencyMode = ConcurrencyMode.Reentrant,InstanceContextMode = InstanceContextMode.PerCall

客户端：ServiceBehavior(ConcurrencyMode = ConcurrencyMode.Multiple,InstanceContextMode = InstanceContextMode.PerCall) 

服务端输出：

 

客户端输出：

 

 

  由测试10、11、12、18这些测试得出如下结论：ServiceBehaviorAttribute对回调服务的并发设置无效。

 会话模式下，不同客户端代理对可重入的服务总是以并发的方式执行；相同客户端对可重入的服务总是以串行的方式执行，而无论怎样，回调服务总是以串行的方式执行。