WCF callbacks are an old topic, but recently I got a chance to play around it. WCF callback means instead of normal request – response pattern, it will be a bidirectional communication between client and server.

First need to create the service interface

[ServiceContract(CallbackContract = typeof(IServiceCallback),
Namespace = "http://dotnetthoughts.net/wcf")]
interface IService
{
    [OperationContract(IsOneWay = true)]
    void SayHello(string name);
}

If you notice the Service contract attribute, there is parameter, Callback contract, which is required to map the service call with the callback method. And here is the callback contract interface.

interface IServiceCallback
{
    [OperationContract(IsOneWay = true)]
    void Print(string message);
}

And here is the implementation of the service and callback interface.

class Service : IService
{
    public void SayHello(string name)
    {
        IServiceCallback callback =
            OperationContext.Current.GetCallbackChannel<IServiceCallback>();
        string message = string.Format("Hello {0}", name);
        callback.Print(message);
    }
}

class ServiceCallback : IServiceCallback
{
    public void Print(string message)
    {
        Console.WriteLine(message);
    }
}

I am using Self Hosting mode to host the service. And here is the implementation.

class Program
{
    static void Main(string[] args)
    {
        string baseAddress = "net.tcp://localhost:8080/";
        Uri[] addresses = { new Uri(baseAddress) };
        using (var serviceHost = new ServiceHost(typeof(Service), addresses))
        {
            serviceHost.AddServiceEndpoint(typeof(IService),
                new NetTcpBinding(), "IService");

            serviceHost.Open();
            Console.WriteLine("Service started.");
            Console.WriteLine("Press any key to stop.");
            Console.ReadKey(true);
            serviceHost.Close();
        }
    }
}

Now we need to create proxy to communicate to our service. Here is the proxy implementation.

class ServiceProxy : DuplexClientBase<IService>, IService
{
    public ServiceProxy(object callbackInstance,
        Binding binding, EndpointAddress remoteAddress)
        : base(callbackInstance, binding, remoteAddress)
    {

    }
    public void SayHello(string name)
    {
        Channel.SayHello(name);
    }
}

And finally here is the client implementation, in the client class; I am implementing the callback interface, so that I can get the callback result in the client.

class Client : IServiceCallback
{
    public void SayHelloToService(string name)
    {
        var proxy =
            new ServiceProxy(this, new NetTcpBinding(),
                new EndpointAddress("net.tcp://localhost:8080/IService"));
        proxy.SayHello(name);
    }

    public void Print(string message)
    {
        Console.WriteLine(message);
    }
}

Now start the Service first then create the instance of client class and invoke SayHelloToService with name parameter and it will be printed in the console. And here is the Test for the same.

[TestClass]
public class TestService : IServiceCallback
{
    private string actual = string.Empty;
    private AutoResetEvent autoResetEvent = null;
    [TestMethod]
    public void TestSayHello()
    {
        string expected = "Hello dotnetthoughts";
        autoResetEvent = new AutoResetEvent(false);
        var proxy =
            new ServiceProxy(this, new NetTcpBinding(),
                new EndpointAddress("net.tcp://localhost:8080/IService"));
        proxy.SayHello("dotnetthoughts");
        Assert.IsTrue(autoResetEvent.WaitOne(5000), @"Callback not recevied.");
        Assert.IsTrue(expected == actual, @"Invalid response from callback.");
    }

    public void Print(string message)
    {
        actual = message;
        autoResetEvent.Set();
    }
}

Happy Coding