Teilen über

Vorgehensweise: Asynchrones Aufrufen von Vorgängen mithilfe einer Kanalfactory

In diesem Thema wird erläutert, wie ein Client asynchron auf einen Dienstvorgang zugreifen kann, wenn eine ChannelFactory<TChannel>clientbasierte Clientanwendung verwendet wird. (Wenn Sie ein System.ServiceModel.ClientBase<TChannel> Objekt verwenden, um einen Dienst aufzurufen, können Sie das ereignisgesteuerte asynchrone Aufrufmodell verwenden. Weitere Informationen finden Sie unter Vorgehensweise: Servicevorgänge asynchron aufrufen. Weitere Informationen zum ereignisbasierten asynchronen Aufrufmodell finden Sie unter Ereignisbasiertes asynchrones Muster (EAP).)

Der Dienst in diesem Thema implementiert die ICalculator Schnittstelle. Der Client kann die Vorgänge auf dieser Schnittstelle asynchron aufrufen. Dies bedeutet, dass Vorgänge wie Add in zwei Methoden aufgeteilt werden, BeginAdd und EndAdddas erste, von dem der Aufruf initiiert wird, und letzteres das Ergebnis abruft, wenn der Vorgang abgeschlossen ist. Ein Beispiel zur asynchronen Implementierung eines Vorgangs in einem Dienst finden Sie unter How to: Implement an Asynchronous Service Operation. Ausführliche Informationen zu synchronen und asynchronen Vorgängen finden Sie unter Synchrone und asynchrone Vorgänge.

Procedure

So rufen Sie WCF-Dienstvorgänge asynchron auf

  1. Führen Sie das ServiceModel Metadata Utility Tool (Svcutil.exe) mit der /async Option aus, wie im folgenden Befehl gezeigt.

    svcutil /n:http://Microsoft.ServiceModel.Samples,Microsoft.ServiceModel.Samples http://localhost:8000/servicemodelsamples/service/mex /a

    Dadurch wird eine asynchrone Clientversion des Dienstvertrags für den Vorgang generiert.

  2. Erstellen Sie eine Rückruffunktion, die aufgerufen werden soll, wenn der asynchrone Vorgang abgeschlossen ist, wie im folgenden Beispielcode gezeigt.

    static void AddCallback(IAsyncResult ar)
{
    double result = ((CalculatorClient)ar.AsyncState).EndAdd(ar);
    Console.WriteLine($"Add Result: {result}");
}

    Private Shared Sub AddCallback(ByVal ar As IAsyncResult)
    Dim result = (CType(ar.AsyncState, CalculatorClient)).EndAdd(ar)
    Console.WriteLine("Add Result: {0}", result)
End Sub

  3. Um asynchron auf einen Dienstvorgang zuzugreifen, erstellen Sie den Client und rufen Sie den Begin[Operation] (z.B. BeginAdd) auf, und geben Sie eine Rückruffunktion an, wie im folgenden Beispielcode gezeigt wird.

    ChannelFactory<ICalculatorChannel> factory = new ChannelFactory<ICalculatorChannel>();
ICalculatorChannel channelClient = factory.CreateChannel();

// BeginAdd
double value1 = 100.00D;
double value2 = 15.99D;

IAsyncResult arAdd = channelClient.BeginAdd(value1, value2, AddCallback, channelClient);
Console.WriteLine($"Add({value1},{value2})");

    Dim factory As New ChannelFactory(Of ICalculatorChannel)()
Dim channelClient As ICalculatorChannel = factory.CreateChannel()

' BeginAdd
Dim value1 = 100.0R
Dim value2 = 15.99R

Dim arAdd As IAsyncResult = channelClient.BeginAdd(value1, value2, AddressOf AddCallback, channelClient)
Console.WriteLine("Add({0},{1})", value1, value2)

    Wenn die Rückruffunktion ausgeführt wird, ruft der Client End<operation> (z. B. EndAdd) auf, um das Ergebnis abzurufen.

Example

Der Dienst, der mit dem Clientcode verwendet wird, der in der vorherigen Prozedur verwendet wird, implementiert die ICalculator Schnittstelle wie im folgenden Code dargestellt. Auf der Dienstseite werden die Add und Subtract Operationen des Vertrags von der Windows Communication Foundation (WCF)-Laufzeit synchron aufgerufen, obwohl die vorherigen Clientschritte asynchron auf dem Client aufgerufen werden. Die Multiply Und Divide Vorgänge werden verwendet, um den Dienst asynchron auf der Dienstseite aufzurufen, auch wenn der Client sie synchron aufruft. In diesem Beispiel wird die AsyncPattern-Eigenschaft auf true gesetzt. Diese Eigenschaftseinstellung weist die Laufzeit in Kombination mit der Implementierung des asynchronen .NET Framework-Musters an, den Vorgang asynchron aufzurufen.

[ServiceContract(Namespace = "http://Microsoft.ServiceModel.Samples")]
public interface ICalculator
{
    [OperationContract]
    double Add(double n1, double n2);

    [OperationContract]
    double Subtract(double n1, double n2);

    //Multiply involves some file I/O so we'll make it Async.
    [OperationContract(AsyncPattern = true)]
    IAsyncResult BeginMultiply(double n1, double n2, AsyncCallback callback, object state);
    double EndMultiply(IAsyncResult ar);

    //Divide involves some file I/O so we'll make it Async.
    [OperationContract(AsyncPattern = true)]
    IAsyncResult BeginDivide(double n1, double n2, AsyncCallback callback, object state);
    double EndDivide(IAsyncResult ar);
}

<ServiceContract(Namespace:="http://Microsoft.ServiceModel.Samples")> _
Public Interface ICalculator
    <OperationContract> _
    Function Add(ByVal n1 As Double, ByVal n2 As Double) As Double

    <OperationContract> _
    Function Subtract(ByVal n1 As Double, ByVal n2 As Double) As Double

    'Multiply involves some file I/O so we'll make it Async.
    <OperationContract(AsyncPattern:=True)> _
    Function BeginMultiply(ByVal n1 As Double, ByVal n2 As Double, ByVal callback As AsyncCallback, ByVal state As Object) As IAsyncResult
    Function EndMultiply(ByVal ar As IAsyncResult) As Double

    'Divide involves some file I/O so we'll make it Async.
    <OperationContract(AsyncPattern:=True)> _
    Function BeginDivide(ByVal n1 As Double, ByVal n2 As Double, ByVal callback As AsyncCallback, ByVal state As Object) As IAsyncResult
    Function EndDivide(ByVal ar As IAsyncResult) As Double
End Interface
  • Last updated on