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.
Nota
O procedimento de configuração e as instruções de compilação para este exemplo estão localizados no final deste tópico.
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 usa o retorno de chamada para enviar mensagens de volta ao cliente através da interface de retorno de chamada.
[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);
}
}
A proxy que é gerada para um contrato duplex requer um InstanceContext a ser fornecido no momento da construção. Isso InstanceContext é usado como o site para um objeto que implementa a interface de retorno de chamada e lida com mensagens que são enviadas de volta do serviço. Um InstanceContext é construído com uma instância da CallbackHandler
classe. Este objeto lida com mensagens enviadas do serviço para o cliente na interface de retorno de chamada.
// 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
Certifique-se de ter executado o procedimento de instalação única para os exemplos do Windows Communication Foundation.
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.
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 noclientBaseAddress
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>