Delen via

Procedure: Toegang krijgen tot services met een dubbelzijdig contract

  • Artikel

Een functie van Windows Communication Foundation (WCF) is de mogelijkheid om een service te maken die gebruikmaakt van een dubbelzijdig berichtenpatroon. Met dit patroon kan een service communiceren met de client via een callback. In dit onderwerp worden de stappen beschreven voor het maken van een WCF-client in een clientklasse waarmee de callback-interface wordt geïmplementeerd.

Een dubbele binding maakt het IP-adres van de client beschikbaar voor de service. De client moet beveiliging gebruiken om ervoor te zorgen dat deze alleen verbinding maakt met services die worden vertrouwd.

Zie De zelfstudie Aan de slag voor een zelfstudie over het maken van een eenvoudige WCF-service en -client.

Toegang krijgen tot een duplex-service

  1. Maak een service die twee interfaces bevat. De eerste interface is voor de service, de tweede is voor de callback. Zie Een duplex-contract maken voor meer informatie over het maken van een duplex-service.

  2. Voer de service uit.

  3. Gebruik het hulpprogramma Hulpprogramma voor metagegevens van ServiceModel (Svcutil.exe) om contracten (interfaces) voor de client te genereren. Zie Een client maken voor meer informatie over hoe u dit doet.

  4. Implementeer de callback-interface in de clientklasse, zoals wordt weergegeven in het volgende voorbeeld.

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

    Public Class CallbackHandler
Implements ICalculatorDuplexCallback
   Public Sub Result (ByVal result As Double)
      Console.WriteLine("Result ({0})", result)
   End Sub
    Public Sub Equation(ByVal equation As String)
        Console.WriteLine("Equation({0})", equation)
    End Sub
End Class

  5. Maak een exemplaar van de InstanceContext-klasse. De constructor vereist een exemplaar van de clientklasse.

    InstanceContext site = new InstanceContext(new CallbackHandler());

    Dim site As InstanceContext = New InstanceContext(new CallbackHandler())

  6. Maak een exemplaar van de WCF-client met behulp van de constructor waarvoor een InstanceContext object is vereist. De tweede parameter van de constructor is de naam van een eindpunt dat in het configuratiebestand is gevonden.

    CalculatorDuplexClient wcfClient = new CalculatorDuplexClient(site, "default");

    Dim wcfClient As New CalculatorDuplexClient(site, "default")

  7. Roep de methoden van de WCF-client aan zoals vereist.

Opmerking

In het volgende codevoorbeeld ziet u hoe u een clientklasse maakt die toegang heeft tot een duplex-contract.

using System;
using System.ServiceModel;
using System.ServiceModel.Channels;

// Define class that implements the callback interface of duplex
// contract.
public class CallbackHandler : ICalculatorDuplexCallback
{
  public void Result(double result)
  {
    Console.WriteLine("Result({0})", result);
  }
  public void Equation(string equation)
  {
    Console.WriteLine("Equation({0})", equation);
  }
}

public class Client
{
  public static void Main()
  {
    // Picks up configuration from the config file.

    CalculatorDuplexClient wcfClient
      = new CalculatorDuplexClient(new InstanceContext(new CallbackHandler()));
    try
    {
      // Call the AddTo service operation.
      double value = 100.00D;
      wcfClient.AddTo(value);

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

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

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

      // Complete equation.
      wcfClient.Clear();

      // Wait for callback messages to complete before
      // closing.
      System.Threading.Thread.Sleep(5000);

      // Close the WCF client.
      wcfClient.Close();
      Console.WriteLine("Done!");
    }
    catch (TimeoutException timeProblem)
    {
      Console.WriteLine("The service operation timed out. " + timeProblem.Message);
      wcfClient.Abort();
      Console.Read();
    }
    catch (CommunicationException commProblem)
    {
      Console.WriteLine("There was a communication problem. " + commProblem.Message);
      wcfClient.Abort();
      Console.Read();
    }
  }
}

Imports System.ServiceModel

Namespace Microsoft.ServiceModel.Samples

    ' The service contract is defined in generatedClient.vb, generated from the service by the svcutil tool.

    ' Define class which implements callback interface of duplex contract
    Public Class CallbackHandler
        Implements ICalculatorDuplexCallback

        Public Sub Result(ByVal result As Double) Implements ICalculatorDuplexCallback.Result
            Console.WriteLine("Result({0})", result)
        End Sub

        Public Sub Equation(ByVal eqn As String) Implements ICalculatorDuplexCallback.Equation
            Console.WriteLine("Equation({0})", eqn)
        End Sub
    End Class

    Class Client
        Public Shared Sub Main()

            ' Construct InstanceContext to handle messages on callback interface
            Dim instanceContext As New InstanceContext(New CallbackHandler())

            ' Create a client
            Dim wcfClient As New CalculatorDuplexClient(instanceContext)
            Console.WriteLine("Press <ENTER> to terminate client once the output is displayed.")
            Console.WriteLine()

            Try
                ' Call the AddTo service operation.
                Dim value As Double = 100
                wcfClient.AddTo(value)

                ' Call the SubtractFrom service operation.
                value = 50
                wcfClient.SubtractFrom(value)

                ' Call the MultiplyBy service operation.
                value = 17.65
                wcfClient.MultiplyBy(value)

                ' Call the DivideBy service operation.
                value = 2
                wcfClient.DivideBy(value)

                ' Complete equation
                wcfClient.Clear()

                Console.ReadLine()

                'Closing the client gracefully closes the connection and cleans up resources
                wcfClient.Close()

            Catch timeout As TimeoutException
                Console.WriteLine(timeout.Message)
                wcfClient.Abort()
            Catch commException As CommunicationException
                Console.WriteLine(commException.Message)
                wcfClient.Abort()
            End Try
        End Sub

    End Class

End Namespace

Zie ook