ServiceContractAttribute.CallbackContract Property

public:
 property Type ^ CallbackContract { Type ^ get(); void set(Type ^ value); };

public Type CallbackContract { get; set; }

member this.CallbackContract : Type with get, set

Public Property CallbackContract As Type

Property Value

A Type that indicates the callback contract. The default is null.

Examples

The following code example shows a service that specifies a callback contract, which indicates that a service of type IDuplexHello must have a correspondent that implements a service of type IHelloCallbackContract. In addition, IHelloCallbackContract implements a one-way callback method, enabling the service to call the client without waiting for a reply to support a distributed, event-driven client.

using System;
using System.Collections.Generic;
using System.ServiceModel;
using System.Threading;

namespace Microsoft.WCF.Documentation
{
 [ServiceContract(
 Name = "SampleDuplexHello",
 Namespace = "http://microsoft.wcf.documentation",
 CallbackContract = typeof(IHelloCallbackContract),
 SessionMode = SessionMode.Required
 )]
 public interface IDuplexHello
 {
 [OperationContract(IsOneWay = true)]
 void Hello(string greeting);
 }

 public interface IHelloCallbackContract
 {
 [OperationContract(IsOneWay = true)]
 void Reply(string responseToGreeting);
 }

 public class DuplexHello : IDuplexHello
 {
 public DuplexHello()
 {
 Console.WriteLine("Service object created: " + this.GetHashCode().ToString());
 }

 ~DuplexHello()
 {
 Console.WriteLine("Service object destroyed: " + this.GetHashCode().ToString());
 }

 public void Hello(string greeting)
 {
 Console.WriteLine("Caller sent: " + greeting);
 Console.WriteLine("Session ID: " + OperationContext.Current.SessionId);
 Console.WriteLine("Waiting two seconds before returning call.");
 // Put a slight delay to demonstrate asynchronous behavior on client.
 Thread.Sleep(2000);
 IHelloCallbackContract callerProxy
 = OperationContext.Current.GetCallbackChannel<IHelloCallbackContract>();
 string response = "Service object " + this.GetHashCode().ToString() + " received: " + greeting;
 Console.WriteLine("Sending back: " + response);
 callerProxy.Reply(response);
 }
 }
}

Imports System.Collections.Generic
Imports System.ServiceModel
Imports System.Threading

Namespace Microsoft.WCF.Documentation
 <ServiceContract(Name:="SampleDuplexHello", Namespace:="http://microsoft.wcf.documentation", _
 CallbackContract:=GetType(IHelloCallbackContract), SessionMode:=SessionMode.Required)> _
 Public Interface IDuplexHello
 <OperationContract(IsOneWay:=True)> _
 Sub Hello(ByVal greeting As String)
 End Interface

 Public Interface IHelloCallbackContract
 <OperationContract(IsOneWay := True)> _
 Sub Reply(ByVal responseToGreeting As String)
 End Interface

 Public Class DuplexHello
 Implements IDuplexHello
 Public Sub New()
 Console.WriteLine("Service object created: " & Me.GetHashCode().ToString())
 End Sub

 Protected Overrides Sub Finalize()
 Console.WriteLine("Service object destroyed: " & Me.GetHashCode().ToString())
 End Sub

 Public Sub Hello(ByVal greeting As String) Implements IDuplexHello.Hello
 Console.WriteLine("Caller sent: " & greeting)
 Console.WriteLine("Session ID: " & OperationContext.Current.SessionId)
 Console.WriteLine("Waiting two seconds before returning call.")
 ' Put a slight delay to demonstrate asynchronous behavior on client.
 Thread.Sleep(2000)
 Dim callerProxy = OperationContext.Current.GetCallbackChannel(Of IHelloCallbackContract)()
 Dim response = "Service object " & Me.GetHashCode().ToString() & " received: " & greeting
 Console.WriteLine("Sending back: " & response)
 callerProxy.Reply(response)
 End Sub
 End Class
End Namespace

Remarks

Specify an interface in the CallbackContract property that represents the required opposite contract in a two-way (or duplex) message exchange. This enables client applications to listen for inbound operation calls that the server-side service application can send independently of client activity. Callback contracts that have one-way operations represent calls from the service that the client can handle.