EventWaitHandle Constructeurs

Définition

Espace de noms:

System.Threading

Assembly:

System.Threading.dll

Initialise une nouvelle instance de la classe EventWaitHandle.

Surcharges

EventWaitHandle(Boolean, EventResetMode)	Initialise une nouvelle instance de la classe EventWaitHandle, en spécifiant si le handle d'attente est signalé initialement et s'il se réinitialise automatiquement ou manuellement.
EventWaitHandle(Boolean, EventResetMode, String)	Initialise une nouvelle instance de la classe EventWaitHandle, en spécifiant si le handle d'attente est signalé initialement s'il a été créé à la suite de cet appel, s'il se réinitialise automatiquement ou manuellement, ainsi que le nom d'un événement de synchronisation du système.
EventWaitHandle(Boolean, EventResetMode, String, Boolean)	Initialise une nouvelle instance de la classe EventWaitHandle, spécifiant si le handle d’attente est signalé initialement s’il est créé suite à cet appel, s’il se réinitialise automatiquement ou manuellement, le nom d’un événement de synchronisation du système et une variable booléenne dont la valeur après l’appel indique si l’événement système nommé a été créé.

EventWaitHandle(Boolean, EventResetMode)

Source:

EventWaitHandle.cs

Initialise une nouvelle instance de la classe EventWaitHandle, en spécifiant si le handle d'attente est signalé initialement et s'il se réinitialise automatiquement ou manuellement.

public:
 EventWaitHandle(bool initialState, System::Threading::EventResetMode mode);

public EventWaitHandle (bool initialState, System.Threading.EventResetMode mode);

new System.Threading.EventWaitHandle : bool * System.Threading.EventResetMode -> System.Threading.EventWaitHandle

Public Sub New (initialState As Boolean, mode As EventResetMode)

Paramètres

initialState

Boolean

true pour définir l'état initial comme étant signalé ; false pour le définir comme étant non signalé.

mode

EventResetMode

L’une des valeurs EventResetMode qui détermine si l’événement se réinitialise automatiquement ou manuellement.

Exceptions

ArgumentException

La valeur d’énumération mode était en dehors de la plage autorisée.

Exemples

L’exemple de code suivant utilise la SignalAndWait(WaitHandle, WaitHandle) surcharge de méthode pour permettre au thread principal de signaler un thread bloqué, puis d’attendre que le thread termine une tâche.

L’exemple démarre cinq threads et leur permet de bloquer sur un EventWaitHandle créé avec l’indicateur EventResetMode.AutoReset , puis libère un thread chaque fois que l’utilisateur appuie sur la touche Entrée . L’exemple met ensuite en file d’attente cinq autres threads et les libère tous à l’aide d’un EventWaitHandle créé avec l’indicateur EventResetMode.ManualReset .

using namespace System;
using namespace System::Threading;

public ref class Example
{
private:
   // The EventWaitHandle used to demonstrate the difference
   // between AutoReset and ManualReset synchronization events.
   //
   static EventWaitHandle^ ewh;

   // A counter to make sure all threads are started and
   // blocked before any are released. A Long is used to show
   // the use of the 64-bit Interlocked methods.
   //
   static __int64 threadCount = 0;

   // An AutoReset event that allows the main thread to block
   // until an exiting thread has decremented the count.
   //
   static EventWaitHandle^ clearCount =
      gcnew EventWaitHandle( false,EventResetMode::AutoReset );

public:
   [MTAThread]
   static void main()
   {
      // Create an AutoReset EventWaitHandle.
      //
      ewh = gcnew EventWaitHandle( false,EventResetMode::AutoReset );
      
      // Create and start five numbered threads. Use the
      // ParameterizedThreadStart delegate, so the thread
      // number can be passed as an argument to the Start
      // method.
      for ( int i = 0; i <= 4; i++ )
      {
         Thread^ t = gcnew Thread(
            gcnew ParameterizedThreadStart( ThreadProc ) );
         t->Start( i );
      }
      
      // Wait until all the threads have started and blocked.
      // When multiple threads use a 64-bit value on a 32-bit
      // system, you must access the value through the
      // Interlocked class to guarantee thread safety.
      //
      while ( Interlocked::Read( threadCount ) < 5 )
      {
         Thread::Sleep( 500 );
      }

      // Release one thread each time the user presses ENTER,
      // until all threads have been released.
      //
      while ( Interlocked::Read( threadCount ) > 0 )
      {
         Console::WriteLine( L"Press ENTER to release a waiting thread." );
         Console::ReadLine();
         
         // SignalAndWait signals the EventWaitHandle, which
         // releases exactly one thread before resetting,
         // because it was created with AutoReset mode.
         // SignalAndWait then blocks on clearCount, to
         // allow the signaled thread to decrement the count
         // before looping again.
         //
         WaitHandle::SignalAndWait( ewh, clearCount );
      }
      Console::WriteLine();
      
      // Create a ManualReset EventWaitHandle.
      //
      ewh = gcnew EventWaitHandle( false,EventResetMode::ManualReset );
      
      // Create and start five more numbered threads.
      //
      for ( int i = 0; i <= 4; i++ )
      {
         Thread^ t = gcnew Thread(
            gcnew ParameterizedThreadStart( ThreadProc ) );
         t->Start( i );
      }
      
      // Wait until all the threads have started and blocked.
      //
      while ( Interlocked::Read( threadCount ) < 5 )
      {
         Thread::Sleep( 500 );
      }

      // Because the EventWaitHandle was created with
      // ManualReset mode, signaling it releases all the
      // waiting threads.
      //
      Console::WriteLine( L"Press ENTER to release the waiting threads." );
      Console::ReadLine();
      ewh->Set();

   }

   static void ThreadProc( Object^ data )
   {
      int index = static_cast<Int32>(data);

      Console::WriteLine( L"Thread {0} blocks.", data );
      // Increment the count of blocked threads.
      Interlocked::Increment( threadCount );
      
      // Wait on the EventWaitHandle.
      ewh->WaitOne();

      Console::WriteLine( L"Thread {0} exits.", data );
      // Decrement the count of blocked threads.
      Interlocked::Decrement( threadCount );
      
      // After signaling ewh, the main thread blocks on
      // clearCount until the signaled thread has
      // decremented the count. Signal it now.
      //
      clearCount->Set();
   }
};

using System;
using System.Threading;

public class Example
{
    // The EventWaitHandle used to demonstrate the difference
    // between AutoReset and ManualReset synchronization events.
    //
    private static EventWaitHandle ewh;

    // A counter to make sure all threads are started and
    // blocked before any are released. A Long is used to show
    // the use of the 64-bit Interlocked methods.
    //
    private static long threadCount = 0;

    // An AutoReset event that allows the main thread to block
    // until an exiting thread has decremented the count.
    //
    private static EventWaitHandle clearCount = 
        new EventWaitHandle(false, EventResetMode.AutoReset);

    [MTAThread]
    public static void Main()
    {
        // Create an AutoReset EventWaitHandle.
        //
        ewh = new EventWaitHandle(false, EventResetMode.AutoReset);

        // Create and start five numbered threads. Use the
        // ParameterizedThreadStart delegate, so the thread
        // number can be passed as an argument to the Start 
        // method.
        for (int i = 0; i <= 4; i++)
        {
            Thread t = new Thread(
                new ParameterizedThreadStart(ThreadProc)
            );
            t.Start(i);
        }

        // Wait until all the threads have started and blocked.
        // When multiple threads use a 64-bit value on a 32-bit
        // system, you must access the value through the
        // Interlocked class to guarantee thread safety.
        //
        while (Interlocked.Read(ref threadCount) < 5)
        {
            Thread.Sleep(500);
        }

        // Release one thread each time the user presses ENTER,
        // until all threads have been released.
        //
        while (Interlocked.Read(ref threadCount) > 0)
        {
            Console.WriteLine("Press ENTER to release a waiting thread.");
            Console.ReadLine();

            // SignalAndWait signals the EventWaitHandle, which
            // releases exactly one thread before resetting, 
            // because it was created with AutoReset mode. 
            // SignalAndWait then blocks on clearCount, to 
            // allow the signaled thread to decrement the count
            // before looping again.
            //
            WaitHandle.SignalAndWait(ewh, clearCount);
        }
        Console.WriteLine();

        // Create a ManualReset EventWaitHandle.
        //
        ewh = new EventWaitHandle(false, EventResetMode.ManualReset);

        // Create and start five more numbered threads.
        //
        for(int i=0; i<=4; i++)
        {
            Thread t = new Thread(
                new ParameterizedThreadStart(ThreadProc)
            );
            t.Start(i);
        }

        // Wait until all the threads have started and blocked.
        //
        while (Interlocked.Read(ref threadCount) < 5)
        {
            Thread.Sleep(500);
        }

        // Because the EventWaitHandle was created with
        // ManualReset mode, signaling it releases all the
        // waiting threads.
        //
        Console.WriteLine("Press ENTER to release the waiting threads.");
        Console.ReadLine();
        ewh.Set();
    }

    public static void ThreadProc(object data)
    {
        int index = (int) data;

        Console.WriteLine("Thread {0} blocks.", data);
        // Increment the count of blocked threads.
        Interlocked.Increment(ref threadCount);

        // Wait on the EventWaitHandle.
        ewh.WaitOne();

        Console.WriteLine("Thread {0} exits.", data);
        // Decrement the count of blocked threads.
        Interlocked.Decrement(ref threadCount);

        // After signaling ewh, the main thread blocks on
        // clearCount until the signaled thread has 
        // decremented the count. Signal it now.
        //
        clearCount.Set();
    }
}

Imports System.Threading

Public Class Example

    ' The EventWaitHandle used to demonstrate the difference
    ' between AutoReset and ManualReset synchronization events.
    '
    Private Shared ewh As EventWaitHandle

    ' A counter to make sure all threads are started and
    ' blocked before any are released. A Long is used to show
    ' the use of the 64-bit Interlocked methods.
    '
    Private Shared threadCount As Long = 0

    ' An AutoReset event that allows the main thread to block
    ' until an exiting thread has decremented the count.
    '
    Private Shared clearCount As New EventWaitHandle(False, _
        EventResetMode.AutoReset)

    <MTAThread> _
    Public Shared Sub Main()

        ' Create an AutoReset EventWaitHandle.
        '
        ewh = New EventWaitHandle(False, EventResetMode.AutoReset)

        ' Create and start five numbered threads. Use the
        ' ParameterizedThreadStart delegate, so the thread
        ' number can be passed as an argument to the Start 
        ' method.
        For i As Integer = 0 To 4
            Dim t As New Thread(AddressOf ThreadProc)
            t.Start(i)
        Next i

        ' Wait until all the threads have started and blocked.
        ' When multiple threads use a 64-bit value on a 32-bit
        ' system, you must access the value through the
        ' Interlocked class to guarantee thread safety.
        '
        While Interlocked.Read(threadCount) < 5
            Thread.Sleep(500)
        End While

        ' Release one thread each time the user presses ENTER,
        ' until all threads have been released.
        '
        While Interlocked.Read(threadCount) > 0
            Console.WriteLine("Press ENTER to release a waiting thread.")
            Console.ReadLine()

            ' SignalAndWait signals the EventWaitHandle, which
            ' releases exactly one thread before resetting, 
            ' because it was created with AutoReset mode. 
            ' SignalAndWait then blocks on clearCount, to 
            ' allow the signaled thread to decrement the count
            ' before looping again.
            '
            WaitHandle.SignalAndWait(ewh, clearCount)
        End While
        Console.WriteLine()

        ' Create a ManualReset EventWaitHandle.
        '
        ewh = New EventWaitHandle(False, EventResetMode.ManualReset)

        ' Create and start five more numbered threads.
        '
        For i As Integer = 0 To 4
            Dim t As New Thread(AddressOf ThreadProc)
            t.Start(i)
        Next i

        ' Wait until all the threads have started and blocked.
        '
        While Interlocked.Read(threadCount) < 5
            Thread.Sleep(500)
        End While

        ' Because the EventWaitHandle was created with
        ' ManualReset mode, signaling it releases all the
        ' waiting threads.
        '
        Console.WriteLine("Press ENTER to release the waiting threads.")
        Console.ReadLine()
        ewh.Set()
        
    End Sub

    Public Shared Sub ThreadProc(ByVal data As Object)
        Dim index As Integer = CInt(data)

        Console.WriteLine("Thread {0} blocks.", data)
        ' Increment the count of blocked threads.
        Interlocked.Increment(threadCount)

        ' Wait on the EventWaitHandle.
        ewh.WaitOne()

        Console.WriteLine("Thread {0} exits.", data)
        ' Decrement the count of blocked threads.
        Interlocked.Decrement(threadCount)

        ' After signaling ewh, the main thread blocks on
        ' clearCount until the signaled thread has 
        ' decremented the count. Signal it now.
        '
        clearCount.Set()
    End Sub
End Class

Remarques

Si l’état initial de l’événement n’est pas signé, les threads qui attendent l’événement se bloquent. Si l’état initial est signalé et que l’indicateur ManualReset est spécifié pour mode, les threads qui attendent sur l’événement ne se bloquent pas. Si l’état initial est signalé, et mode est AutoReset, le premier thread qui attend l’événement est immédiatement libéré, après quoi l’événement est réinitialisé et les threads suivants se bloquent.

Voir aussi

• Vue d’ensemble des primitives de synchronisation

EventWaitHandle(Boolean, EventResetMode, String)

Source:

EventWaitHandle.cs

Initialise une nouvelle instance de la classe EventWaitHandle, en spécifiant si le handle d'attente est signalé initialement s'il a été créé à la suite de cet appel, s'il se réinitialise automatiquement ou manuellement, ainsi que le nom d'un événement de synchronisation du système.

public:
 EventWaitHandle(bool initialState, System::Threading::EventResetMode mode, System::String ^ name);

public EventWaitHandle (bool initialState, System.Threading.EventResetMode mode, string? name);

new System.Threading.EventWaitHandle : bool * System.Threading.EventResetMode * string -> System.Threading.EventWaitHandle

Public Sub New (initialState As Boolean, mode As EventResetMode, name As String)

Paramètres

initialState

Boolean

true pour définir l’état initial sur signalé si l’événement nommé est créé suite à cet appel ; false pour le définir sur non signalé.

mode

EventResetMode

L’une des valeurs EventResetMode qui détermine si l’événement se réinitialise automatiquement ou manuellement.

name

String

Nom, si l’événement doit être partagé avec d’autres processus ; sinon, null ou une chaîne vide. Le nom respecte la casse. La barre oblique inverse (\) est réservée et ne peut être utilisée que pour spécifier un espace de noms. Pour plus d’informations sur les espaces de noms, consultez la section remarques. Il peut y avoir d’autres restrictions sur le nom en fonction du système d’exploitation. Par exemple, sur les systèmes d’exploitation Unix, le nom après l’exclusion de l’espace de noms doit être un nom de fichier valide.

Exceptions

IOException

name n'est pas valide. Il peut y avoir diverses raisons à cela, notamment des restrictions placées par le système d’exploitation (par exemple, un préfixe inconnu ou des caractères non valides). Notez que le nom et les préfixes communs « Global\ » et « Local\ » respectent la casse.

- ou -

Une autre erreur s’est produite. La propriété HResult est susceptible de fournir plus d’informations.

DirectoryNotFoundException

Windows uniquement : name a spécifié un espace de noms inconnu. Pour plus d’informations, consultez Noms d’objets.

PathTooLongException

name est trop long. Les restrictions de longueur peuvent dépendre du système d’exploitation ou de la configuration.

UnauthorizedAccessException

L’événement nommé existe et a la sécurité de contrôle d’accès, mais l’utilisateur n’a pas FullControl.

WaitHandleCannotBeOpenedException

Il n’est pas possible de créer un objet de synchronisation portant le name fourni. Il est possible qu’un objet de synchronisation d’un autre type possède le même nom.

ArgumentException

La valeur d’énumération mode était en dehors de la plage autorisée.

- ou -

.NET Framework uniquement : name est plus long que MAX_PATH (260 caractères).

Remarques

Le name peut être préfixé avec Global\ ou Local\ pour spécifier un espace de noms. Lorsque l’espace Global de noms est spécifié, l’objet de synchronisation peut être partagé avec n’importe quel processus sur le système. Lorsque l’espace Local de noms est spécifié, qui est également la valeur par défaut quand aucun espace de noms n’est spécifié, l’objet de synchronisation peut être partagé avec des processus dans la même session. Sur Windows, une session est une session de connexion, et les services s’exécutent généralement dans une autre session non interactive. Sur les systèmes d’exploitation de type Unix, chaque interpréteur de commandes a sa propre session. Les objets de synchronisation locale de session peuvent convenir à la synchronisation entre les processus avec une relation parent/enfant où ils s’exécutent tous dans la même session. Pour plus d’informations sur les noms d’objets de synchronisation sur Windows, consultez Noms d’objets.

Si un name est fourni et qu’un objet de synchronisation du type demandé existe déjà dans l’espace de noms, l’objet de synchronisation existant est ouvert. Si un objet de synchronisation d’un type différent existe déjà dans l’espace de noms, un WaitHandleCannotBeOpenedException est levée. Sinon, un nouvel objet de synchronisation est créé.

Si un événement système portant le nom spécifié pour le name paramètre existe déjà, le initialState paramètre est ignoré.

Attention

Par défaut, un événement nommé n’est pas limité à l’utilisateur qui l’a créé. D’autres utilisateurs peuvent être en mesure d’ouvrir et d’utiliser l’événement, notamment en interférant avec l’événement en le définissant ou en le réinitialisant de manière inappropriée. Pour restreindre l’accès à des utilisateurs spécifiques, vous pouvez utiliser une surcharge de constructeur ou EventWaitHandleAcl et passer un lors de la création de EventWaitHandleSecurity l’événement nommé. Évitez d’utiliser des événements nommés sans restrictions d’accès sur les systèmes qui peuvent avoir des utilisateurs non approuvés exécutant du code.

Important

Lorsque vous utilisez ce constructeur pour les événements système nommés, spécifiez false pour initialState. Ce constructeur ne fournit aucun moyen de déterminer si un événement système nommé a été créé. Vous ne pouvez donc pas faire d’hypothèses sur l’état de l’événement nommé. Pour déterminer si un événement nommé a été créé, utilisez le EventWaitHandle(Boolean, EventResetMode, String, Boolean) constructeur ou le EventWaitHandle(Boolean, EventResetMode, String, Boolean, EventWaitHandleSecurity) constructeur.

Si l’état initial de l’événement n’est pas signé, les threads qui attendent l’événement se bloquent. Si l’état initial est signalé et que l’indicateur ManualReset est spécifié pour mode, les threads qui attendent sur l’événement ne se bloquent pas. Si l’état initial est signalé, et mode est AutoReset, le premier thread qui attend l’événement est immédiatement libéré, après quoi l’événement est réinitialisé et les threads suivants se bloquent.

Voir aussi

• Vue d’ensemble des primitives de synchronisation

EventWaitHandle(Boolean, EventResetMode, String, Boolean)

Source:

EventWaitHandle.cs

Initialise une nouvelle instance de la classe EventWaitHandle, spécifiant si le handle d’attente est signalé initialement s’il est créé suite à cet appel, s’il se réinitialise automatiquement ou manuellement, le nom d’un événement de synchronisation du système et une variable booléenne dont la valeur après l’appel indique si l’événement système nommé a été créé.

public:
 EventWaitHandle(bool initialState, System::Threading::EventResetMode mode, System::String ^ name, [Runtime::InteropServices::Out] bool % createdNew);

public EventWaitHandle (bool initialState, System.Threading.EventResetMode mode, string? name, out bool createdNew);

new System.Threading.EventWaitHandle : bool * System.Threading.EventResetMode * string * bool -> System.Threading.EventWaitHandle

Public Sub New (initialState As Boolean, mode As EventResetMode, name As String, ByRef createdNew As Boolean)

Paramètres

initialState

Boolean

true pour définir l’état initial sur signalé si l’événement nommé est créé suite à cet appel ; false pour le définir sur non signalé.

mode

EventResetMode

L’une des valeurs EventResetMode qui détermine si l’événement se réinitialise automatiquement ou manuellement.

name

String

Nom, si l’événement doit être partagé avec d’autres processus ; sinon, null ou une chaîne vide. Le nom respecte la casse. La barre oblique inverse (\) est réservée et ne peut être utilisée que pour spécifier un espace de noms. Pour plus d’informations sur les espaces de noms, consultez la section remarques. Il peut y avoir d’autres restrictions sur le nom en fonction du système d’exploitation. Par exemple, sur les systèmes d’exploitation Unix, le nom après l’exclusion de l’espace de noms doit être un nom de fichier valide.

createdNew

Boolean

Cette méthode retourne true si un événement local a été créé (en d'autres termes, si name est null ou une chaîne vide) ou si l'événement système nommé spécifié a été créé ; false si l'événement système nommé spécifié existait déjà. Ce paramètre est passé sans être initialisé.

Exceptions

IOException

name n'est pas valide. Il peut y avoir diverses raisons à cela, notamment des restrictions placées par le système d’exploitation (par exemple, un préfixe inconnu ou des caractères non valides). Notez que le nom et les préfixes communs « Global\ » et « Local\ » respectent la casse.

- ou -

Une autre erreur s’est produite. La propriété HResult est susceptible de fournir plus d’informations.

DirectoryNotFoundException

Windows uniquement : name a spécifié un espace de noms inconnu. Pour plus d’informations, consultez Noms d’objets.

PathTooLongException

name est trop long. Les restrictions de longueur peuvent dépendre du système d’exploitation ou de la configuration.

UnauthorizedAccessException

L’événement nommé existe et a la sécurité de contrôle d’accès, mais l’utilisateur n’a pas FullControl.

WaitHandleCannotBeOpenedException

Il n’est pas possible de créer un objet de synchronisation portant le name fourni. Il est possible qu’un objet de synchronisation d’un autre type possède le même nom.

ArgumentException

La valeur d’énumération mode était en dehors de la plage autorisée.

- ou -

.NET Framework uniquement : name est plus long que MAX_PATH (260 caractères).

Remarques

Le name peut être préfixé avec Global\ ou Local\ pour spécifier un espace de noms. Lorsque l’espace Global de noms est spécifié, l’objet de synchronisation peut être partagé avec n’importe quel processus sur le système. Lorsque l’espace Local de noms est spécifié, qui est également la valeur par défaut lorsqu’aucun espace de noms n’est spécifié, l’objet de synchronisation peut être partagé avec des processus dans la même session. Sur Windows, une session est une session de connexion et les services s’exécutent généralement dans une autre session non interactive. Sur les systèmes d’exploitation de type Unix, chaque interpréteur de commandes a sa propre session. Les objets de synchronisation locale de session peuvent convenir à la synchronisation entre des processus avec une relation parent/enfant où ils s’exécutent tous dans la même session. Pour plus d’informations sur les noms d’objets de synchronisation sur Windows, consultez Noms d’objets.

Si un name est fourni et qu’un objet de synchronisation du type demandé existe déjà dans l’espace de noms, l’objet de synchronisation existant est ouvert. Si un objet de synchronisation d’un autre type existe déjà dans l’espace de noms, un WaitHandleCannotBeOpenedException est levée. Sinon, un nouvel objet de synchronisation est créé.

Si un événement système portant le nom spécifié pour le name paramètre existe déjà, le initialState paramètre est ignoré. Après avoir appelé ce constructeur, utilisez la valeur dans la variable spécifiée pour le ref paramètre (ByRef paramètre en Visual Basic)createdNew pour déterminer si l’événement système nommé existait déjà ou a été créé.

Si l’état initial de l’événement n’est pas signé, les threads qui attendent sur l’événement sont bloqués. Si l’état initial est signalé et que l’indicateur ManualReset est spécifié pour mode, les threads qui attendent sur l’événement ne bloquent pas. Si l’état initial est signalé et mode est AutoReset, le premier thread qui attend l’événement est immédiatement libéré, après quoi l’événement est réinitialisé et les threads suivants sont bloqués.

Attention

Par défaut, un événement nommé n’est pas limité à l’utilisateur qui l’a créé. D’autres utilisateurs peuvent ouvrir et utiliser l’événement, notamment en interférant avec l’événement en le définissant ou en le réinitialisant de manière inappropriée. Pour restreindre l’accès à des utilisateurs spécifiques, vous pouvez utiliser une surcharge de constructeur ou EventWaitHandleAcl et passer un lors de la création de EventWaitHandleSecurity l’événement nommé. Évitez d’utiliser des événements nommés sans restrictions d’accès sur les systèmes qui peuvent avoir des utilisateurs non approuvés exécutant du code.

Voir aussi

• Vue d’ensemble des primitives de synchronisation