AsyncResult Classe

Définition

Encapsule les résultats d'une opération asynchrone sur un délégué.Encapsulates the results of an asynchronous operation on a delegate.

public ref class AsyncResult : IAsyncResult, System::Runtime::Remoting::Messaging::IMessageSink
[System.Runtime.InteropServices.ComVisible(true)]
public class AsyncResult : IAsyncResult, System.Runtime.Remoting.Messaging.IMessageSink
type AsyncResult = class
    interface IAsyncResult
    interface IMessageSink
Public Class AsyncResult
Implements IAsyncResult, IMessageSink
Héritage
AsyncResult
Attributs
Implémente

Exemples

L’exemple suivant montre comment utiliser la AsyncWaitHandle propriété pour obtenir un WaitHandleet comment attendre un appel asynchrone sur un délégué.The following example demonstrates how to use the AsyncWaitHandle property to get a WaitHandle, and how to wait for an asynchronous call on a delegate. Le WaitHandle est signalé quand l’appel asynchrone se termine et vous pouvez l’attendre en appelant la méthode WaitOne .The WaitHandle is signaled when the asynchronous call completes, and you can wait for it by calling the WaitOne method.

L’exemple se compose de deux classes, la classe qui contient la méthode qui est appelée de façon asynchrone et la classe qui contient Main la méthode qui effectue l’appel.The example consists of two classes, the class that contains the method which is called asynchronously, and the class that contains the Main method that makes the call.

Pour plus d’informations et pour obtenir d’autres exemples d’appel de méthodes de façon asynchrone à l’aide de délégués, consultez appel de méthodes synchrones de façon asynchrone.For more information and more examples of calling methods asynchronously by using delegates, see Calling Synchronous Methods Asynchronously.

using namespace System;
using namespace System::Threading;
using namespace System::Runtime::InteropServices; 

namespace Examples {
namespace AdvancedProgramming {
namespace AsynchronousOperations
{
    public ref class AsyncDemo 
    {
    public:
        // The method to be executed asynchronously.
        String^ TestMethod(int callDuration, [OutAttribute] int% threadId) 
        {
            Console::WriteLine("Test method begins.");
            Thread::Sleep(callDuration);
            threadId = Thread::CurrentThread->ManagedThreadId;
            return String::Format("My call time was {0}.", callDuration);
        }
    };

    // The delegate must have the same signature as the method
    // it will call asynchronously.
    public delegate String^ AsyncMethodCaller(int callDuration, [OutAttribute] int% threadId);
}}}
using System;
using System.Threading; 

namespace Examples.AdvancedProgramming.AsynchronousOperations
{
    public class AsyncDemo 
    {
        // The method to be executed asynchronously.
        public string TestMethod(int callDuration, out int threadId) 
        {
            Console.WriteLine("Test method begins.");
            Thread.Sleep(callDuration);
            threadId = Thread.CurrentThread.ManagedThreadId;
            return String.Format("My call time was {0}.", callDuration.ToString());
        }
    }
    // The delegate must have the same signature as the method
    // it will call asynchronously.
    public delegate string AsyncMethodCaller(int callDuration, out int threadId);
}
Imports System.Threading
Imports System.Runtime.InteropServices 

Namespace Examples.AdvancedProgramming.AsynchronousOperations
    Public Class AsyncDemo 
        ' The method to be executed asynchronously.
        Public Function TestMethod(ByVal callDuration As Integer, _
                <Out> ByRef threadId As Integer) As String
            Console.WriteLine("Test method begins.")
            Thread.Sleep(callDuration)
            threadId = Thread.CurrentThread.ManagedThreadId()
            return String.Format("My call time was {0}.", callDuration.ToString())
        End Function
    End Class

    ' The delegate must have the same signature as the method
    ' it will call asynchronously.
    Public Delegate Function AsyncMethodCaller(ByVal callDuration As Integer, _
        <Out> ByRef threadId As Integer) As String
End Namespace
#using <TestMethod.dll>

using namespace System;
using namespace System::Threading;
using namespace Examples::AdvancedProgramming::AsynchronousOperations;

void main() 
{
    // The asynchronous method puts the thread id here.
    int threadId;

    // Create an instance of the test class.
    AsyncDemo^ ad = gcnew AsyncDemo();

    // Create the delegate.
    AsyncMethodCaller^ caller = gcnew AsyncMethodCaller(ad, &AsyncDemo::TestMethod);
       
    // Initiate the asychronous call.
    IAsyncResult^ result = caller->BeginInvoke(3000, 
        threadId, nullptr, nullptr);

    Thread::Sleep(0);
    Console::WriteLine("Main thread {0} does some work.",
        Thread::CurrentThread->ManagedThreadId);

    // Wait for the WaitHandle to become signaled.
    result->AsyncWaitHandle->WaitOne();

    // Perform additional processing here.
    // Call EndInvoke to retrieve the results.
    String^ returnValue = caller->EndInvoke(threadId, result);

    // Close the wait handle.
    result->AsyncWaitHandle->Close();

    Console::WriteLine("The call executed on thread {0}, with return value \"{1}\".",
        threadId, returnValue);
}

/* This example produces output similar to the following:

Main thread 1 does some work.
Test method begins.
The call executed on thread 3, with return value "My call time was 3000.".
 */
using System;
using System.Threading;

namespace Examples.AdvancedProgramming.AsynchronousOperations
{
    public class AsyncMain 
    {
        static void Main() 
        {
            // The asynchronous method puts the thread id here.
            int threadId;

            // Create an instance of the test class.
            AsyncDemo ad = new AsyncDemo();

            // Create the delegate.
            AsyncMethodCaller caller = new AsyncMethodCaller(ad.TestMethod);
       
            // Initiate the asychronous call.
            IAsyncResult result = caller.BeginInvoke(3000, 
                out threadId, null, null);

            Thread.Sleep(0);
            Console.WriteLine("Main thread {0} does some work.",
                Thread.CurrentThread.ManagedThreadId);

            // Wait for the WaitHandle to become signaled.
            result.AsyncWaitHandle.WaitOne();

            // Perform additional processing here.
            // Call EndInvoke to retrieve the results.
            string returnValue = caller.EndInvoke(out threadId, result);

            // Close the wait handle.
            result.AsyncWaitHandle.Close();

            Console.WriteLine("The call executed on thread {0}, with return value \"{1}\".",
                threadId, returnValue);
        }
    }
}

/* This example produces output similar to the following:

Main thread 1 does some work.
Test method begins.
The call executed on thread 3, with return value "My call time was 3000.".
 */
Imports System.Threading
Imports System.Runtime.InteropServices 

Namespace Examples.AdvancedProgramming.AsynchronousOperations

    Public Class AsyncMain 
        Shared Sub Main() 
            ' The asynchronous method puts the thread id here.
            Dim threadId As Integer

            ' Create an instance of the test class.
            Dim ad As New AsyncDemo()

            ' Create the delegate.
            Dim caller As New AsyncMethodCaller(AddressOf ad.TestMethod)
       
            ' Initiate the asynchronous call.
            Dim result As IAsyncResult = caller.BeginInvoke(3000, _
                threadId, Nothing, Nothing)

            Thread.Sleep(0)
            Console.WriteLine("Main thread {0} does some work.", _
                Thread.CurrentThread.ManagedThreadId)
            ' Perform additional processing here and then
            ' wait for the WaitHandle to be signaled.
            result.AsyncWaitHandle.WaitOne()

            ' Call EndInvoke to retrieve the results.
            Dim returnValue As String = caller.EndInvoke(threadId, result)

            ' Close the wait handle.
            result.AsyncWaitHandle.Close()

            Console.WriteLine("The call executed on thread {0}, with return value ""{1}"".", _
                threadId, returnValue)
        End Sub
    End Class
End Namespace

'This example produces output similar to the following:
'
'Main thread 1 does some work.
'Test method begins.
'The call executed on thread 3, with return value "My call time was 3000.".

Remarques

La AsyncResult classe est utilisée conjointement avec les appels de méthode asynchrones effectués à l’aide de délégués.The AsyncResult class is used in conjunction with asynchronous method calls made using delegates. Le IAsyncResult retourné par la méthode du BeginInvoke délégué AsyncResultpeut être casté en.The IAsyncResult returned from the delegate's BeginInvoke method can be cast to an AsyncResult. Le AsyncResult a la AsyncDelegate propriété qui contient l’objet délégué sur lequel l’appel asynchrone a été appelé.The AsyncResult has the AsyncDelegate property that holds the delegate object on which the asynchronous call was invoked.

Pour plus d’informations BeginInvoke sur les appels et les appels asynchrones à l’aide de délégués, consultez programmation asynchrone à l’aide de délégués.For more information about BeginInvoke and asynchronous calls using delegates, see Asynchronous Programming Using Delegates.

Propriétés

AsyncDelegate

Obtient l'objet de délégué sur lequel l'appel asynchrone a été effectué.Gets the delegate object on which the asynchronous call was invoked.

AsyncState

Obtient l'objet fourni comme dernier paramètre d'un appel de méthode BeginInvoke.Gets the object provided as the last parameter of a BeginInvoke method call.

AsyncWaitHandle

Obtient un WaitHandle qui encapsule des handles de synchronisation Win32 et permet l'implémentation de divers schémas de synchronisation.Gets a WaitHandle that encapsulates Win32 synchronization handles, and allows the implementation of various synchronization schemes.

CompletedSynchronously

Obtient une valeur indiquant si l'appel BeginInvoke s'est terminé de façon synchrone.Gets a value indicating whether the BeginInvoke call completed synchronously.

EndInvokeCalled

Obtient ou définit une valeur indiquant si EndInvoke a été appelé sur AsyncResult en cours.Gets or sets a value indicating whether EndInvoke has been called on the current AsyncResult.

IsCompleted

Obtient une valeur indiquant si le serveur a terminé l'appel.Gets a value indicating whether the server has completed the call.

NextSink

Obtient le récepteur de messages suivant dans la chaîne de récepteurs.Gets the next message sink in the sink chain.

Méthodes

AsyncProcessMessage(IMessage, IMessageSink)

Implémente l'interface IMessageSink.Implements the IMessageSink interface.

Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.Determines whether the specified object is equal to the current object.

(Hérité de Object)
GetHashCode()

Sert de fonction de hachage par défaut.Serves as the default hash function.

(Hérité de Object)
GetReplyMessage()

Obtient le message de réponse pour l'appel asynchrone.Gets the response message for the asynchronous call.

GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Hérité de Object)
MemberwiseClone()

Crée une copie superficielle de l'objet Object actuel.Creates a shallow copy of the current Object.

(Hérité de Object)
SetMessageCtrl(IMessageCtrl)

Définit IMessageCtrl pour l'appel de méthode distant en cours qui offre un moyen de contrôler les messages asynchrones après leur distribution.Sets an IMessageCtrl for the current remote method call, which provides a way to control asynchronous messages after they have been dispatched.

SyncProcessMessage(IMessage)

Traite de manière synchrone un message de réponse retourné par un appel de méthode sur un objet distant.Synchronously processes a response message returned by a method call on a remote object.

ToString()

Retourne une chaîne qui représente l'objet en cours.Returns a string that represents the current object.

(Hérité de Object)

S’applique à

Voir aussi