Duplex Message Exchange - (WCF)
In WCF (Windows Communication Foundation), duplex message exchange is a communication pattern where the client can send and receive messages from the service simultaneously. This pattern is commonly used in scenarios where the service needs to provide real-time updates or notifications to the client.
Syntax
To implement duplex message exchange in WCF, you will need to define a callback contract in your service interface that the client can use to receive messages. Here's an example callback contract:
[ServiceContract(CallbackContract = typeof(IMyServiceCallback))]
public interface IMyService
{
[OperationContract]
void DoWork();
}
public interface IMyServiceCallback
{
[OperationContract]
void Notify(string message);
}
To enable duplex message exchange, the client must first create an instance of the callback contract and pass it to the service when it calls the service operation. Here's an example client code:
// create callback instance
var callback = new MyServiceCallback();
// create service proxy
var factory = new DuplexChannelFactory<IMyService>(callback);
var service = factory.CreateChannel();
// call service operation
service.DoWork();
In the service implementation, you can use the callback contract to send messages to the client. Here's an example service code:
public class MyService : IMyService
{
public void DoWork()
{
// get callback channel for client
var callback = OperationContext.Current.GetCallbackChannel<IMyServiceCallback>();
// send a message to the client
callback.Notify("Work done!");
}
}
Example
Here's an example of how to implement duplex message exchange in WCF using C#:
[ServiceContract(CallbackContract = typeof(IMyServiceCallback))]
public interface IMyService
{
[OperationContract]
void DoWork();
}
public interface IMyServiceCallback
{
[OperationContract]
void Notify(string message);
}
public class MyService : IMyService
{
public void DoWork()
{
// get callback channel for client
var callback = OperationContext.Current.GetCallbackChannel<IMyServiceCallback>();
// send a message to the client
callback.Notify("Work done!");
}
}
public class MyServiceCallback : IMyServiceCallback
{
public void Notify(string message)
{
Console.WriteLine("Notification: " + message);
}
}
class Program
{
static void Main(string[] args)
{
// create callback instance
var callback = new MyServiceCallback();
// create service proxy
var factory = new DuplexChannelFactory<IMyService>(callback);
var service = factory.CreateChannel();
// call service operation
service.DoWork();
Console.ReadLine();
}
}
Output
When you run the client code, you should see output that looks like this:
Notification: Work done!
Explanation
In the example code, we define a service interface (IMyService
) that includes a service operation (DoWork
) and a callback contract (IMyServiceCallback
) that includes a callback operation (Notify
). We implement the service logic in the MyService
class, where we use the OperationContext.Current.GetCallbackChannel
method to get the callback channel for the client and send a message to the client using the Notify
callback operation. In the client code, we create an instance of the MyServiceCallback
class to handle the callback messages, create a service proxy using the DuplexChannelFactory
class, and call the DoWork
service operation. When the service sends a message back to the client, the Notify
callback operation is called and the message is printed to the console.
Use
Duplex message exchange is commonly used in WCF applications for real-time updates and notifications. It is especially useful in scenarios where the client needs to receive updates from the service without explicitly requesting them.
Important Points
- Duplex message exchange is a communication pattern in WCF where the client can send and receive messages from the service simultaneously.
- To enable duplex message exchange, you will need to define a callback contract in your service interface, create a callback instance in your client code, and call the service operation using a duplex channel factory.
- The
OperationContext.Current.GetCallbackChannel
method can be used to get the callback channel for the client in the service implementation.
Summary
In this page, we discussed how to implement duplex message exchange in WCF using C#. We covered the syntax, example, output, explanation, use, important points, and summary of duplex message exchange in WCF. Duplex message exchange is a powerful communication pattern that enables real-time updates and notifications in WCF applications.