Útmutató: Az operations aszinkron meghívása Channel Factory használatával

Ez a témakör azt ismerteti, hogyan férhet hozzá az ügyfél aszinkron módon egy szolgáltatásművelethez egy ChannelFactory<TChannel>-based ügyfélalkalmazás használatakor. (Ha objektumot System.ServiceModel.ClientBase<TChannel> használ egy szolgáltatás meghívásához, használhatja az eseményvezérelt aszinkron hívásmodellt. További információ : A szolgáltatásműveletek aszinkron meghívása. Az eseményalapú aszinkron hívásmodellről további információt az eseményalapú aszinkron minta (EAP) című témakörben talál.)

A jelen témakör szolgáltatása implementálja a ICalculator felületet. Az ügyfél aszinkron módon hívhatja meg a műveleteket ezen az interfészen, ami azt jelenti, hogy a hasonló Add műveletek két metódusra vannak felosztva, és EndAddaz előbbi kezdeményezi a hívást, BeginAdd az utóbbi pedig a művelet befejezésekor kéri le az eredményt. Ha például bemutatja, hogyan implementálhat egy műveletet aszinkron módon egy szolgáltatásban, olvassa el a How to: Implement an Asynchronous Service Operation (Aszinkron szolgáltatásművelet implementálása) című témakört. A szinkron és aszinkron műveletekről további információt a Szinkron és az Aszinkron műveletek című témakörben talál.

Eljárás

WCF szolgáltatásműveletek aszinkron meghívása

1. Futtassa a ServiceModel Metadata Segédprogram eszközt (Svcutil.exe) az /async alábbi parancsban látható módon.

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

   Ez létrehozza a művelet szolgáltatási szerződésének aszinkron ügyfélverzióját.

2. Hozzon létre egy visszahívási függvényt, amelyet az aszinkron művelet befejezésekor kell meghívni, ahogyan az az alábbi mintakódban látható.

   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. Ha aszinkron módon szeretne hozzáférni egy szolgáltatásművelethez, hozza létre az ügyfelet, és hívja meg (például BeginAdd) és Begin[Operation] adjon meg egy visszahívási függvényt az alábbi mintakódban látható módon.

   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)
   

   A visszahívási függvény végrehajtásakor az ügyfél meghívja End<operation> (például EndAdd) az eredményt.

Példa

Az előző eljárásban használt ügyfélkóddal használt szolgáltatás implementálja a felületet az ICalculator alábbi kódban látható módon. A szolgáltatásoldalon a Add szerződés és Subtract a szerződés műveleteit a Windows Communication Foundation (WCF) futásideje szinkron módon hívja meg, annak ellenére, hogy az előző ügyféllépéseket aszinkron módon hívja meg az ügyfél. Az Multiply és Divide a műveletek a szolgáltatás oldalán aszinkron módon meghívják a szolgáltatást, még akkor is, ha az ügyfél szinkron módon hívja meg őket. Ez a példa a tulajdonságot a AsyncPattern következőre trueállítja: . Ez a tulajdonságbeállítás a .NET-keretrendszer aszinkron minta implementálásával együtt arra utasítja a futtatókörnyezetet, hogy aszinkron módon hívja meg a műveletet.

[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