Duplex

O exemplo Duplex demonstra como definir e implementar um contrato duplex. A comunicação duplex ocorre quando um cliente estabelece uma sessão com um serviço e dá ao serviço um canal no qual o serviço pode enviar mensagens de volta para o cliente. Este exemplo é baseado em Introdução. Um contrato duplex é definido como um par de interfaces — uma interface primária do cliente para o serviço e uma interface de retorno de chamada do serviço para o cliente. Neste exemplo, a ICalculatorDuplex interface permite que o cliente execute operações matemáticas, calculando o resultado ao longo de uma sessão. O serviço retorna resultados na ICalculatorDuplexCallback interface. Um contrato duplex requer uma sessão, porque um contexto deve ser estabelecido para correlacionar o conjunto de mensagens que estão sendo enviadas entre o cliente e o serviço.

Neste exemplo, o cliente é um aplicativo de console (.exe) e o serviço é hospedado pelo IIS (Serviços de Informações da Internet). O contrato duplex é definido da seguinte forma:

[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);
}

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

A CalculatorService classe implementa a interface primária ICalculatorDuplex . O serviço usa o PerSession modo de instância para manter o resultado de cada sessão. Uma propriedade privada chamada Callback é usada para acessar o canal de retorno de chamada para o cliente. O serviço utiliza o callback para enviar mensagens de volta ao cliente através da interface de callback.

[ServiceBehavior(InstanceContextMode = InstanceContextMode.PerSession)]
public class CalculatorService : ICalculatorDuplex
{
    double result = 0.0D;
    string equation;

    public CalculatorService()
    {
        equation = result.ToString();
    }

    public void Clear()
    {
        Callback.Equation($"{equation} = {result}");
        equation = result.ToString();
    }

    public void AddTo(double n)
    {
        result += n;
        equation += $" + {n}";
        Callback.Result(result);
    }

    //...

    ICalculatorDuplexCallback Callback
    {
        get
        {
            return OperationContext.Current.GetCallbackChannel<ICalculatorDuplexCallback>();
        }
    }
}

O cliente deve fornecer uma classe que implemente a interface de retorno de chamada do contrato duplex, para receber mensagens do serviço. No exemplo, uma CallbackHandler classe é definida para implementar a ICalculatorDuplexCallback interface.

public class CallbackHandler : ICalculatorDuplexCallback
{
   public void Result(double result)
   {
      Console.WriteLine("Result({0})", result);
   }

   public void Equation(string equation)
   {
      Console.WriteLine("Equation({0}", equation);
   }
}

O proxy que é gerado para um contrato duplex requer um InstanceContext a ser fornecido no ato da construção. Isso InstanceContext é usado como o local para um objeto que implementa a interface de retorno de chamada e processa mensagens enviadas de volta pelo serviço. Um InstanceContext é construído com uma instância da CallbackHandler classe. Este objeto processa mensagens enviadas do serviço para o cliente na interface de callback.

// Construct InstanceContext to handle messages on callback interface.
InstanceContext instanceContext = new InstanceContext(new CallbackHandler());

// Create a client.
CalculatorDuplexClient client = new CalculatorDuplexClient(instanceContext);

Console.WriteLine("Press <ENTER> to terminate client once the output is displayed.");
Console.WriteLine();

// Call the AddTo service operation.
double value = 100.00D;
client.AddTo(value);

// Call the SubtractFrom service operation.
value = 50.00D;
client.SubtractFrom(value);

// Call the MultiplyBy service operation.
value = 17.65D;
client.MultiplyBy(value);

// Call the DivideBy service operation.
value = 2.00D;
client.DivideBy(value);

// Complete equation.
client.Clear();

Console.ReadLine();

//Closing the client gracefully closes the connection and cleans up resources.
client.Close();

A configuração foi modificada para fornecer uma ligação que suporta comunicação de sessão e comunicação duplex. O wsDualHttpBinding suporta comunicação de sessão e permite comunicação duplex fornecendo conexões HTTP duplas, uma para cada direção. No serviço, a única diferença na configuração é a ligação que é usada. No cliente, você deve configurar um endereço que o servidor pode usar para se conectar ao cliente, conforme mostrado na configuração de exemplo a seguir.

<client>
  <endpoint name=""
            address="http://localhost/servicemodelsamples/service.svc"
            binding="wsDualHttpBinding"
            bindingConfiguration="DuplexBinding"
            contract="Microsoft.ServiceModel.Samples.ICalculatorDuplex" />
</client>

<bindings>
  <!-- Configure a binding that support duplex communication. -->
  <wsDualHttpBinding>
    <binding name="DuplexBinding"
             clientBaseAddress="http://localhost:8000/myClient/">
    </binding>
  </wsDualHttpBinding>
</bindings>

Ao executar o exemplo, você vê as mensagens que são retornadas ao cliente na interface de retorno de chamada que é enviada do serviço. Cada resultado intermediário é exibido, seguido por toda a equação após a conclusão de todas as operações. Pressione ENTER para desligar o cliente.

Para configurar, compilar e executar o exemplo

1. Verifique se você executou o procedimento de instalação do One-Time para os exemplos do Windows Communication Foundation.

2. Para criar a edição C#, C++ ou Visual Basic .NET da solução, siga as instruções em Criando os exemplos do Windows Communication Foundation.

3. Para executar o exemplo em uma configuração de máquina única ou cruzada, siga as instruções em Executando os exemplos do Windows Communication Foundation.

   Importante

   Ao executar o cliente em uma configuração entre máquinas, certifique-se de substituir "localhost" no address atributo do ponto de< extremidade> do elemento client<> e no clientBaseAddress atributo do elemento binding<> do <elemento wsDualHttpBinding> pelo nome da máquina apropriada, conforme mostrado a seguir:

   <client>
       <endpoint name = ""
       address="http://service_machine_name/servicemodelsamples/service.svc"
       ... />
   </client>
   ...
   <wsDualHttpBinding>
       <binding name="DuplexBinding" clientBaseAddress="http://client_machine_name:8000/myClient/">
       </binding>
   </wsDualHttpBinding>