AsyncResult.AsyncWaitHandle Propriété

Définition

Obtient un WaitHandle qui encapsule des handles de synchronisation Win32 et permet l'implémentation de divers schémas de synchronisation.

public virtual System.Threading.WaitHandle AsyncWaitHandle { get; }

Valeur de propriété

WaitHandle qui encapsule des handles de synchronisation Win32 et permet l'implémentation de divers schémas de synchronisation.

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é. Le WaitHandle est signalé quand l’appel asynchrone se termine et vous pouvez l’attendre en appelant la méthode WaitOne .

L’exemple se compose de deux classes, la classe qui contient la méthode appelée de manière asynchrone et la classe qui contient la Main méthode qui effectue l’appel.

Pour plus d’informations et d’autres exemples d’appel de méthodes de manière asynchrone à l’aide de délégués, consultez Appel de méthodes synchrones de manière asynchrone.

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);
}
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.".
 */

Remarques

Le WaitHandle retourné par cette méthode est automatiquement signalé lorsque l’opération asynchrone est terminée.

Le handle d’attente n’est pas fermé automatiquement lorsque vous appelez EndInvoke sur le délégué utilisé pour effectuer l’appel de méthode asynchrone. Si vous libérez toutes les références au handle d’attente, les ressources système sont libérées quand le garbage collection récupère le handle d’attente. Pour libérer les ressources système dès que vous avez terminé d’utiliser le handle d’attente, appelez la WaitHandle.Close méthode . Le garbage collection fonctionne plus efficacement lorsque les objets jetables sont explicitement fermés ou supprimés.

Attention

Le WaitHandle contenu de la AsyncWaitHandle propriété peut être utilisé pour bloquer le thread actuel jusqu’à ce que l’appel asynchrone soit terminé. Toutefois, le WaitHandle ignore si AsyncCallbackun a été spécifié pendant l’appel BeginInvoke . Par conséquent, une situation peut se produire où l’application s’arrête avant la fin de l’exécution AsyncCallback de, même si un WaitHandle est utilisé pour bloquer jusqu’à la fin de l’appel asynchrone. Pour obtenir un exemple de cette situation, consultez l’exemple de la AsyncResult classe et supprimez l’instruction Thread.Sleep .

S’applique à

Voir aussi