WaitHandle.WaitOne Méthode

public:
 virtual bool WaitOne();

public virtual bool WaitOne();

abstract member WaitOne : unit -> bool
override this.WaitOne : unit -> bool

Public Overridable Function WaitOne () As Boolean

Retours

true si l’instance actuelle reçoit un signal. Si l’instance actuelle n’est jamais signalée, WaitOne() ne retourne jamais.

Exceptions

Exemples

L’exemple de code suivant montre comment utiliser un handle d’attente pour empêcher la fin d’un processus pendant qu’il attend qu’un thread d’arrière-plan termine l’exécution.

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();
    }
}

Imports System.Threading

Public Class WaitOne

    Shared autoEvent As New AutoResetEvent(False)

    <MTAThread> _
    Shared Sub Main()
        Console.WriteLine("Main starting.")

        ThreadPool.QueueUserWorkItem(AddressOf WorkMethod, autoEvent)

        ' Wait for work method to signal.
        autoEvent.WaitOne()
        Console.WriteLine("Work method signaled.")
        Console.WriteLine("Main ending.")
    End Sub

    Shared Sub WorkMethod(stateInfo As Object) 
        Console.WriteLine("Work starting.")

        ' Simulate time spent working.
        Thread.Sleep(New Random().Next(100, 2000))

        ' Signal that work is finished.
        Console.WriteLine("Work ending.")
        CType(stateInfo, AutoResetEvent).Set()
    End Sub

End Class

Remarques

AbandonedMutexException est nouveau dans .NET Framework version 2.0. Dans les versions précédentes, la WaitOne méthode retourne true lorsqu’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, il 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 l’instance actuelle reçoive un signal. Utilisez cette méthode pour bloquer jusqu’à ce qu’un WaitHandle signal reçoive un signal d’un autre thread, tel qu’il est généré lorsqu’une opération asynchrone se termine. Pour plus d’informations, consultez l’interface IAsyncResult.

L’appel de cette surcharge de méthode équivaut à 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.

public:
 virtual bool WaitOne(int millisecondsTimeout);

public virtual bool WaitOne(int millisecondsTimeout);

abstract member WaitOne : int -> bool
override this.WaitOne : int -> bool

Public Overridable Function WaitOne (millisecondsTimeout As Integer) As Boolean

Paramètres

Retours

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

Exceptions

Exemples

L’exemple de code suivant montre comment utiliser un handle d’attente pour empêcher la fin d’un processus pendant qu’il attend qu’un thread d’arrière-plan termine l’exécution.

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();
    }
}

Imports System.Threading

Public Class WaitOne

    Shared autoEvent As New AutoResetEvent(False)

    <MTAThread> _
    Shared Sub Main()
        Console.WriteLine("Main starting.")

        ThreadPool.QueueUserWorkItem(AddressOf WorkMethod, autoEvent)

        ' Wait for work method to signal.
        If autoEvent.WaitOne(1000) Then
            Console.WriteLine("Work method signaled.")
        Else
            Console.WriteLine("Timed out waiting for work " & _
                "method to signal.")
        End If

        Console.WriteLine("Main ending.")
    End Sub

    Shared Sub WorkMethod(stateInfo As Object) 
        Console.WriteLine("Work starting.")

        ' Simulate time spent working.
        Thread.Sleep(New Random().Next(100, 2000))

        ' Signal that work is finished.
        Console.WriteLine("Work ending.")
        CType(stateInfo, AutoResetEvent).Set()
    End Sub

End Class

Remarques

Si millisecondsTimeout elle est égale à 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 l’instance actuelle reçoive un signal ou qu’un délai d’attente se produise. Utilisez cette méthode pour bloquer jusqu’à ce qu’un WaitHandle signal reçoive un signal d’un autre thread, tel qu’il est généré lorsqu’une opération asynchrone se termine. 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 est identique à l’appel de la WaitOne(Int32, Boolean) surcharge et en spécifiant false pour exitContext.

public:
 virtual bool WaitOne(TimeSpan timeout);

public virtual bool WaitOne(TimeSpan timeout);

abstract member WaitOne : TimeSpan -> bool
override this.WaitOne : TimeSpan -> bool

Public Overridable Function WaitOne (timeout As TimeSpan) As Boolean

Paramètres

Retours

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

Exceptions

Remarques

Si timeout elle est égale à 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 l’instance actuelle reçoive un signal ou qu’un délai d’attente se produise. Utilisez cette méthode pour bloquer jusqu’à ce qu’un WaitHandle signal reçoive un signal d’un autre thread, tel qu’il est généré lorsqu’une opération asynchrone se termine. 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 est identique à l’appel de la WaitOne(TimeSpan, Boolean) surcharge et en spécifiant false pour exitContext.

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

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

abstract member WaitOne : int * bool -> bool
override this.WaitOne : int * bool -> bool

Public Overridable Function WaitOne (millisecondsTimeout As Integer, exitContext As Boolean) As Boolean

Paramètres

Retours

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

Exceptions

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 la valeur définie et bloque jusqu’à false l’expiration du délai d’attente. Un deuxième thread s’exécute après que le premier thread se termine et attend avec exitContext la valeur définie truesur . L’appel pour signaler le handle d’attente pour ce deuxième thread n’est pas bloqué et le thread se termine avant le délai d’attente.

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!!!

Imports System.Threading
Imports System.Runtime.Remoting.Contexts

<Synchronization(true)>
Public Class SyncingClass
    Inherits ContextBoundObject
    
    Private waitHandle As EventWaitHandle

    Public Sub New()
         waitHandle = New EventWaitHandle(false, EventResetMode.ManualReset)
    End Sub

    Public Sub Signal()
        Console.WriteLine("Thread[{0:d4}]: Signalling...", Thread.CurrentThread.GetHashCode())
        waitHandle.Set()
    End Sub

    Public Sub DoWait(leaveContext As Boolean)
        Dim signalled As Boolean

        waitHandle.Reset()
        Console.WriteLine("Thread[{0:d4}]: Waiting...", Thread.CurrentThread.GetHashCode())
        signalled = waitHandle.WaitOne(3000, leaveContext)
        If signalled Then
            Console.WriteLine("Thread[{0:d4}]: Wait released!!!", Thread.CurrentThread.GetHashCode())
        Else
            Console.WriteLine("Thread[{0:d4}]: Wait timeout!!!", Thread.CurrentThread.GetHashCode())
        End If
    End Sub
End Class

Public Class TestSyncDomainWait
    Public Shared Sub Main()
        Dim syncClass As New SyncingClass()

        Dim runWaiter As Thread

        Console.WriteLine(Environment.NewLine + "Wait and signal INSIDE synchronization domain:" + Environment.NewLine)
        runWaiter = New Thread(AddressOf 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(Environment.NewLine + "Wait and signal OUTSIDE synchronization domain:" + Environment.NewLine)
        runWaiter = New Thread(AddressOf 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()
    End Sub

    Public Shared Sub RunWaitKeepContext(parm As Object)
        Dim syncClass As SyncingClass = CType(parm, SyncingClass)
        syncClass.DoWait(False)
    End Sub

    Public Shared Sub RunWaitLeaveContext(parm As Object)
        Dim syncClass As SyncingClass = CType(parm, SyncingClass)
        syncClass.DoWait(True)
    End Sub
End Class

' 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 elle est égale à 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é, il 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, il 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 l’instance actuelle reçoive un signal ou qu’un délai d’attente se produise. Utilisez cette méthode pour bloquer jusqu’à ce qu’un WaitHandle signal reçoive un signal d’un autre thread, tel qu’il est généré lorsqu’une opération asynchrone se termine. 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é nondefault. Le contexte managé peut être nondefault si votre thread se trouve à l’intérieur d’un appel à une 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, par exemple String, vous pouvez être dans un contexte nondefault si une ContextBoundObject est sur votre pile dans le domaine d’application actuel.

Lorsque votre code s’exécute dans un contexte non défini, en spécifiant true pour exitContext que le thread quitte le contexte managé non défini (autrement dit, pour passer au contexte par défaut) avant d’exécuter cette méthode. Le thread retourne au contexte nondefault 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 le corps entier du code de la classe. Si le code dans la pile des 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 de réentérer le domaine de synchronisation.

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

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

abstract member WaitOne : TimeSpan * bool -> bool
override this.WaitOne : TimeSpan * bool -> bool

Public Overridable Function WaitOne (timeout As TimeSpan, exitContext As Boolean) As Boolean

Paramètres

Retours

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

Exceptions

Exemples

L’exemple de code suivant montre comment utiliser un handle d’attente pour empêcher la fin d’un processus pendant qu’il attend qu’un thread d’arrière-plan termine l’exécution.

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();
    }
}

Imports System.Threading

Public Class WaitOne

    Shared autoEvent As New AutoResetEvent(False)

    <MTAThread> _
    Shared Sub Main()
        Console.WriteLine("Main starting.")

        ThreadPool.QueueUserWorkItem(AddressOf WorkMethod, autoEvent)

        ' Wait for work method to signal.
        If autoEvent.WaitOne(New TimeSpan(0, 0, 1), False) Then
            Console.WriteLine("Work method signaled.")
        Else
            Console.WriteLine("Timed out waiting for work " & _
                "method to signal.")
        End If

        Console.WriteLine("Main ending.")
    End Sub

    Shared Sub WorkMethod(stateInfo As Object) 
        Console.WriteLine("Work starting.")

        ' Simulate time spent working.
        Thread.Sleep(New Random().Next(100, 2000))

        ' Signal that work is finished.
        Console.WriteLine("Work ending.")
        CType(stateInfo, AutoResetEvent).Set()
    End Sub

End Class

Remarques

Si timeout elle est égale à 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é, il 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, il 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 l’instance actuelle reçoive un signal ou qu’un délai d’attente se produise. Utilisez cette méthode pour bloquer jusqu’à ce qu’un WaitHandle signal reçoive un signal d’un autre thread, tel qu’il est généré lorsqu’une opération asynchrone se termine. 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é nondefault. Le contexte managé peut être nondefault si votre thread se trouve à l’intérieur d’un appel à une 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, par exemple String, vous pouvez être dans un contexte nondefault si une ContextBoundObject est sur votre pile dans le domaine d’application actuel.

Lorsque votre code s’exécute dans un contexte non défini, en spécifiant true pour exitContext que le thread quitte le contexte managé non défini (autrement dit, pour passer au contexte par défaut) avant d’exécuter cette méthode. Le thread retourne au contexte nondefault 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 le corps entier du code de la classe. Si le code dans la pile des 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 de réentérer le domaine de synchronisation.