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 os clientes e os servidores se comuniquem entre si independentemente, de modo que qualquer um possa iniciar chamadas para o outro. O contrato duplex é um dos três padrões de mensagens disponíveis para os serviços WCF (Windows Communication Foundation). Os outros padrões de duas mensagens são unidirecionais e solicitação-resposta. Um contrato duplex consiste de dois contratos unidirecionais entre o cliente e o servidor e não exige que as chamadas de método sejam correlacionadas. Use esse tipo de contrato quando o serviço tiver que consultar o cliente para obter mais informações ou explicitamente gerar eventos no cliente. Para obter mais informações sobre como criar um aplicativo cliente para um contrato duplex, confira Como acessar serviços com um contrato duplex. Para ver um exemplo prático, confira o exemplo de Duplex.

Para criar um contrato duplex

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

2. Aplique a classe ServiceContractAttribute à 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 de método na interface.

4. Aplique a classe OperationContractAttribute a cada assinatura de método que deve ser 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 chamar 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 de método na interface de retorno de chamada.

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

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

Para chamar métodos no cliente

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

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

   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 a comunicação duplex. O contrato do serviço contém operações de serviço para avançar e voltar. O contrato do cliente contém uma operação de serviço para relatar 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

• Aplicar os atributos ServiceContractAttribute e OperationContractAttribute permite a geração automática de definições do contrato de serviço na linguagem WSDL.

• Use a Ferramenta de Utilitário de Metadados do ServiceModel (Svcutil.exe) para recuperar o documento WSDL e o código e a configuração (opcional) para um cliente.

• Os pontos de extremidade que expõem serviços duplex devem ser protegidos. Quando um serviço recebe uma mensagem duplex, ele olha o ReplyTo na mensagem de entrada para determinar para onde enviar a resposta. Se o canal não estiver protegido, um cliente não confiável poderá enviar uma mensagem mal-intencionada com um ReplyTo do computador de destino, resultando em uma negação de serviço do computador de destino. Com mensagens normais de solicitação-resposta, isso não é um problema, pois o ReplyTo é ignorado e a resposta é enviada no canal no qual a mensagem original chegou.

Confira também

• ServiceContractAttribute
• OperationContractAttribute
• Como: acessar serviços com um contrato duplex
• Duplex
• Serviços de implantação e projeção
• Como definir um contrato de serviço
• Sessão