Condividi tramite

Duplex

L'esempio Duplex illustra come definire e implementare un contratto duplex. La comunicazione duplex si verifica quando un client stabilisce una sessione con un servizio e fornisce al servizio un canale in cui il servizio può inviare messaggi al client. Questo esempio si basa sull'introduzione. Un contratto duplex è definito come una coppia di interfacce, ovvero un'interfaccia primaria dal client al servizio e un'interfaccia di callback dal servizio al client. In questo esempio, l'interfaccia ICalculatorDuplex consente al client di eseguire operazioni matematiche, calcolando il risultato in una sessione. Il servizio restituisce i risultati sull'interfaccia ICalculatorDuplexCallback . Poiché occorre definire un contesto per correlare il set di messaggi scambiati fra il client e il servizio, i contratti duplex richiedono una sessione.

Annotazioni

La procedura di installazione e le istruzioni di compilazione per questo esempio si trovano alla fine di questo argomento.

In questo esempio il client è un'applicazione console (.exe) e il servizio è ospitato da Internet Information Services (IIS). Il contratto duplex è definito come segue:

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

La CalculatorService classe implementa l'interfaccia primaria ICalculatorDuplex . Il servizio utilizza la modalità istanza PerSession per mantenere il risultato di ogni sessione. Una proprietà privata denominata Callback viene usata per accedere al canale di callback del client. Il servizio utilizza il callback per inviare messaggi al client attraverso l'interfaccia di 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>();
        }
    }
}

Il client deve fornire una classe che implementa l'interfaccia di callback del contratto duplex per la ricezione di messaggi dal servizio. Nell'esempio viene definita una CallbackHandler classe per implementare l'interfaccia ICalculatorDuplexCallback .

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

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

Il proxy generato per un contratto duplex richiede che venga fornito un InstanceContext al momento della costruzione. Viene InstanceContext usato come sito per un oggetto che implementa l'interfaccia di callback e gestisce i messaggi inviati indietro dal servizio. Un InstanceContext viene costruito con un'istanza della classe CallbackHandler. Questo oggetto gestisce i messaggi inviati dal servizio al client nell'interfaccia di 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();

La configurazione è stata modificata per fornire un'associazione che supporta sia la comunicazione di sessione che la comunicazione duplex. wsDualHttpBinding supporta la comunicazione di sessione e consente la comunicazione duplex fornendo connessioni HTTP doppie, una per ogni direzione. Nel servizio, l'unica differenza nella configurazione è l'associazione usata. Nel client è necessario configurare un indirizzo che il server può usare per connettersi al client, come illustrato nella configurazione di esempio seguente.

<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>

Quando si esegue l'esempio, vengono visualizzati i messaggi restituiti al client nell'interfaccia di callback inviata dal servizio. Ogni risultato intermedio viene visualizzato, seguito dall'intera equazione al completamento di tutte le operazioni. Premere INVIO per arrestare il client.

Per configurare, compilare ed eseguire l'esempio

  1. Assicurati di aver eseguito la procedura di installazione di One-Time per gli esempi di Windows Communication Foundation.

  2. Per compilare l'edizione C#, C++o Visual Basic .NET della soluzione, seguire le istruzioni in Compilazione degli esempi di Windows Communication Foundation.

  3. Per eseguire l'esempio in una configurazione con computer singolo o incrociato, seguire le istruzioni riportate in Esecuzione degli esempi di Windows Communication Foundation.

    Importante

    Quando si esegue il client in una configurazione tra computer, assicurarsi di sostituire "localhost" sia nell'attributo addressdell'endpoint< dell'elemento>< client> che nell'attributo clientBaseAddress dell'elemento <di associazione> dell'elemento <wsDualHttpBinding> con il nome del computer appropriato, come illustrato di seguito:

    <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>
  • Last updated on