Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

AsyncResult.AsyncWaitHandle propriété

 

Date de publication : novembre 2016

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

Espace de noms:   System.Runtime.Remoting.Messaging
Assembly:  mscorlib (dans mscorlib.dll)

public virtual WaitHandle AsyncWaitHandle { get; }

Valeur de propriété

Type: System.Threading.WaitHandle

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

Le WaitHandle retourné par cette méthode est automatiquement signalée 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 appeler la 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ées ou libérées.

System_CAPS_cautionAttention

Le WaitHandle contenus dans le AsyncWaitHandle propriété peut être utilisée pour bloquer le thread actuel jusqu'à ce que l’appel asynchrone est terminé. Toutefois, le WaitHandle ignorera la AsyncCallback, s’il a été spécifié lors de la BeginInvoke appeler. Par conséquent, une situation peut se produire lorsque l’application s’arrête avant la AsyncCallback a terminé l’exécution, même si un WaitHandle est utilisé pour bloquer jusqu'à la fin de l’appel asynchrone. Pour obtenir un exemple d’une telle situation, consultez l’exemple de la AsyncResult classe et supprimez la Thread.Sleep instruction.

L’exemple suivant montre comment utiliser le AsyncWaitHandle propriété à obtenir un WaitHandle, et l’attente d’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 contenant la méthode qui est appelée de façon asynchrone et la classe qui contient la Main méthode qui effectue l’appel.

Pour plus d’informations et obtenir d’autres exemples d’appel de méthodes asynchrone à l’aide de délégués, consultez appel asynchrone des méthodes synchrones.

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

.NET Framework
Disponible depuis 1.1
Retour au début
Afficher: