Duplex

Duplex-exemplet visar hur du definierar och implementerar ett duplex-kontrakt. Duplex-kommunikation sker när en klient upprättar en session med en tjänst och ger tjänsten en kanal där tjänsten kan skicka meddelanden tillbaka till klienten. Det här exemplet baseras på Komma igång. Ett duplexkontrakt definieras som ett par gränssnitt – ett primärt gränssnitt från klienten till tjänsten och ett motringningsgränssnitt från tjänsten till klienten. I det här exemplet ICalculatorDuplex gör gränssnittet att klienten kan utföra matematiska åtgärder och beräkna resultatet under en session. Tjänsten returnerar resultat i ICalculatorDuplexCallback gränssnittet. Ett duplex-kontrakt kräver en session, eftersom en kontext måste upprättas för att korrelera den uppsättning meddelanden som skickas mellan klienten och tjänsten.

Kommentar

Installationsproceduren och bygginstruktionerna för det här exemplet finns i slutet av det här avsnittet.

I det här exemplet är klienten ett konsolprogram (.exe) och tjänsten hanteras av Internet Information Services (IIS). Duplex-kontraktet definieras på följande sätt:

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

Klassen CalculatorService implementerar det primära ICalculatorDuplex gränssnittet. Tjänsten använder PerSession instansläget för att underhålla resultatet för varje session. En privat egenskap med namnet Callback används för att komma åt återanropskanalen till klienten. Tjänsten använder återanropet för att skicka tillbaka meddelanden till klienten via motringningsgränssnittet.

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

Klienten måste ange en klass som implementerar återanropsgränssnittet för duplex-kontraktet för att ta emot meddelanden från tjänsten. I exemplet definieras en CallbackHandler klass för att implementera ICalculatorDuplexCallback gränssnittet.

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

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

Proxyn som genereras för ett duplex-kontrakt kräver att en InstanceContext tillhandahålls vid konstruktionen. Detta InstanceContext används som plats för ett objekt som implementerar motringningsgränssnittet och hanterar meddelanden som skickas tillbaka från tjänsten. En InstanceContext konstrueras med en instans av CallbackHandler klassen. Det här objektet hanterar meddelanden som skickas från tjänsten till klienten i motringningsgränssnittet.

// 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();

Konfigurationen har ändrats för att tillhandahålla en bindning som stöder både sessionskommunikation och duplexkommunikation. Stöder wsDualHttpBinding sessionskommunikation och tillåter dubbelsidig kommunikation genom att tillhandahålla dubbla HTTP-anslutningar, en för varje riktning. På tjänsten är den enda skillnaden i konfiguration den bindning som används. På klienten måste du konfigurera en adress som servern kan använda för att ansluta till klienten enligt följande exempelkonfiguration.

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

När du kör exemplet visas de meddelanden som returneras till klienten i motringningsgränssnittet som skickas från tjänsten. Varje mellanliggande resultat visas, följt av hela ekvationen när alla åtgärder har slutförts. Tryck på RETUR för att stänga av klienten.

Så här konfigurerar du, skapar och kör exemplet

1. Kontrollera att du har utfört engångsinstallationsproceduren för Windows Communication Foundation-exempel.

2. Om du vill skapa C#,C++- eller Visual Basic .NET-versionen av lösningen följer du anvisningarna i Skapa Windows Communication Foundation-exempel.

3. Om du vill köra exemplet i en konfiguration med en eller flera datorer följer du anvisningarna i Köra Windows Communication Foundation-exempel.

   Viktigt!

   När du kör klienten i en konfiguration mellan datorer måste du ersätta "localhost" i både address -attributet< för klientelementets> slutpunkt><och clientBaseAddress attributet <för bindningselementet>< i wsDualHttpBinding-elementet> med namnet på lämplig dator, enligt följande:

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