A Simple Duplex Service in WCF

No.of Views2939
Bookmarked0 times
Downloads 
Votes0
By  Dhananjay Kumar   On  07 Sep 2010 10:09:09
Tag : WCF , REST Services
This article will give step by step explanation on how to create a simple duplex service in WCF. In call back operation or duplex service, Service can also call some function at the client .
emailbookmarkadd commentsprint

Images in this article missing? We recently lost them in a site migration. We're working to restore these as you read this. Should you need an image in an emergency, please contact us at info@codegain.com

 

Introduction

This article will give step by step explanation on how to create a  simple duplex service in WCF. In call back operation or duplex service, Service  can also call some function at the client .

 

Image Loading

1.    Duplex service allows calling back some operation (function) on the client.
2.    Duplex service also knows as Call Backs.
3.    All Binding does not support duplex service.
4.    Duplex communication is not standard. They are absolute Microsoft feature.
5.    wsDualHttpBinding supports duplex communication over HTTP binding.
6.    Duplex communication is possible over netTcpBinding and netNamedPipeBinding

Steps involved in creating a duplex service

1.    Create a WCF Service
2.    Create a call back contract.
3.    Create service contract
4.    Implement service and configure the behavior for duplex communication and call the client function at the service.
5.    Configure the endpoint for duplex service
6.    Create the client.
7.    Call the WCF Service

Create a WCF Service

1.    Open visual studio and create a new project. Select WCF Service application from WCF project template tab.
2.    Delete all the default generated code.
3.    If using VS2010, open web.config and comment serviceHostEnvironment as below.

Image Loading

4.    If using VS2008 then delete the default End Point generated.
5.    Now you are left with empty IService1 and Service1.svc.cs file.

 

Create a call back contract

1.    Open IService1.cs .
2.    Add an interface in the same file. Give any name of the interface. I am giving name here IMyContractCallBack 

Image Loading

3.    Create an operation contract in the Interface.
4.    Make sure return type is Void.
5.    Make sure IsOneWayProperty is set to true.
6.    There is no need to mark call back interface as ServiceContract.

Explanation

At the client side, this call back interface will get implemented and on a duplex channel Service will call the CallBackFunction from the client.

Create service contract

1.    Open IService1.
2.    Declare operation contract called from the client.  Make the isoneway to property to true from the service operation contract also.

Image Loading

3.    Set the CallBackContract in Service contract attribute. Set the call back contract as the interface created for the call back.

Image Loading

Here IMyContractCallBack is name of the interface user for duplex communication.

So Service contract and call back contract will be as below,

IService1.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.ServiceModel.Web;
using System.Text;

namespace WcfService3
{
   
    [ServiceContract(CallbackContract=typeof(IMyContractCallBack))]public interface IService1
    {
        [OperationContract(IsOneWay=true)]void   NormalFunction();

    }public interface IMyContractCallBack
    {
        [OperationContract(IsOneWay=true)]void    CallBackFunction(string str); 

    }

    
}

 Implement service and configure for duplex communication and call client function

1.    In service behavior set the instance mode of the service to percall.

Image Loading

2.    Create a call back channel 

Image Loading

Here I am using OperationConetxt to get current call back channel.

3.    Now instance of IMyContractCallBack can be used to make call at the function in call back interface contract at the client side.  Like below ,

Image Loading

Here we are going to call function at the client side from the operation contract of the service. 

Service1.svc.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.ServiceModel.Web;
using System.Text;

namespace WcfService3
{   
    [ServiceBehavior(InstanceContextMode= InstanceContextMode.PerCall)]public class Service1 : IService1
    {public void     NormalFunction()
        {

            IMyContractCallBack callback = OperationContext.Current.GetCallbackChannel<IMyContractCallBack>();        
            callback.CallBackFunction("Calling from Call Back");
            
        }

    }
}

Configure the endpoint for duplex service

As we discussed earlier that duplex service is not supported by all type of bindings.   So while configuring the end point for the service we need to choose the binding supports duplex communication.  Here we are going to use wsDualHttpBinding

1.    Declare the end point with wsDualHttpBinding.

Image Loading

2.    Declare the Meta data exchange end point.

Image Loading

3.    Declare the host address

Image Loading

4.    Declare the service behavior

Image Loading

So the service in configuration will look like

Image Loading

Web.Config

<?xml version="1.0"?>
<configuration>
  <system.web>
    <compilation debug="true" targetFramework="4.0" />
  </system.web>
  <system.serviceModel>
    <behaviors>
      <serviceBehaviors>
        <behavior name ="svcbh">         
          <serviceMetadata httpGetEnabled="False"/>         
          <serviceDebug includeExceptionDetailInFaults="False"/>
        </behavior>
      </serviceBehaviors>
    </behaviors>
    <!--<serviceHostingEnvironment multipleSiteBindingsEnabled="true" />-->
    <services>
      <service name ="WcfService3.Service1" behaviorConfiguration ="svcbh" >
        <host>
          <baseAddresses>
            <add baseAddress = "http//localhost:9000/Service1/" />
          </baseAddresses>
        </host>
        <endpoint name ="duplexendpoint" 
                  address ="" 
                  binding ="wsDualHttpBinding" 
                  contract ="WcfService3.IService1"/>
        <endpoint name ="MetaDataTcpEndpoint"
                  address="mex" 
                  binding="mexHttpBinding" 
                  contract="IMetadataExchange"/>
      </service>
    </services>
  </system.serviceModel>
 <system.webServer>
    <modules runAllManagedModulesForAllRequests="true"/>
  </system.webServer>  
</configuration>

Create the client

1.    Create a console application to consume this service.
2.    Add the reference of System.ServiceModel. In console application project.
3.    Add the service reference of the service, we created in previous steps.

Create a duplex proxy class to implement call back contract

1.    Right click and add a class in console application.  Give any name; I am giving the name MyCallBack.
2.    Add the namespace 

Image Loading

3.    Implement call back contract. In our case it is IService1Callback and IDisposable.

Image Loading

Note:   Since name of the service contract is IService1, so the call back interface name will be IService1Callback . It is name of service contract suffixes by keyword CallBack.

4.    Now implement the call back contract method in this class. 

Image Loading

5.     Now make a function in this class to create duplex proxy.

a.    Create an instance of InstanceContext and pass the reference of current class in the constructor of that.

Image Loading

b.    Pass this context as parameter of  service1client 

Image Loading

c.    Call the  service on this proxy 

Image Loading

So, the function will be 

Image Loading

For your reference MyCallback class will be as below,

MyCallback.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using ConsoleApplication1.ServiceReference1;
using System.ServiceModel;

namespace ConsoleApplication1
{class MyCallBack :IService1Callback ,IDisposable 

    {
        Service1Client proxy;public void   CallBackFunction(string str)
        {
            Console.WriteLine(str);
        }public void callService()
        {
           InstanceContext context = new InstanceContext(this);
           proxy = new Service1Client(context);
           proxy.NormalFunction();

        }public void Dispose()
        {
            proxy.Close();
        }
    }
}

 Call the WCF Service

Create the instance of  MyCallBack class and  call the callService() method to call the service.

Program.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using ConsoleApplication1.ServiceReference1;
using System.ServiceModel; 

namespace ConsoleApplication1
{class Program
    {static void Main(string[] args)
        {

            MyCallBack obj = new MyCallBack();
            obj.callService();
            Console.Read();
            obj.Dispose();

        }
    }
}

 Output 

Image Loading

Hope help.Happy coding.

 
Sign Up to vote for this article
 
About Author
 
Dhananjay Kumar
Occupation-Software Engineer
Company-Infosys Technolgies,Pune
Member Type-Gold
Location-India
Joined date-20 Jul 2009
Home Page-http://dhananjaykumar.net/
Blog Page-http://dhananjaykumar.net/
Dhananjay Kumar is Microsoft MVP on connected system. He blogs at http://dhananjaykumar.net/ . You can follow him http://twitter.com/debugmode_/ and reach him at dhananjay.25july@gmail.com
 
 
Other popularSectionarticles
Comments
There is no comments for this articles.
Leave a Reply
Title:
Display Name:
Email:
(not display in page for the security purphase)
Website:
Message:
Please refresh your screen using Ctrl+F5
If you can't read this number refresh your screen
Please input the anti-spam code that you can read in the image.
^ Scroll to Top
</