Como: Criar um contrato duplex

Este tópico mostra as etapas básicas para criar métodos que usam um contrato duplex (bidirecional). Um contrato duplex permite que clientes e servidores se comuniquem entre si de forma independente para que um possa iniciar chamadas para o outro. O contrato duplex é um dos três padrões de mensagem disponíveis para os serviços do Windows Communication Foundation (WCF). Os outros dois padrões de mensagem são unidirecional e solicitação-resposta. Um contrato duplex consiste em dois contratos unidirecionais entre o cliente e o servidor e não requer que as chamadas de método sejam correlacionadas. Use este tipo de contrato quando o seu serviço tiver de consultar o cliente para obter mais informações ou levantar explicitamente eventos sobre o cliente. Para obter mais informações sobre como criar um aplicativo cliente para um contrato duplex, consulte Como acessar serviços com um contrato duplex. Para obter um exemplo de trabalho, consulte o Exemplo duplex.

Para criar um contrato duplex

1. Crie a interface que compõe o lado do servidor do contrato duplex.

2. Aplique a ServiceContractAttribute classe à interface.

   [ServiceContract(Namespace = "http://Microsoft.ServiceModel.Samples", SessionMode=SessionMode.Required,
                    CallbackContract=typeof(ICalculatorDuplexCallback))]
   public interface ICalculatorDuplex
   {
       [OperationContract(IsOneWay=true)]
       void Clear();
       [OperationContract(IsOneWay = true)]
       void AddTo(double n);
       [OperationContract(IsOneWay = true)]
       void SubtractFrom(double n);
       [OperationContract(IsOneWay = true)]
       void MultiplyBy(double n);
       [OperationContract(IsOneWay = true)]
       void DivideBy(double n);
   }
   

   <ServiceContract(Namespace:="http://Microsoft.ServiceModel.Samples", SessionMode:=SessionMode.Required, _
                   CallbackContract:=GetType(ICalculatorDuplexCallback))> _
   Public Interface ICalculatorDuplex
   
       <OperationContract(IsOneWay:=True)> _
       Sub Clear()
       <OperationContract(IsOneWay:=True)> _
       Sub AddTo(ByVal n As Double)
       <OperationContract(IsOneWay:=True)> _
       Sub SubtractFrom(ByVal n As Double)
       <OperationContract(IsOneWay:=True)> _
       Sub MultiplyBy(ByVal n As Double)
       <OperationContract(IsOneWay:=True)> _
       Sub DivideBy(ByVal n As Double)
   End Interface
   
   

3. Declare as assinaturas do método na interface.

4. Aplique a OperationContractAttribute classe a cada assinatura de método que deve fazer parte do contrato público.

5. Crie a interface de retorno de chamada que define o conjunto de operações que o serviço pode invocar no cliente.

   public interface ICalculatorDuplexCallback
   {
       [OperationContract(IsOneWay = true)]
       void Equals(double result);
       [OperationContract(IsOneWay = true)]
       void Equation(string eqn);
   }
   

   Public Interface ICalculatorDuplexCallback
       <OperationContract(IsOneWay:=True)> _
       Sub Equals(ByVal result As Double)
       <OperationContract(IsOneWay:=True)> _
       Sub Equation(ByVal eqn As String)
   end interface
   
   

6. Declare as assinaturas do método na interface de retorno de chamada.

7. Aplique a OperationContractAttribute classe a cada assinatura de método que deve fazer parte do contrato público.

8. Vincule as duas interfaces em um contrato duplex definindo a CallbackContract propriedade na interface primária para o tipo da interface de retorno de chamada.

Para chamar métodos no cliente

1. Na implementação do contrato primário pelo serviço, declare uma variável para a interface de retorno de chamada.

2. Defina a variável como a referência de objeto retornada pelo GetCallbackChannel método da OperationContext classe.

   ICalculatorDuplexCallback callback = null;
   

   Dim callback As ICalculatorDuplexCallback
   

   callback = OperationContext.Current.GetCallbackChannel<ICalculatorDuplexCallback>();
   

   callback = OperationContext.Current.GetCallbackChannel(Of ICalculatorDuplexCallback)()
   

3. Chame os métodos definidos pela interface de retorno de chamada.

Exemplo

O exemplo de código a seguir demonstra comunicação duplex. O contrato de serviço contém operações de serviço para avançar e retroceder. O contrato do cliente contém uma operação de serviço para comunicar a sua posição.

// Define a duplex service contract.
// A duplex contract consists of two interfaces.
// The primary interface is used to send messages from client to service.
// The callback interface is used to send messages from service back to client.
// ICalculatorDuplex allows one to perform multiple operations on a running result.
// The result is sent back after each operation on the ICalculatorCallback interface.
[ServiceContract(Namespace = "http://Microsoft.ServiceModel.Samples", SessionMode=SessionMode.Required,
                 CallbackContract=typeof(ICalculatorDuplexCallback))]
public interface ICalculatorDuplex
{
    [OperationContract(IsOneWay=true)]
    void Clear();
    [OperationContract(IsOneWay = true)]
    void AddTo(double n);
    [OperationContract(IsOneWay = true)]
    void SubtractFrom(double n);
    [OperationContract(IsOneWay = true)]
    void MultiplyBy(double n);
    [OperationContract(IsOneWay = true)]
    void DivideBy(double n);
}
// The callback interface is used to send messages from service back to client.
// The Equals operation will return the current result after each operation.
// The Equation operation will return the complete equation after Clear() is called.
public interface ICalculatorDuplexCallback
{
    [OperationContract(IsOneWay = true)]
    void Equals(double result);
    [OperationContract(IsOneWay = true)]
    void Equation(string eqn);
}
// Service class which implements a duplex service contract.
// Use an InstanceContextMode of PerSession to store the result
// An instance of the service will be bound to each duplex session
[ServiceBehavior(InstanceContextMode = InstanceContextMode.PerSession)]
public class CalculatorService : ICalculatorDuplex
{
    double result;
    string equation;
    ICalculatorDuplexCallback callback = null;

    public CalculatorService()
    {
        result = 0.0D;
        equation = result.ToString();
        callback = OperationContext.Current.GetCallbackChannel<ICalculatorDuplexCallback>();
    }

    public void Clear()
    {
        callback.Equation(equation + " = " + result.ToString());
        result = 0.0D;
        equation = result.ToString();
    }

    public void AddTo(double n)
    {
        result += n;
        equation += " + " + n.ToString();
        callback.Equals(result);
    }

    public void SubtractFrom(double n)
    {
        result -= n;
        equation += " - " + n.ToString();
        callback.Equals(result);
    }

    public void MultiplyBy(double n)
    {
        result *= n;
        equation += " * " + n.ToString();
        callback.Equals(result);
    }

    public void DivideBy(double n)
    {
        result /= n;
        equation += " / " + n.ToString();
        callback.Equals(result);
    }
}

' Define a duplex service contract.
' A duplex contract consists of two interfaces.
' The primary interface is used to send messages from client to service.
' The callback interface is used to send messages from service back to client.
' ICalculatorDuplex allows one to perform multiple operations on a running result.
' The result is sent back after each operation on the ICalculatorCallback interface.
<ServiceContract(Namespace:="http://Microsoft.ServiceModel.Samples", SessionMode:=SessionMode.Required, _
                CallbackContract:=GetType(ICalculatorDuplexCallback))> _
Public Interface ICalculatorDuplex

    <OperationContract(IsOneWay:=True)> _
    Sub Clear()
    <OperationContract(IsOneWay:=True)> _
    Sub AddTo(ByVal n As Double)
    <OperationContract(IsOneWay:=True)> _
    Sub SubtractFrom(ByVal n As Double)
    <OperationContract(IsOneWay:=True)> _
    Sub MultiplyBy(ByVal n As Double)
    <OperationContract(IsOneWay:=True)> _
    Sub DivideBy(ByVal n As Double)
End Interface

' The callback interface is used to send messages from service back to client.
' The Equals operation will return the current result after each operation.
' The Equation operation will return the complete equation after Clear() is called.
Public Interface ICalculatorDuplexCallback
    <OperationContract(IsOneWay:=True)> _
    Sub Equals(ByVal result As Double)
    <OperationContract(IsOneWay:=True)> _
    Sub Equation(ByVal eqn As String)
end interface

' Service class which implements a duplex service contract.
' Use an InstanceContextMode of PerSession to store the result
' An instance of the service will be bound to each duplex session
<ServiceBehavior(InstanceContextMode:=InstanceContextMode.PerSession)> _
Public Class CalculatorService
    Implements ICalculatorDuplex
    Dim result As Double
    Dim equation As String
    Dim callback As ICalculatorDuplexCallback

    Public Sub New()
        result = 0D
        equation = result.ToString()
        callback = OperationContext.Current.GetCallbackChannel(Of ICalculatorDuplexCallback)()

    End Sub
    Public Sub AddTo(ByVal n As Double) Implements ICalculatorDuplex.AddTo
        result += n
        equation += " + " + n.ToString()
        callback.Equals(result)
    End Sub

    Public Sub Clear() Implements ICalculatorDuplex.Clear
        callback.Equation(equation + " = " + result.ToString())
        result = 0D
        equation = result.ToString()
    End Sub

    Public Sub DivideBy(ByVal n As Double) Implements ICalculatorDuplex.DivideBy
        result /= n
        equation += " / " + n.ToString()
        callback.Equals(result)
    End Sub

    Public Sub MultiplyBy(ByVal n As Double) Implements ICalculatorDuplex.MultiplyBy
        result *= n
        equation += " * " + n.ToString()
        callback.Equals(result)
    End Sub

    Public Sub SubtractFrom(ByVal n As Double) Implements ICalculatorDuplex.SubtractFrom
        result -= n
        equation += " - " + n.ToString()
        callback.Equals(result)
    End Sub
End Class

• A aplicação dos ServiceContractAttribute atributos e OperationContractAttribute permite a geração automática de definições de contrato de serviço na WSDL (Web Services Description Language).

• Use a ServiceModel Metadata Utility Tool (Svcutil.exe) para recuperar o documento WSDL e o código e a configuração (opcionais) de um cliente.

• Os pontos de extremidade que expõem serviços duplex devem ser protegidos. Quando um serviço recebe uma mensagem duplex, ele examina o ReplyTo nessa mensagem de entrada para determinar para onde enviar a resposta. Se o canal não estiver protegido, um cliente não confiável pode enviar uma mensagem maliciosa com o ReplyTo de uma máquina de destino, levando a uma negação de serviço da máquina de destino. Com mensagens regulares de solicitação-resposta, isso não é um problema, porque o ReplyTo é ignorado e a resposta é enviada no canal em que a mensagem original entrou.

Consulte também

• ServiceContractAttribute
• OperationContractAttribute
• Como: Acessar serviços com um contrato duplex
• Duplex
• Projetando e implementando serviços
• Como: Definir um contrato de serviço
• Sessão