namespace MyService
{
    [ServiceContract(CallbackContract = typeof(IRenewable))]

    public interface IMyBaseContract
    {

        // No 'forward' operations

    }

    public interface IRenewable
    {

        [OperationContract]
        void Renew();

    }

    [ServiceContract(CallbackContract = typeof(IMyServiceCallback))]

    public interface IMyService : IMyBaseContract
    {

        [OperationContract]
        void MyServiceMethod();

        [OperationContract(IsOneWay = true)]
        void calculation(int id);
    }

    public interface IMyServiceCallback : IRenewable
    {

        [OperationContract(IsOneWay = true)]
        void OnCallbackMethod(int id);

    }

}

namespace MyService
{

    public class MyService : IMyService
    {
        ServiceHost host;


        #region IMyService Members

        public void MyServiceMethod()
        {
            
           
        }

        public void calculation(int id)
        {
            if (id >  10 )
            {
                IMyServiceCallback callback = OperationContext.Current.GetCallbackChannel<IMyServiceCallback>();
                callback.OnCallbackMethod( 5 );

            }
        }

        #endregion
    }
}

public partial class Window1 : Window
    {
        MyServiceClient client;
        InstanceContext context;
        public Window1()
        {
            InitializeComponent();
            context = new InstanceContext(new ClientCallback());
            client = new MyServiceClient(context);
    
           
        }

        private void Button_Click(object sender, RoutedEventArgs e)
        {
            client.calculation(Convert.ToInt16(tb.Text));

        }
    }

    public class ClientCallback : IMyServiceCallback
    {


        #region IMyServiceCallback Members

        public void Renew()
        {

        }

        public void OnCallbackMethod(int id)
        {
            if (id ==  15 )
            {
                MessageBox.Show(id.ToString());
            }
        }

        #endregion
    }
}

 client.calculation(Convert.ToInt16(tb.Text));

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <system.web>
    <compilation debug="true" />
  </system.web>
  <!-- When deploying the service library project, the content of the config file must be added to the host's 
  app.config file. System.Configuration does not support config files for libraries. -->
  <system.serviceModel>
    <services>
      <service name="CallbackService.MyService" behaviorConfiguration="CallbackService.MyServiceBehavior">
        <host>
          <baseAddresses>
            <add baseAddress = "http://localhost:6577/MyService" />
          </baseAddresses>
        </host>
        <!-- Service Endpoints -->
        <!-- Unless fully qualified, address is relative to base address supplied above -->
        <endpoint address ="http://localhost:6577/MyService" binding="wsDualHttpBinding" contract="CallbackService.IMyContract">
          <!-- 
              Upon deployment, the following identity element should be removed or replaced to reflect the 
              identity under which the deployed service runs.  If removed, WCF will infer an appropriate identity 
              automatically.
          -->
          <identity>
            <dns value="localhost"/>
          </identity>
        </endpoint>
        <!-- Metadata Endpoints -->
        <!-- The Metadata Exchange endpoint is used by the service to describe itself to clients. --> 
        <!-- This endpoint does not use a secure binding and should be secured or removed before deployment -->
        <endpoint address="mex" binding="mexHttpBinding" contract="IMetadataExchange"/>
      </service>
    </services>
    <behaviors>
      <serviceBehaviors>
        <behavior name="CallbackService.MyServiceBehavior">
          <!-- To avoid disclosing metadata information, 
          set the value below to false and remove the metadata endpoint above before deployment -->
          <serviceMetadata httpGetEnabled="True"/>
          <!-- To receive exception details in faults for debugging purposes, 
          set the value below to true.  Set to false before deployment 
          to avoid disclosing exception information -->
          <serviceDebug includeExceptionDetailInFaults="False" />
        </behavior>
      </serviceBehaviors>
    </behaviors>
  </system.serviceModel>
</configuration>

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <system.serviceModel>
    <services >
      <service behaviorConfiguration="ServiceBehavior"
      name="CallbackService.MyService">
        <endpoint address="http://localhost:6577/MyService"
        binding="wsDualHttpBinding" contract="CallbackService.IMyContract">
          <identity>
            <dns value="localhost"/>
          </identity>
        </endpoint>
        <endpoint address="mex"
        binding="mexHttpBinding" contract="IMetadataExchange"/>
      </service>
    </services>
    <behaviors>
      <serviceBehaviors>
        <behavior name="ServiceBehavior">
          <serviceMetadata httpGetEnabled="true"/>
          <serviceDebug includeExceptionDetailInFaults="true "/>
        </behavior>
      </serviceBehaviors>
    </behaviors>
  </system.serviceModel>

</configuration>

 public partial class Window1 : Window
    {
        MyServiceClient proxy;
        public Window1()
        {
            InitializeComponent();
            IMyContractCallback callback = new MyCallback();
            InstanceContext cntx = new InstanceContext(callback);
            try
            {
                proxy = new MyServiceClient(cntx);
            }
            catch(Exception ex)
            {
                MessageBox.Show(ex.Message);

            }

        }

        private void Button_Click(object sender, RoutedEventArgs e)
        {
            proxy.MyMethodString(tb.Text);
        }
    }


    class MyServiceClient : DuplexClientBase<IMyContract>, IMyContract
    {
        public MyServiceClient(InstanceContext callbackCntx)
            : base(callbackCntx)
        {
        }
        public void MyMethodString(string values)
        {
            base.Channel.MyMethodString(values);
        }
    }
    class MyCallback : IMyContractCallback
    {

        #region IMyContractCallback Members

        public void OnMyMethodString(string values)
        {
            MessageBox.Show(values);
        }

        #endregion
    }

 try
            {
                proxy = new MyServiceClient(cntx);
            }
            catch(Exception ex)
            {
                MessageBox.Show(ex.Message);

            }