Procedure: Aanroepen van bewerkingen asynchroon met behulp van een kanaalfactory

In dit onderwerp wordt beschreven hoe een client asynchroon toegang heeft tot een servicebewerking wanneer u een clienttoepassing op basis van een ChannelFactory<TChannel>client gebruikt. (Wanneer u een System.ServiceModel.ClientBase<TChannel> object gebruikt om een service aan te roepen, kunt u het gebeurtenisgestuurde asynchrone aanroepende model gebruiken. Zie Procedure voor meer informatie : Servicebewerkingen asynchroon aanroepen. Zie Asynchroon Asynchroon patroon (EAP) voor meer informatie over het op gebeurtenissen gebaseerde asynchrone aanroepende model.

De service in dit onderwerp implementeert de ICalculator interface. De client kan de bewerkingen op deze interface asynchroon aanroepen, wat betekent dat bewerkingen zoals Add worden gesplitst in twee methoden enEndAddBeginAdd, waarvan de eerste de aanroep initieert en waarvan de laatste het resultaat ophaalt wanneer de bewerking is voltooid. Zie Hoe u een Asynchrone servicebewerking implementeert voor een voorbeeld van het asynchroon implementeren van een bewerking in een service. Zie Synchrone en Asynchrone bewerkingen voor meer informatie over synchrone en asynchrone bewerkingen.

Procedure

WCF-servicebewerkingen asynchroon aanroepen

1. Voer het hulpprogramma ServiceModel Metadata Utility (Svcutil.exe) uit met de /async optie, zoals wordt weergegeven in de volgende opdracht.

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

   Hiermee wordt een asynchrone clientversie van het servicecontract voor de bewerking gegenereerd.

2. Maak een callback-functie die moet worden aangeroepen wanneer de asynchrone bewerking is voltooid, zoals wordt weergegeven in de volgende voorbeeldcode.

   static void AddCallback(IAsyncResult ar)
   {
       double result = ((CalculatorClient)ar.AsyncState).EndAdd(ar);
       Console.WriteLine("Add Result: {0}", 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. Als u asynchroon toegang wilt krijgen tot een servicebewerking, maakt u de client en roept u de Begin[Operation] (bijvoorbeeld BeginAdd) aan en geeft u een callback-functie op, zoals wordt weergegeven in de volgende voorbeeldcode.

   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({0},{1})", 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)
   

   Wanneer de callback-functie wordt uitgevoerd, roept End<operation> de client aan (bijvoorbeeld EndAdd) om het resultaat op te halen.

Opmerking

De service die wordt gebruikt met de clientcode die in de voorgaande procedure wordt gebruikt, implementeert de ICalculator interface, zoals wordt weergegeven in de volgende code. Aan de servicezijde worden de Add en Subtract bewerkingen van het contract synchroon aangeroepen door de WCF-uitvoeringstijd (Windows Communication Foundation), ook al worden de voorgaande clientstappen asynchroon aangeroepen op de client. De Multiply en Divide bewerkingen worden gebruikt om de service asynchroon aan te roepen aan de servicezijde, zelfs als de client deze synchroon aanroept. In dit voorbeeld wordt de AsyncPattern eigenschap ingesteld op true. Deze eigenschapsinstelling, in combinatie met de implementatie van het asynchrone .NET Framework-patroon, vertelt de runtime om de bewerking asynchroon aan te roepen.

[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