WaitHandle.WaitOne Méthode

Définition

Espace de noms:

System.Threading

Assembly:

System.Runtime.dll

Bloque le thread actuel jusqu'à ce que le WaitHandle actuel reçoive un signal.

Surcharges

WaitOne()	Bloque le thread actuel jusqu'à ce que le WaitHandle actuel reçoive un signal.
WaitOne(Int32)	Bloque le thread actuel jusqu'à ce que le WaitHandle actuel reçoive un signal, en utilisant un entier signé 32 bits pour spécifier l'intervalle de temps.
WaitOne(TimeSpan)	Bloque le thread actuel jusqu'à ce que l'instance actuelle reçoive un signal, en utilisant une valeur TimeSpan pour spécifier l'intervalle de temps.
WaitOne(Int32, Boolean)	Bloque le thread actuel jusqu’à ce que le WaitHandle actuel reçoive un signal, en utilisant un entier signé 32 bits pour spécifier l’intervalle de temps et en spécifiant s’il faut quitter le domaine de synchronisation avant l’attente.
WaitOne(TimeSpan, Boolean)	Bloque le thread actuel jusqu'à ce que l'instance actuelle reçoive un signal, en utilisant une valeur TimeSpan pour spécifier l'intervalle de temps et en spécifiant s'il faut quitter le domaine de synchronisation avant l'attente.

WaitOne()

Source:

WaitHandle.cs

Bloque le thread actuel jusqu'à ce que le WaitHandle actuel reçoive un signal.

C#

public virtual bool WaitOne ();

Retours

Boolean

true si l'instance actuelle reçoit un signal. Si l'instance actuelle ne reçoit jamais de signal, WaitOne() ne retourne jamais.

Exceptions

ObjectDisposedException

L’instance actuelle a déjà été supprimée.

AbandonedMutexException

L’attente s’est arrêtée, car un thread s’est terminé sans libérer de mutex.

InvalidOperationException

L'instance actuelle est un proxy transparent pour un WaitHandle dans un autre domaine d'application.

Exemples

L’exemple de code suivant montre comment utiliser un handle d’attente pour empêcher un processus de se terminer pendant qu’il attend qu’un thread d’arrière-plan se termine.

C#

using System;
using System.Threading;

class WaitOne
{
    static AutoResetEvent autoEvent = new AutoResetEvent(false);

    static void Main()
    {
        Console.WriteLine("Main starting.");

        ThreadPool.QueueUserWorkItem(
            new WaitCallback(WorkMethod), autoEvent);

        // Wait for work method to signal.
        autoEvent.WaitOne();
        Console.WriteLine("Work method signaled.\nMain ending.");
    }

    static void WorkMethod(object stateInfo) 
    {
        Console.WriteLine("Work starting.");

        // Simulate time spent working.
        Thread.Sleep(new Random().Next(100, 2000));

        // Signal that work is finished.
        Console.WriteLine("Work ending.");
        ((AutoResetEvent)stateInfo).Set();
    }
}

Remarques

AbandonedMutexException est nouveau dans .NET Framework version 2.0. Dans les versions précédentes, la WaitOne méthode retourne true quand un mutex est abandonné. Un mutex abandonné indique souvent une erreur de codage grave. Dans le cas d’un mutex à l’échelle du système, cela peut indiquer qu’une application a été arrêtée brusquement (par exemple, à l’aide du Gestionnaire des tâches Windows). L’exception contient des informations utiles pour le débogage.

L’appelant de cette méthode se bloque indéfiniment jusqu’à ce que le instance actuel reçoive un signal. Utilisez cette méthode pour bloquer jusqu’à ce qu’un WaitHandle reçoit un signal d’un autre thread, tel qu’il est généré à la fin d’une opération asynchrone. Pour plus d’informations, consultez l’interface IAsyncResult .

Appeler cette surcharge de méthode revient à appeler la WaitOne(Int32, Boolean) surcharge de méthode et à spécifier -1 ou Timeout.Infinite pour le premier paramètre et false pour le deuxième paramètre.

Remplacez cette méthode pour personnaliser le comportement des classes dérivées.

WaitOne(Int32)

Source:

WaitHandle.cs

Bloque le thread actuel jusqu'à ce que le WaitHandle actuel reçoive un signal, en utilisant un entier signé 32 bits pour spécifier l'intervalle de temps.

C#

public virtual bool WaitOne (int millisecondsTimeout);

Paramètres

millisecondsTimeout

Int32

Nombre de millisecondes à attendre, ou Infinite (-1) pour un délai d'attente infini.

Retours

Boolean

true si l'instance actuelle reçoit un signal ; sinon, false.

Exceptions

ObjectDisposedException

L’instance actuelle a déjà été supprimée.

ArgumentOutOfRangeException

millisecondsTimeout est un nombre négatif différent de -1, qui représente un délai d’attente infini.

AbandonedMutexException

L’attente s’est arrêtée, car un thread s’est terminé sans libérer de mutex.

InvalidOperationException

L'instance actuelle est un proxy transparent pour un WaitHandle dans un autre domaine d'application.

Exemples

L’exemple de code suivant montre comment utiliser un handle d’attente pour empêcher un processus de se terminer pendant qu’il attend qu’un thread d’arrière-plan se termine.

C#

using System;
using System.Threading;

class WaitOne
{
    static AutoResetEvent autoEvent = new AutoResetEvent(false);

    static void Main()
    {
        Console.WriteLine("Main starting.");

        ThreadPool.QueueUserWorkItem(
            new WaitCallback(WorkMethod), autoEvent);

        // Wait for work method to signal.
        if(autoEvent.WaitOne(1000))
        {
            Console.WriteLine("Work method signaled.");
        }
        else
        {
            Console.WriteLine("Timed out waiting for work " +
                "method to signal.");
        }
        Console.WriteLine("Main ending.");
    }

    static void WorkMethod(object stateInfo) 
    {
        Console.WriteLine("Work starting.");

        // Simulate time spent working.
        Thread.Sleep(new Random().Next(100, 2000));

        // Signal that work is finished.
        Console.WriteLine("Work ending.");
        ((AutoResetEvent)stateInfo).Set();
    }
}

Remarques

Si millisecondsTimeout est zéro, la méthode ne bloque pas. Il teste l’état du handle d’attente et retourne immédiatement.

L’appelant de cette méthode bloque jusqu’à ce que le instance actuel reçoive un signal ou qu’un délai d’attente se produise. Utilisez cette méthode pour bloquer jusqu’à ce qu’un WaitHandle reçoit un signal d’un autre thread, tel qu’il est généré à la fin d’une opération asynchrone. Pour plus d’informations, consultez l’interface IAsyncResult .

Remplacez cette méthode pour personnaliser le comportement des classes dérivées.

L’appel de cette surcharge de méthode revient à appeler la WaitOne(Int32, Boolean) surcharge et à false spécifier pour exitContext.

WaitOne(TimeSpan)

Source:

WaitHandle.cs

Bloque le thread actuel jusqu'à ce que l'instance actuelle reçoive un signal, en utilisant une valeur TimeSpan pour spécifier l'intervalle de temps.

C#

public virtual bool WaitOne (TimeSpan timeout);

Paramètres

timeout

TimeSpan

TimeSpan qui représente le nombre de millièmes de secondes à attendre ou TimeSpan qui représente -1 millième de seconde, pour attendre indéfiniment.

Retours

Boolean

true si l'instance actuelle reçoit un signal ; sinon, false.

Exceptions

ObjectDisposedException

L’instance actuelle a déjà été supprimée.

ArgumentOutOfRangeException

timeout est un nombre négatif différent de -1 milliseconde, qui représente un délai d’attente infini.

-ou-

timeout est supérieur à Int32.MaxValue.

AbandonedMutexException

L’attente s’est arrêtée, car un thread s’est terminé sans libérer de mutex.

InvalidOperationException

L'instance actuelle est un proxy transparent pour un WaitHandle dans un autre domaine d'application.

Remarques

Si timeout est zéro, la méthode ne bloque pas. Il teste l’état du handle d’attente et retourne immédiatement.

L’appelant de cette méthode bloque jusqu’à ce que le instance actuel reçoive un signal ou qu’un délai d’attente se produise. Utilisez cette méthode pour bloquer jusqu’à ce qu’un WaitHandle reçoit un signal d’un autre thread, tel qu’il est généré à la fin d’une opération asynchrone. Pour plus d’informations, consultez l’interface IAsyncResult .

Remplacez cette méthode pour personnaliser le comportement des classes dérivées.

La valeur maximale pour timeout est Int32.MaxValue.

L’appel de cette surcharge de méthode revient à appeler la WaitOne(TimeSpan, Boolean) surcharge et à false spécifier pour exitContext.

WaitOne(Int32, Boolean)

Source:

WaitHandle.cs

Bloque le thread actuel jusqu’à ce que le WaitHandle actuel reçoive un signal, en utilisant un entier signé 32 bits pour spécifier l’intervalle de temps et en spécifiant s’il faut quitter le domaine de synchronisation avant l’attente.

C#

public virtual bool WaitOne (int millisecondsTimeout, bool exitContext);

Paramètres

millisecondsTimeout

Int32

Nombre de millisecondes à attendre, ou Infinite (-1) pour un délai d'attente infini.

exitContext

Boolean

true pour quitter le domaine de synchronisation du contexte avant l'attente (dans le cas d'un contexte synchronisé) et l'acquérir à nouveau ensuite ; sinon, false.

Retours

Boolean

true si l'instance actuelle reçoit un signal ; sinon, false.

Exceptions

ObjectDisposedException

L’instance actuelle a déjà été supprimée.

ArgumentOutOfRangeException

millisecondsTimeout est un nombre négatif différent de -1, qui représente un délai d’attente infini.

AbandonedMutexException

L’attente s’est arrêtée, car un thread s’est terminé sans libérer de mutex.

InvalidOperationException

L'instance actuelle est un proxy transparent pour un WaitHandle dans un autre domaine d'application.

Exemples

L’exemple suivant montre comment la surcharge de WaitOne(Int32, Boolean) méthode se comporte lorsqu’elle est appelée dans un domaine de synchronisation. Tout d’abord, un thread attend avec exitContext défini sur et bloque jusqu’à false l’expiration du délai d’attente. Un deuxième thread s’exécute une fois que le premier thread se termine et attend avec exitContext la valeur définie sur true. L’appel pour signaler la poignée d’attente de ce deuxième thread n’est pas bloqué et le thread se termine avant le délai d’attente.

C#

using System;
using System.Threading;
using System.Runtime.Remoting.Contexts;

[Synchronization(true)]
public class SyncingClass : ContextBoundObject
{
    private EventWaitHandle waitHandle;

    public SyncingClass()
    {
         waitHandle =
            new EventWaitHandle(false, EventResetMode.ManualReset);
    }

    public void Signal()
    {
        Console.WriteLine("Thread[{0:d4}]: Signalling...", Thread.CurrentThread.GetHashCode());
        waitHandle.Set();
    }

    public void DoWait(bool leaveContext)
    {
        bool signalled;

        waitHandle.Reset();
        Console.WriteLine("Thread[{0:d4}]: Waiting...", Thread.CurrentThread.GetHashCode());
        signalled = waitHandle.WaitOne(3000, leaveContext);
        if (signalled)
        {
            Console.WriteLine("Thread[{0:d4}]: Wait released!!!", Thread.CurrentThread.GetHashCode());
        }
        else
        {
            Console.WriteLine("Thread[{0:d4}]: Wait timeout!!!", Thread.CurrentThread.GetHashCode());
        }
    }
}

public class TestSyncDomainWait
{
    public static void Main()
    {
        SyncingClass syncClass = new SyncingClass();

        Thread runWaiter;

        Console.WriteLine("\nWait and signal INSIDE synchronization domain:\n");
        runWaiter = new Thread(RunWaitKeepContext);
        runWaiter.Start(syncClass);
        Thread.Sleep(1000);
        Console.WriteLine("Thread[{0:d4}]: Signal...", Thread.CurrentThread.GetHashCode());
        // This call to Signal will block until the timeout in DoWait expires.
        syncClass.Signal();
        runWaiter.Join();

        Console.WriteLine("\nWait and signal OUTSIDE synchronization domain:\n");
        runWaiter = new Thread(RunWaitLeaveContext);
        runWaiter.Start(syncClass);
        Thread.Sleep(1000);
        Console.WriteLine("Thread[{0:d4}]: Signal...", Thread.CurrentThread.GetHashCode());
        // This call to Signal is unblocked and will set the wait handle to
        // release the waiting thread.
        syncClass.Signal();
        runWaiter.Join();
    }

    public static void RunWaitKeepContext(object parm)
    {
        ((SyncingClass)parm).DoWait(false);
    }

    public static void RunWaitLeaveContext(object parm)
    {
        ((SyncingClass)parm).DoWait(true);
    }
}

// The output for the example program will be similar to the following:
//
// Wait and signal INSIDE synchronization domain:
//
// Thread[0004]: Waiting...
// Thread[0001]: Signal...
// Thread[0004]: Wait timeout!!!
// Thread[0001]: Signalling...
//
// Wait and signal OUTSIDE synchronization domain:
//
// Thread[0006]: Waiting...
// Thread[0001]: Signal...
// Thread[0001]: Signalling...
// Thread[0006]: Wait released!!!

Remarques

Si millisecondsTimeout est zéro, la méthode ne bloque pas. Il teste l’état du handle d’attente et retourne immédiatement.

Si un mutex est abandonné, un AbandonedMutexException est levée. Un mutex abandonné indique souvent une erreur de codage grave. Dans le cas d’un mutex à l’échelle du système, cela peut indiquer qu’une application a été arrêtée brusquement (par exemple, à l’aide du Gestionnaire des tâches Windows). L’exception contient des informations utiles pour le débogage.

L’appelant de cette méthode bloque jusqu’à ce que le instance actuel reçoive un signal ou qu’un délai d’attente se produise. Utilisez cette méthode pour bloquer jusqu’à ce qu’un WaitHandle reçoit un signal d’un autre thread, tel qu’il est généré à la fin d’une opération asynchrone. Pour plus d’informations, consultez l’interface IAsyncResult .

Remplacez cette méthode pour personnaliser le comportement des classes dérivées.

Sortie du contexte

Le exitContext paramètre n’a aucun effet, sauf si cette méthode est appelée à partir d’un contexte managé non par défaut. Le contexte managé peut être non défini par défaut si votre thread se trouve à l’intérieur d’un appel à un instance d’une classe dérivée de ContextBoundObject. Même si vous exécutez actuellement une méthode sur une classe qui n’est pas dérivée de ContextBoundObject, comme String, vous pouvez être dans un contexte non par défaut si un ContextBoundObject se trouve sur votre pile dans le domaine d’application actuel.

Lorsque votre code s’exécute dans un contexte non par défaut, la spécification true pour exitContext entraîne la sortie du thread du contexte managé non par défaut (autrement dit, pour passer au contexte par défaut) avant d’exécuter cette méthode. Le thread retourne au contexte non par défaut d’origine une fois l’appel à cette méthode terminé.

La sortie du contexte peut être utile lorsque la classe liée au contexte a l’attribut SynchronizationAttribute . Dans ce cas, tous les appels aux membres de la classe sont automatiquement synchronisés et le domaine de synchronisation est l’ensemble du corps du code de la classe. Si le code dans la pile d’appels d’un membre appelle cette méthode et spécifie true pour exitContext, le thread quitte le domaine de synchronisation, ce qui permet à un thread bloqué sur un appel à n’importe quel membre de l’objet de continuer. Lorsque cette méthode est retournée, le thread qui a effectué l’appel doit attendre d’être réentrée dans le domaine de synchronisation.

WaitOne(TimeSpan, Boolean)

Source:

WaitHandle.cs

Bloque le thread actuel jusqu'à ce que l'instance actuelle reçoive un signal, en utilisant une valeur TimeSpan pour spécifier l'intervalle de temps et en spécifiant s'il faut quitter le domaine de synchronisation avant l'attente.

C#

public virtual bool WaitOne (TimeSpan timeout, bool exitContext);

Paramètres

timeout

TimeSpan

TimeSpan qui représente le nombre de millièmes de secondes à attendre ou TimeSpan qui représente -1 millième de seconde, pour attendre indéfiniment.

exitContext

Boolean

true pour quitter le domaine de synchronisation du contexte avant l'attente (dans le cas d'un contexte synchronisé) et l'acquérir à nouveau ensuite ; sinon, false.

Retours

Boolean

true si l'instance actuelle reçoit un signal ; sinon, false.

Exceptions

ObjectDisposedException

L’instance actuelle a déjà été supprimée.

ArgumentOutOfRangeException

timeout est un nombre négatif différent de -1 milliseconde, qui représente un délai d’attente infini.

-ou-

timeout est supérieur à Int32.MaxValue.

AbandonedMutexException

L’attente s’est arrêtée, car un thread s’est terminé sans libérer de mutex.

InvalidOperationException

L'instance actuelle est un proxy transparent pour un WaitHandle dans un autre domaine d'application.

Exemples

L’exemple de code suivant montre comment utiliser un handle d’attente pour empêcher un processus de se terminer pendant qu’il attend qu’un thread d’arrière-plan se termine.

C#

using System;
using System.Threading;

class WaitOne
{
    static AutoResetEvent autoEvent = new AutoResetEvent(false);

    static void Main()
    {
        Console.WriteLine("Main starting.");

        ThreadPool.QueueUserWorkItem(
            new WaitCallback(WorkMethod), autoEvent);

        // Wait for work method to signal.
        if(autoEvent.WaitOne(new TimeSpan(0, 0, 1), false))
        {
            Console.WriteLine("Work method signaled.");
        }
        else
        {
            Console.WriteLine("Timed out waiting for work " +
                "method to signal.");
        }
        Console.WriteLine("Main ending.");
    }

    static void WorkMethod(object stateInfo) 
    {
        Console.WriteLine("Work starting.");

        // Simulate time spent working.
        Thread.Sleep(new Random().Next(100, 2000));

        // Signal that work is finished.
        Console.WriteLine("Work ending.");
        ((AutoResetEvent)stateInfo).Set();
    }
}

Remarques

Si timeout est zéro, la méthode ne bloque pas. Il teste l’état du handle d’attente et retourne immédiatement.

Si un mutex est abandonné, un AbandonedMutexException est levée. Un mutex abandonné indique souvent une erreur de codage grave. Dans le cas d’un mutex à l’échelle du système, cela peut indiquer qu’une application a été arrêtée brusquement (par exemple, à l’aide du Gestionnaire des tâches Windows). L’exception contient des informations utiles pour le débogage.

L’appelant de cette méthode bloque jusqu’à ce que le instance actuel reçoive un signal ou qu’un délai d’attente se produise. Utilisez cette méthode pour bloquer jusqu’à ce qu’un WaitHandle reçoit un signal d’un autre thread, tel qu’il est généré à la fin d’une opération asynchrone. Pour plus d’informations, consultez l’interface IAsyncResult .

Remplacez cette méthode pour personnaliser le comportement des classes dérivées.

La valeur maximale pour timeout est Int32.MaxValue.

Sortie du contexte

Le exitContext paramètre n’a aucun effet, sauf si cette méthode est appelée à partir d’un contexte managé non par défaut. Le contexte managé peut être non défini par défaut si votre thread se trouve à l’intérieur d’un appel à un instance d’une classe dérivée de ContextBoundObject. Même si vous exécutez actuellement une méthode sur une classe qui n’est pas dérivée de ContextBoundObject, comme String, vous pouvez être dans un contexte non par défaut si un ContextBoundObject se trouve sur votre pile dans le domaine d’application actuel.

Lorsque votre code s’exécute dans un contexte non par défaut, la spécification true pour exitContext entraîne la sortie du thread du contexte managé non par défaut (autrement dit, pour passer au contexte par défaut) avant d’exécuter cette méthode. Le thread retourne au contexte non par défaut d’origine une fois l’appel à cette méthode terminé.

La sortie du contexte peut être utile lorsque la classe liée au contexte a l’attribut SynchronizationAttribute . Dans ce cas, tous les appels aux membres de la classe sont automatiquement synchronisés et le domaine de synchronisation est l’ensemble du corps du code de la classe. Si le code dans la pile d’appels d’un membre appelle cette méthode et spécifie true pour exitContext, le thread quitte le domaine de synchronisation, ce qui permet à un thread bloqué sur un appel à n’importe quel membre de l’objet de continuer. Lorsque cette méthode est retournée, le thread qui a effectué l’appel doit attendre d’être réentrée dans le domaine de synchronisation.