C# 4 and .NET 4

1306 ❘ ChaPTer 43 windOws cOmmunicAtiOn fOundAtiOn
duPleX CommuniCaTion
The next sample application shows how a duplex communication can be done between the client and the
service. The client starts the connection to the service. After the client connects to the service, the service
can call back into the client.
For duplex communication, a contract must be specified that is implemented in the client. Here the contract
for the client is defined by the interface IMyMessageCallback. The method implemented by the client is
OnCallback(). The operation has the operation contract setting IsOneWay=true applied. This way, the
service doesn’t wait until the method is successfully invoked on the client. By default, the service instance
can be invoked from only one thread (see the ConcurrencyMode property of the service behavior, which is,
by default, set to ConcurrencyMode.Single).
If the service implementation now does a callback to the client and waits to get an answer from the client,
the thread getting the reply from the client must wait until it gets a lock to the service object. Because the
service object is already locked by the request to the client, a deadlock occurs. WCF detects the deadlock
and throws an exception. To avoid this situation, you can change the ConcurrencyMode property to the
value Multiple or Reentrant. With the setting Multiple, multiple threads can access the instance
concurrently. Here, you must implement locking on your own. With the setting Reentrant, the service
instance stays single-threaded, but allows answers from callback requests to reenter the context. Instead
of changing the concurrency mode, you can specify the IsOneWay property with the operation contract.
This way, the caller does not wait for a reply. Of course, this setting is possible only if return values are not
expected.
The contract of the service is defined by the interface IMyMessage. The callback contract is mapped to the
service contract with the CallbackContract property of the service contract definition:
public interface IMyMessageCallback
{
[OperationContract(IsOneWay=true)]
void OnCallback(string message);
}
[ServiceContract(CallbackContract=typeof(IMyMessageCallback))]
public interface IMyMessage
{
[OperationContract]
void MessageToServer(string message);
}
code snippet MessageService/IMyMessage.cs
The class MessageService implements the service contract IMyMessage. The service writes the message
from the client to the console. To access the callback contract, you can use the OperationContext class.
OperationContext.Current returns the OperationContext that is associated with the current request
from the client. With the OperationContext, you can access session information, message headers
and properties, and, in the case of a duplex communication, the callback channel. The generic method
GetCallbackChannel() returns the channel to the client instance. This channel can then be used to send
a message to the client by invoking the method OnCallback(), which is defined with the callback interface
IMyMessageCallback. To demonstrate that it is also possible to use the callback channel from the service
independently of the completion of the method, a new thread that receives the callback channel is created.
The new thread sends messages to the client by using the callback channel.
public class MessageService: IMyMessage
{
public void MessageToServer(string message)
{
Console.WriteLine("message from the client: {0}", message);
IMyMessageCallback callback =
OperationContext.Current.
www.it-ebooks.info