EventWaitHandle Constructeurs

Définition

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, String, Boolean, EventWaitHandleSecurity)

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éé, et la sécurité de contrôle d’accès à appliquer à l’événement nommé s’il est créé.

EventWaitHandle(Boolean, EventResetMode)

Source:
EventWaitHandle.cs
Source:
EventWaitHandle.cs
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

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

S’applique à

EventWaitHandle(Boolean, EventResetMode, String)

Source:
EventWaitHandle.cs
Source:
EventWaitHandle.cs
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);
[System.Security.SecurityCritical]
public EventWaitHandle (bool initialState, System.Threading.EventResetMode mode, string name);
public EventWaitHandle (bool initialState, System.Threading.EventResetMode mode, string? name);
public EventWaitHandle (bool initialState, System.Threading.EventResetMode mode, string name);
[<System.Security.SecurityCritical>]
new System.Threading.EventWaitHandle : bool * System.Threading.EventResetMode * string -> System.Threading.EventWaitHandle
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.

Attributs

Exceptions

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.

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

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

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

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.

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

S’applique à

EventWaitHandle(Boolean, EventResetMode, String, Boolean)

Source:
EventWaitHandle.cs
Source:
EventWaitHandle.cs
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);
[System.Security.SecurityCritical]
public EventWaitHandle (bool initialState, System.Threading.EventResetMode mode, string name, out bool createdNew);
public EventWaitHandle (bool initialState, System.Threading.EventResetMode mode, string? name, out bool createdNew);
public EventWaitHandle (bool initialState, System.Threading.EventResetMode mode, string name, out bool createdNew);
[<System.Security.SecurityCritical>]
new System.Threading.EventWaitHandle : bool * System.Threading.EventResetMode * string * bool -> System.Threading.EventWaitHandle
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é.

Attributs

Exceptions

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.

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

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

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

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.

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

S’applique à

EventWaitHandle(Boolean, EventResetMode, String, Boolean, EventWaitHandleSecurity)

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éé, et la sécurité de contrôle d’accès à appliquer à l’événement nommé s’il est créé.

public:
 EventWaitHandle(bool initialState, System::Threading::EventResetMode mode, System::String ^ name, [Runtime::InteropServices::Out] bool % createdNew, System::Security::AccessControl::EventWaitHandleSecurity ^ eventSecurity);
public EventWaitHandle (bool initialState, System.Threading.EventResetMode mode, string name, out bool createdNew, System.Security.AccessControl.EventWaitHandleSecurity eventSecurity);
[System.Security.SecurityCritical]
public EventWaitHandle (bool initialState, System.Threading.EventResetMode mode, string name, out bool createdNew, System.Security.AccessControl.EventWaitHandleSecurity eventSecurity);
new System.Threading.EventWaitHandle : bool * System.Threading.EventResetMode * string * bool * System.Security.AccessControl.EventWaitHandleSecurity -> System.Threading.EventWaitHandle
[<System.Security.SecurityCritical>]
new System.Threading.EventWaitHandle : bool * System.Threading.EventResetMode * string * bool * System.Security.AccessControl.EventWaitHandleSecurity -> System.Threading.EventWaitHandle
Public Sub New (initialState As Boolean, mode As EventResetMode, name As String, ByRef createdNew As Boolean, eventSecurity As EventWaitHandleSecurity)

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. Le caractère de barre oblique inverse (\) est réservé et ne peut être utilisé 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é.

eventSecurity
EventWaitHandleSecurity

Objet EventWaitHandleSecurity qui représente la sécurité de contrôle d’accès à appliquer à l’événement système nommé.

Attributs

Exceptions

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 -

Il y a eu une autre erreur. La propriété HResult est susceptible de fournir plus d’informations.

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

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

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

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.

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).

Exemples

L’exemple de code suivant illustre le comportement inter-processus d’un événement système nommé avec la sécurité du contrôle d’accès. L’exemple utilise la OpenExisting(String) surcharge de méthode pour tester l’existence d’un événement nommé.

Si l’événement n’existe pas, il est créé avec la propriété initiale et la sécurité de contrôle d’accès qui refuse à l’utilisateur actuel le droit d’utiliser l’événement, mais accorde le droit de lire et de modifier les autorisations sur l’événement.

Si vous exécutez l’exemple compilé à partir de deux fenêtres de commande, la deuxième copie lève une exception de violation d’accès lors de l’appel à OpenExisting(String). L’exception est interceptée et l’exemple utilise la OpenExisting(String, EventWaitHandleRights) surcharge de méthode pour attendre l’événement avec les droits nécessaires pour lire et modifier les autorisations.

Une fois les autorisations modifiées, l’événement est ouvert avec les droits nécessaires pour attendre et le signaler. Si vous exécutez l’exemple compilé à partir d’une troisième fenêtre de commande, l’exemple s’exécute à l’aide des nouvelles autorisations.

using namespace System;
using namespace System::Threading;
using namespace System::Security::AccessControl;
using namespace System::Security::Permissions;

public ref class Example
{
public:
   [SecurityPermissionAttribute(SecurityAction::Demand,Flags=SecurityPermissionFlag::UnmanagedCode)]
   static void Main()
   {
      String^ ewhName = L"EventWaitHandleExample5";

      EventWaitHandle^ ewh = nullptr;
      bool doesNotExist = false;
      bool unauthorized = false;
      
      // The value of this variable is set by the event
      // constructor. It is true if the named system event was
      // created, and false if the named event already existed.
      //
      bool wasCreated;
      
      // Attempt to open the named event.
      try
      {
         // Open the event with (EventWaitHandleRights.Synchronize
         // | EventWaitHandleRights.Modify), to wait on and
         // signal the named event.
         //
         ewh = EventWaitHandle::OpenExisting( ewhName );
      }
      catch ( WaitHandleCannotBeOpenedException^ ) 
      {
         Console::WriteLine( L"Named event does not exist." );
         doesNotExist = true;
      }
      catch ( UnauthorizedAccessException^ ex ) 
      {
         Console::WriteLine( L"Unauthorized access: {0}", ex->Message );
         unauthorized = true;
      }

      // There are three cases: (1) The event does not exist.
      // (2) The event exists, but the current user doesn't
      // have access. (3) The event exists and the user has
      // access.
      //
      if ( doesNotExist )
      {
         // The event does not exist, so create it.

         // Create an access control list (ACL) that denies the
         // current user the right to wait on or signal the
         // event, but allows the right to read and change
         // security information for the event.
         //
         String^ user = String::Concat( Environment::UserDomainName, L"\\",
            Environment::UserName );
         EventWaitHandleSecurity^ ewhSec = gcnew EventWaitHandleSecurity;
         //following constructor fails
         EventWaitHandleAccessRule^ rule = gcnew EventWaitHandleAccessRule(
            user,
            static_cast<EventWaitHandleRights>(
               EventWaitHandleRights::Synchronize | 
               EventWaitHandleRights::Modify),
            AccessControlType::Deny );
         ewhSec->AddAccessRule( rule );

         rule = gcnew EventWaitHandleAccessRule( user,
            static_cast<EventWaitHandleRights>(
               EventWaitHandleRights::ReadPermissions | 
               EventWaitHandleRights::ChangePermissions),
            AccessControlType::Allow );
         ewhSec->AddAccessRule( rule );
         
         // Create an EventWaitHandle object that represents
         // the system event named by the constant 'ewhName',
         // initially signaled, with automatic reset, and with
         // the specified security access. The Boolean value that
         // indicates creation of the underlying system object
         // is placed in wasCreated.
         //
         ewh = gcnew EventWaitHandle( true,
            EventResetMode::AutoReset,
            ewhName,
            wasCreated,
            ewhSec );
         
         // If the named system event was created, it can be
         // used by the current instance of this program, even
         // though the current user is denied access. The current
         // program owns the event. Otherwise, exit the program.
         //
         if ( wasCreated )
         {
            Console::WriteLine( L"Created the named event." );
         }
         else
         {
            Console::WriteLine( L"Unable to create the event." );
            return;
         }
      }
      else if ( unauthorized )
      {
         // Open the event to read and change the access control
         // security. The access control security defined above
         // allows the current user to do this.
         //
         try
         {
            ewh = EventWaitHandle::OpenExisting( ewhName, 
               static_cast<EventWaitHandleRights>(
                  EventWaitHandleRights::ReadPermissions |
                  EventWaitHandleRights::ChangePermissions) );
            
            // Get the current ACL. This requires
            // EventWaitHandleRights.ReadPermissions.
            EventWaitHandleSecurity^ ewhSec = ewh->GetAccessControl();
            String^ user = String::Concat( Environment::UserDomainName, L"\\",
               Environment::UserName );
            
            // First, the rule that denied the current user
            // the right to enter and release the event must
            // be removed.
            EventWaitHandleAccessRule^ rule = gcnew EventWaitHandleAccessRule(
               user,
               static_cast<EventWaitHandleRights>(
                  EventWaitHandleRights::Synchronize |
                  EventWaitHandleRights::Modify),
               AccessControlType::Deny );
            ewhSec->RemoveAccessRule( rule );
            
            // Now grant the user the correct rights.
            //
            rule = gcnew EventWaitHandleAccessRule( user,
               static_cast<EventWaitHandleRights>(
                  EventWaitHandleRights::Synchronize |
                  EventWaitHandleRights::Modify),
               AccessControlType::Allow );
            ewhSec->AddAccessRule( rule );
            
            // Update the ACL. This requires
            // EventWaitHandleRights.ChangePermissions.
            ewh->SetAccessControl( ewhSec );
            Console::WriteLine( L"Updated event security." );
            
            // Open the event with (EventWaitHandleRights.Synchronize
            // | EventWaitHandleRights.Modify), the rights required
            // to wait on and signal the event.
            //
            ewh = EventWaitHandle::OpenExisting( ewhName );
         }
         catch ( UnauthorizedAccessException^ ex ) 
         {
            Console::WriteLine( L"Unable to change permissions: {0}",
               ex->Message );
            return;
         }

      }
      
      // Wait on the event, and hold it until the program
      // exits.
      //
      try
      {
         Console::WriteLine( L"Wait on the event." );
         ewh->WaitOne();
         Console::WriteLine( L"Event was signaled." );
         Console::WriteLine( L"Press the Enter key to signal the event and exit." );
         Console::ReadLine();
      }
      catch ( UnauthorizedAccessException^ ex ) 
      {
         Console::WriteLine( L"Unauthorized access: {0}", ex->Message );
      }
      finally
      {
         ewh->Set();
      }
   }
};

int main()
{
   Example::Main();
}
using System;
using System.Threading;
using System.Security.AccessControl;

internal class Example
{
    internal static void Main()
    {
        const string ewhName = "EventWaitHandleExample5";

        EventWaitHandle ewh = null;
        bool doesNotExist = false;
        bool unauthorized = false;

        // The value of this variable is set by the event
        // constructor. It is true if the named system event was
        // created, and false if the named event already existed.
        //
        bool wasCreated;

        // Attempt to open the named event.
        try
        {
            // Open the event with (EventWaitHandleRights.Synchronize
            // | EventWaitHandleRights.Modify), to wait on and 
            // signal the named event.
            //
            ewh = EventWaitHandle.OpenExisting(ewhName);
        }
        catch (WaitHandleCannotBeOpenedException)
        {
            Console.WriteLine("Named event does not exist.");
            doesNotExist = true;
        }
        catch (UnauthorizedAccessException ex)
        {
            Console.WriteLine("Unauthorized access: {0}", ex.Message);
            unauthorized = true;
        }

        // There are three cases: (1) The event does not exist.
        // (2) The event exists, but the current user doesn't 
        // have access. (3) The event exists and the user has
        // access.
        //
        if (doesNotExist)
        {
            // The event does not exist, so create it.

            // Create an access control list (ACL) that denies the
            // current user the right to wait on or signal the 
            // event, but allows the right to read and change
            // security information for the event.
            //
            string user = Environment.UserDomainName + "\\"
                + Environment.UserName;
            EventWaitHandleSecurity ewhSec = 
                new EventWaitHandleSecurity();

            EventWaitHandleAccessRule rule = 
                new EventWaitHandleAccessRule(user, 
                    EventWaitHandleRights.Synchronize | 
                    EventWaitHandleRights.Modify, 
                    AccessControlType.Deny);
            ewhSec.AddAccessRule(rule);

            rule = new EventWaitHandleAccessRule(user, 
                EventWaitHandleRights.ReadPermissions | 
                EventWaitHandleRights.ChangePermissions, 
                AccessControlType.Allow);
            ewhSec.AddAccessRule(rule);

            // Create an EventWaitHandle object that represents
            // the system event named by the constant 'ewhName', 
            // initially signaled, with automatic reset, and with
            // the specified security access. The Boolean value that 
            // indicates creation of the underlying system object
            // is placed in wasCreated.
            //
            ewh = new EventWaitHandle(true, 
                EventResetMode.AutoReset, 
                ewhName, 
                out wasCreated, 
                ewhSec);

            // If the named system event was created, it can be
            // used by the current instance of this program, even 
            // though the current user is denied access. The current
            // program owns the event. Otherwise, exit the program.
            // 
            if (wasCreated)
            {
                Console.WriteLine("Created the named event.");
            }
            else
            {
                Console.WriteLine("Unable to create the event.");
                return;
            }
        }
        else if (unauthorized)
        {
            // Open the event to read and change the access control
            // security. The access control security defined above
            // allows the current user to do this.
            //
            try
            {
                ewh = EventWaitHandle.OpenExisting(ewhName, 
                    EventWaitHandleRights.ReadPermissions | 
                    EventWaitHandleRights.ChangePermissions);

                // Get the current ACL. This requires 
                // EventWaitHandleRights.ReadPermissions.
                EventWaitHandleSecurity ewhSec = ewh.GetAccessControl();
                
                string user = Environment.UserDomainName + "\\"
                    + Environment.UserName;

                // First, the rule that denied the current user 
                // the right to enter and release the event must
                // be removed.
                EventWaitHandleAccessRule rule = 
                    new EventWaitHandleAccessRule(user, 
                        EventWaitHandleRights.Synchronize | 
                        EventWaitHandleRights.Modify, 
                        AccessControlType.Deny);
                ewhSec.RemoveAccessRule(rule);

                // Now grant the user the correct rights.
                // 
                rule = new EventWaitHandleAccessRule(user, 
                    EventWaitHandleRights.Synchronize | 
                    EventWaitHandleRights.Modify, 
                    AccessControlType.Allow);
                ewhSec.AddAccessRule(rule);

                // Update the ACL. This requires
                // EventWaitHandleRights.ChangePermissions.
                ewh.SetAccessControl(ewhSec);

                Console.WriteLine("Updated event security.");

                // Open the event with (EventWaitHandleRights.Synchronize 
                // | EventWaitHandleRights.Modify), the rights required
                // to wait on and signal the event.
                //
                ewh = EventWaitHandle.OpenExisting(ewhName);
            }
            catch (UnauthorizedAccessException ex)
            {
                Console.WriteLine("Unable to change permissions: {0}",
                    ex.Message);
                return;
            }
        }

        // Wait on the event, and hold it until the program
        // exits.
        //
        try
        {
            Console.WriteLine("Wait on the event.");
            ewh.WaitOne();
            Console.WriteLine("Event was signaled.");
            Console.WriteLine("Press the Enter key to signal the event and exit.");
            Console.ReadLine();
        }
        catch (UnauthorizedAccessException ex)
        {
            Console.WriteLine("Unauthorized access: {0}", ex.Message);
        }
        finally
        {
            ewh.Set();
        }
    }
}
Imports System.Threading
Imports System.Security.AccessControl

Friend Class Example

    <MTAThread> _
    Friend Shared Sub Main()
        Const ewhName As String = "EventWaitHandleExample5"

        Dim ewh As EventWaitHandle = Nothing
        Dim doesNotExist as Boolean = False
        Dim unauthorized As Boolean = False

        ' The value of this variable is set by the event
        ' constructor. It is True if the named system event was
        ' created, and False if the named event already existed.
        '
        Dim wasCreated As Boolean

        ' Attempt to open the named event.
        Try
            ' Open the event with (EventWaitHandleRights.Synchronize
            ' Or EventWaitHandleRights.Modify), to wait on and 
            ' signal the named event.
            '
            ewh = EventWaitHandle.OpenExisting(ewhName)
        Catch ex As WaitHandleCannotBeOpenedException
            Console.WriteLine("Named event does not exist.")
            doesNotExist = True
        Catch ex As UnauthorizedAccessException
            Console.WriteLine("Unauthorized access: {0}", ex.Message)
            unauthorized = True
        End Try

        ' There are three cases: (1) The event does not exist.
        ' (2) The event exists, but the current user doesn't 
        ' have access. (3) The event exists and the user has
        ' access.
        '
        If doesNotExist Then
            ' The event does not exist, so create it.

            ' Create an access control list (ACL) that denies the
            ' current user the right to wait on or signal the 
            ' event, but allows the right to read and change
            ' security information for the event.
            '
            Dim user As String = Environment.UserDomainName _ 
                & "\" & Environment.UserName
            Dim ewhSec As New EventWaitHandleSecurity()

            Dim rule As New EventWaitHandleAccessRule(user, _
                EventWaitHandleRights.Synchronize Or _
                EventWaitHandleRights.Modify, _
                AccessControlType.Deny)
            ewhSec.AddAccessRule(rule)

            rule = New EventWaitHandleAccessRule(user, _
                EventWaitHandleRights.ReadPermissions Or _
                EventWaitHandleRights.ChangePermissions, _
                AccessControlType.Allow)
            ewhSec.AddAccessRule(rule)

            ' Create an EventWaitHandle object that represents
            ' the system event named by the constant 'ewhName', 
            ' initially signaled, with automatic reset, and with
            ' the specified security access. The Boolean value that 
            ' indicates creation of the underlying system object
            ' is placed in wasCreated.
            '
            ewh = New EventWaitHandle(True, _
                EventResetMode.AutoReset, ewhName, _
                wasCreated, ewhSec)

            ' If the named system event was created, it can be
            ' used by the current instance of this program, even 
            ' though the current user is denied access. The current
            ' program owns the event. Otherwise, exit the program.
            ' 
            If wasCreated Then
                Console.WriteLine("Created the named event.")
            Else
                Console.WriteLine("Unable to create the event.")
                Return
            End If

        ElseIf unauthorized Then

            ' Open the event to read and change the access control
            ' security. The access control security defined above
            ' allows the current user to do this.
            '
            Try
                ewh = EventWaitHandle.OpenExisting(ewhName, _
                    EventWaitHandleRights.ReadPermissions Or _
                    EventWaitHandleRights.ChangePermissions)

                ' Get the current ACL. This requires 
                ' EventWaitHandleRights.ReadPermissions.
                Dim ewhSec As EventWaitHandleSecurity = _
                    ewh.GetAccessControl()
                
                Dim user As String = Environment.UserDomainName _ 
                    & "\" & Environment.UserName

                ' First, the rule that denied the current user 
                ' the right to enter and release the event must
                ' be removed.
                Dim rule As New EventWaitHandleAccessRule(user, _
                    EventWaitHandleRights.Synchronize Or _
                    EventWaitHandleRights.Modify, _
                    AccessControlType.Deny)
                ewhSec.RemoveAccessRule(rule)

                ' Now grant the user the correct rights.
                ' 
                rule = New EventWaitHandleAccessRule(user, _
                    EventWaitHandleRights.Synchronize Or _
                    EventWaitHandleRights.Modify, _
                    AccessControlType.Allow)
                ewhSec.AddAccessRule(rule)

                ' Update the ACL. This requires
                ' EventWaitHandleRights.ChangePermissions.
                ewh.SetAccessControl(ewhSec)

                Console.WriteLine("Updated event security.")

                ' Open the event with (EventWaitHandleRights.Synchronize 
                ' Or EventWaitHandleRights.Modify), the rights required
                ' to wait on and signal the event.
                '
                ewh = EventWaitHandle.OpenExisting(ewhName)

            Catch ex As UnauthorizedAccessException
                Console.WriteLine("Unable to change permissions: {0}", _
                    ex.Message)
                Return
            End Try

        End If

        ' Wait on the event, and hold it until the program
        ' exits.
        '
        Try
            Console.WriteLine("Wait on the event.")
            ewh.WaitOne()
            Console.WriteLine("Event was signaled.")
            Console.WriteLine("Press the Enter key to signal the event and exit.")
            Console.ReadLine()
        Catch ex As UnauthorizedAccessException
            Console.WriteLine("Unauthorized access: {0}", _
                ex.Message)
        Finally
            ewh.Set()
        End Try
    End Sub 
End Class

Remarques

Utilisez ce constructeur pour appliquer la sécurité du contrôle d’accès à un événement système nommé lors de sa création, ce qui empêche d’autres codes de prendre le contrôle de l’événement.

Ce constructeur initialise un EventWaitHandle objet qui représente un événement système. Vous pouvez créer plusieurs EventWaitHandle objets qui représentent le même événement système.

Si l’événement système n’existe pas, il est créé avec la sécurité de contrôle d’accès spécifiée. Si l’événement existe, la sécurité de contrôle d’accès spécifiée est ignorée.

Notes

L’appelant a un contrôle total sur l’objet nouvellement créé EventWaitHandle , même si eventSecurity refuse ou ne parvient pas à accorder certains droits d’accès à l’utilisateur actuel. Toutefois, si l’utilisateur actuel tente d’obtenir un autre EventWaitHandle objet pour représenter le même événement nommé, à l’aide d’un constructeur ou de la méthode, la OpenExisting sécurité du contrôle d’accès Windows est appliquée.

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 passer un EventWaitHandleSecurity lors de la création de 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

S’applique à