EventWaitHandle Costruttori

Riferimento

Definizione

Spazio dei nomi:: System.Threading

Assembly:: System.Threading.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Inizializza una nuova istanza della classe EventWaitHandle.

Overload

EventWaitHandle(Boolean, EventResetMode)	Inizializza una nuova istanza della classe EventWaitHandle, specificando se l'handle di attesa è inizialmente segnalato e se la reimpostazione viene eseguita automaticamente o manualmente.
EventWaitHandle(Boolean, EventResetMode, String)	Inizializza una nuova istanza della classe EventWaitHandle, specificando se l'handle di attesa è inizialmente segnalato se creato a seguito di questa chiamata e se la reimpostazione viene eseguita automaticamente o manualmente e indicando il nome di un evento di sincronizzazione di sistema.
EventWaitHandle(Boolean, EventResetMode, String, Boolean)	Inizializza una nuova istanza della classe EventWaitHandle, che specifica se l'handle di attesa viene inizialmente segnalato se creato in seguito alla chiamata, se viene reimpostato automaticamente o manualmente, nonché il nome di un evento di sincronizzazione di sistema e una variabile Boolean il cui valore dopo la chiamata indica se è stato creato l'evento di sistema denominato.
EventWaitHandle(Boolean, EventResetMode, String, Boolean, EventWaitHandleSecurity)	Inizializza una nuova istanza della classe EventWaitHandle, che specifica se l'handle di attesa viene inizialmente segnalato se creato in seguito alla chiamata, se viene reimpostato automaticamente o manualmente, nonché il nome di un evento di sincronizzazione di sistema, una variabile Boolean il cui valore dopo la chiamata indica se è stato creato l'evento di sistema denominato e la sicurezza del controllo di accesso da applicare all'evento denominato, se è stato creato.

EventWaitHandle(Boolean, EventResetMode)

Origine:: EventWaitHandle.cs

Origine:: EventWaitHandle.cs

Origine:: EventWaitHandle.cs

Inizializza una nuova istanza della classe EventWaitHandle, specificando se l'handle di attesa è inizialmente segnalato e se la reimpostazione viene eseguita automaticamente o manualmente.

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)

Parametri

initialState: Boolean

true per impostare lo stato iniziale su segnalato; false per impostarlo su non segnalato.

mode: EventResetMode

Ottiene uno dei valori di EventResetMode che determina se l'evento viene reimpostato manualmente o automaticamente.

Eccezioni

ArgumentException

Il valore enum mode non è compreso nell'intervallo consentito.

Esempio

Nell'esempio di codice seguente viene usato l'overload del SignalAndWait(WaitHandle, WaitHandle) metodo per consentire al thread principale di segnalare un thread bloccato e quindi attendere il completamento di un'attività da parte del thread.

L'esempio avvia cinque thread e consente di bloccarsi su un EventWaitHandle oggetto creato con il EventResetMode.AutoReset flag, quindi rilascia un thread ogni volta che l'utente preme il tasto INVIO . L'esempio accoda quindi altri cinque thread e li rilascia tutti usando un EventWaitHandle oggetto creato con il EventResetMode.ManualReset flag .

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

Commenti

Se lo stato iniziale dell'evento non è firmato, i thread che attendono l'evento verranno bloccati. Se lo stato iniziale viene segnalato e il ManualReset flag viene specificato per mode, i thread che attendono l'evento non verranno bloccati. Se lo stato iniziale viene segnalato e mode è AutoReset, il primo thread che attende l'evento verrà rilasciato immediatamente, dopo il quale l'evento verrà reimpostato e i thread successivi verranno bloccati.

Vedi anche

Panoramica delle primitive di sincronizzazione

Si applica a

EventWaitHandle(Boolean, EventResetMode, String)

Origine:: EventWaitHandle.cs

Origine:: EventWaitHandle.cs

Origine:: EventWaitHandle.cs

Inizializza una nuova istanza della classe EventWaitHandle, specificando se l'handle di attesa è inizialmente segnalato se creato a seguito di questa chiamata e se la reimpostazione viene eseguita automaticamente o manualmente e indicando il nome di un evento di sincronizzazione di sistema.

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)

Parametri

initialState: Boolean

true per impostare lo stato iniziale su segnalato se l'evento denominato viene creato come risultato della chiamata; false per impostarlo su non segnalato.

mode: EventResetMode

Ottiene uno dei valori di EventResetMode che determina se l'evento viene reimpostato manualmente o automaticamente.

name: String

Il nome, se l'oggetto di sincronizzazione deve essere condiviso con altri processi; in caso contrario null o una stringa vuota. Per il nome è prevista la distinzione tra maiuscole e minuscole. Il carattere barra rovesciata (\) è riservato e può essere usato solo per specificare uno spazio dei nomi. Per altre informazioni sugli spazi dei nomi, vedere la sezione osservazioni. Potrebbero esserci ulteriori restrizioni per il nome a seconda del sistema operativo. Ad esempio, nei sistemi operativi basati su Unix, il nome dopo l'esclusione dello spazio dei nomi deve essere un nome file valido.

Attributi: SecurityCriticalAttribute

Eccezioni

IOException

name non è valido. I motivi possono essere diversi, e tra questi limitazioni implementate dal sistema operativo, come prefisso sconosciuto o caratteri non validi. Si noti che il nome e i prefissi comuni "Global\" e "Local\" fanno distinzione tra maiuscole e minuscole.

-oppure-

Si è verificato un altro errore. È possibile che la proprietà HResult offra ulteriori informazioni.

DirectoryNotFoundException

Solo Windows: name ha specificato uno spazio dei nomi sconosciuto. Per altre informazioni, vedere Object Names (Nomi oggetti).

PathTooLongException

name supera la lunghezza consentita. Le limitazioni di lunghezza possono dipendere dal sistema operativo o dalla configurazione.

UnauthorizedAccessException

L'evento denominato esiste e include sicurezza del controllo di accesso, ma l'utente non ha FullControl.

WaitHandleCannotBeOpenedException

Non è possibile creare un oggetto di sincronizzazione con l'elemento name specificato. Un oggetto di sincronizzazione di un tipo diverso potrebbe avere lo stesso nome.

ArgumentException

Il valore enum mode non è compreso nell'intervallo consentito.

-oppure-

Solo .NET Framework: la lunghezza di name supera MAX_PATH (260 caratteri).

Commenti

Può name essere preceduto Global\ da o Local\ per specificare uno spazio dei nomi. Quando si specifica lo Global spazio dei nomi, l'oggetto di sincronizzazione può essere condiviso con tutti i processi nel sistema. Quando si specifica lo Local spazio dei nomi , che è anche l'impostazione predefinita quando non viene specificato alcuno spazio dei nomi, l'oggetto di sincronizzazione può essere condiviso con i processi nella stessa sessione. In Windows, una sessione è una sessione di accesso e i servizi vengono in genere eseguiti in una sessione diversa non interattiva. Nei sistemi operativi simili a Unix, ogni shell ha una sessione specifica. Gli oggetti di sincronizzazione locale della sessione possono essere appropriati per la sincronizzazione tra processi con una relazione padre/figlio in cui vengono eseguiti tutti nella stessa sessione. Per altre informazioni sui nomi degli oggetti di sincronizzazione in Windows, vedere Nomi di oggetti.

Se viene specificato un name oggetto e un oggetto di sincronizzazione del tipo richiesto esiste già nello spazio dei nomi, viene aperto l'oggetto di sincronizzazione esistente. Se nello spazio dei nomi esiste già un oggetto di sincronizzazione di un tipo diverso, viene generata un'eccezione WaitHandleCannotBeOpenedException . In caso contrario, viene creato un nuovo oggetto di sincronizzazione.

Se esiste già un evento di sistema con il nome specificato per il name parametro , il initialState parametro viene ignorato.

Attenzione

Per impostazione predefinita, un evento denominato non è limitato all'utente che lo ha creato. Altri utenti possono essere in grado di aprire e usare l'evento, inclusa l'interferenza con l'evento impostandola o reimpostandola in modo inappropriato. Per limitare l'accesso a utenti specifici, è possibile usare un overload del costruttore o EventWaitHandleAcl passare un oggetto EventWaitHandleSecurity durante la creazione dell'evento denominato. Evitare di usare eventi denominati senza restrizioni di accesso nei sistemi che potrebbero avere utenti non attendibili che eseguono codice.

Importante

Quando si usa questo costruttore per gli eventi di sistema denominati, specificare false per initialState. Questo costruttore non consente di determinare se è stato creato un evento di sistema denominato, pertanto non è possibile fare ipotesi sullo stato dell'evento denominato. Per determinare se è stato creato un evento denominato, usare il EventWaitHandle(Boolean, EventResetMode, String, Boolean) costruttore o il EventWaitHandle(Boolean, EventResetMode, String, Boolean, EventWaitHandleSecurity) costruttore .

Vedi anche

Panoramica delle primitive di sincronizzazione

Si applica a

EventWaitHandle(Boolean, EventResetMode, String, Boolean)

Origine:: EventWaitHandle.cs

Origine:: EventWaitHandle.cs

Origine:: EventWaitHandle.cs

Inizializza una nuova istanza della classe EventWaitHandle, che specifica se l'handle di attesa viene inizialmente segnalato se creato in seguito alla chiamata, se viene reimpostato automaticamente o manualmente, nonché il nome di un evento di sincronizzazione di sistema e una variabile Boolean il cui valore dopo la chiamata indica se è stato creato l'evento di sistema denominato.

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)

Parametri

initialState: Boolean

true per impostare lo stato iniziale su segnalato se l'evento denominato viene creato come risultato della chiamata; false per impostarlo su non segnalato.

mode: EventResetMode

Ottiene uno dei valori di EventResetMode che determina se l'evento viene reimpostato manualmente o automaticamente.

name: String

createdNew: Boolean

Quando questo metodo viene restituito, contiene true se è stato creato un evento locale (ovvero, se il valore di name è null o una stringa vuota) oppure se è stato creato l'evento di sistema denominato specificato; false se l'evento di sistema denominato specificato è già esistente. Questo parametro viene passato non inizializzato.

Attributi: SecurityCriticalAttribute

Eccezioni

IOException

-oppure-

Si è verificato un altro errore. È possibile che la proprietà HResult offra ulteriori informazioni.

DirectoryNotFoundException

Solo Windows: name ha specificato uno spazio dei nomi sconosciuto. Per altre informazioni, vedere Object Names (Nomi oggetti).

PathTooLongException

name supera la lunghezza consentita. Le limitazioni di lunghezza possono dipendere dal sistema operativo o dalla configurazione.

UnauthorizedAccessException

L'evento denominato esiste e include sicurezza del controllo di accesso, ma l'utente non ha FullControl.

WaitHandleCannotBeOpenedException

Non è possibile creare un oggetto di sincronizzazione con l'elemento name specificato. Un oggetto di sincronizzazione di un tipo diverso potrebbe avere lo stesso nome.

ArgumentException

Il valore enum mode non è compreso nell'intervallo consentito.

-oppure-

Solo .NET Framework: la lunghezza di name supera MAX_PATH (260 caratteri).

Commenti

Può name essere preceduto Global\ da o Local\ per specificare uno spazio dei nomi. Quando viene specificato lo spazio dei nomi, l'oggetto Global di sincronizzazione può essere condiviso con tutti i processi nel sistema. Quando viene specificato lo Local spazio dei nomi, che è anche il valore predefinito quando non viene specificato alcun spazio dei nomi, l'oggetto di sincronizzazione può essere condiviso con i processi nella stessa sessione. In Windows una sessione è una sessione di accesso e i servizi vengono in genere eseguiti in una sessione non interattiva diversa. Nei sistemi operativi Unix, ogni shell ha la propria sessione. Gli oggetti di sincronizzazione locale della sessione possono essere appropriati per la sincronizzazione tra processi con una relazione padre/figlio in cui vengono eseguiti tutti nella stessa sessione. Per altre informazioni sui nomi degli oggetti di sincronizzazione in Windows, vedere Nomi oggetti.

Se viene specificato un name oggetto di sincronizzazione del tipo richiesto esiste già nello spazio dei nomi, viene aperto l'oggetto di sincronizzazione esistente. Se esiste già un oggetto di sincronizzazione di un tipo diverso nello spazio dei nomi, viene generato un WaitHandleCannotBeOpenedException oggetto di sincronizzazione. In caso contrario, viene creato un nuovo oggetto di sincronizzazione.

Se esiste già un evento di sistema con il nome specificato per il name parametro, il initialState parametro viene ignorato. Dopo aver chiamato questo costruttore, usare il valore nella variabile specificata per il ref parametro (ByRef parametro in Visual Basic)createdNew per determinare se l'evento di sistema denominato esiste già o è stato creato.

Se lo stato iniziale dell'evento non è firmato, i thread in attesa dell'evento verranno bloccati. Se lo stato iniziale viene segnalato e il ManualReset flag viene specificato per mode, i thread in attesa dell'evento non verranno bloccati. Se lo stato iniziale viene segnalato ed mode è AutoReset, il primo thread che attende l'evento verrà rilasciato immediatamente, dopo il quale l'evento verrà reimpostato e i thread successivi verranno bloccati.

Attenzione

Per impostazione predefinita, un evento denominato non è limitato all'utente che l'ha creata. Altri utenti possono essere in grado di aprire e usare l'evento, incluso l'interferimento con l'evento impostando o reimpostandolo in modo inappropriato. Per limitare l'accesso a utenti specifici, è possibile usare un overload del costruttore o EventWaitHandleAcl passare un EventWaitHandleSecurity oggetto durante la creazione dell'evento denominato. Evitare l'uso di eventi denominati senza restrizioni di accesso nei sistemi che potrebbero avere utenti non attendibili che eseguono codice.

Vedi anche

Panoramica delle primitive di sincronizzazione

Si applica a

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

Inizializza una nuova istanza della classe EventWaitHandle, che specifica se l'handle di attesa viene inizialmente segnalato se creato in seguito alla chiamata, se viene reimpostato automaticamente o manualmente, nonché il nome di un evento di sincronizzazione di sistema, una variabile Boolean il cui valore dopo la chiamata indica se è stato creato l'evento di sistema denominato e la sicurezza del controllo di accesso da applicare all'evento denominato, se è stato creato.

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)

Parametri

initialState: Boolean

true per impostare lo stato iniziale su segnalato se l'evento denominato viene creato come risultato della chiamata; false per impostarlo su non segnalato.

mode: EventResetMode

Ottiene uno dei valori di EventResetMode che determina se l'evento viene reimpostato manualmente o automaticamente.

name: String

Il nome, se l'oggetto di sincronizzazione deve essere condiviso con altri processi; in caso contrario null o una stringa vuota. Per il nome è prevista la distinzione tra maiuscole e minuscole. Il carattere della barra rovesciata (\) è riservato e può essere usato solo per specificare uno spazio dei nomi. Per altre informazioni sugli spazi dei nomi, vedere la sezione osservazioni. Potrebbero esserci ulteriori restrizioni sul nome a seconda del sistema operativo. Ad esempio, nei sistemi operativi basati su Unix, il nome dopo l'esclusione dello spazio dei nomi deve essere un nome di file valido.

createdNew: Boolean

eventSecurity: EventWaitHandleSecurity

Oggetto EventWaitHandleSecurity che rappresenta la sicurezza del controllo di accesso da applicare all'evento di sistema denominato.

Attributi: SecurityCriticalAttribute

Eccezioni

IOException

-oppure-

Si è verificato un altro errore. È possibile che la proprietà HResult offra ulteriori informazioni.

DirectoryNotFoundException

Solo Windows: name ha specificato uno spazio dei nomi sconosciuto. Per altre informazioni, vedere Object Names (Nomi oggetti).

PathTooLongException

name supera la lunghezza consentita. Le limitazioni di lunghezza possono dipendere dal sistema operativo o dalla configurazione.

UnauthorizedAccessException

L'evento denominato esiste e include sicurezza del controllo di accesso, ma l'utente non ha FullControl.

WaitHandleCannotBeOpenedException

Non è possibile creare un oggetto di sincronizzazione con l'elemento name specificato. Un oggetto di sincronizzazione di un tipo diverso potrebbe avere lo stesso nome.

ArgumentException

Il valore enum mode non è compreso nell'intervallo consentito.

-oppure-

Solo .NET Framework: la lunghezza di name supera MAX_PATH (260 caratteri).

Esempio

Nell'esempio di codice seguente viene illustrato il comportamento tra processi di un evento di sistema denominato con sicurezza del controllo di accesso. L'esempio usa l'overload del OpenExisting(String) metodo per testare l'esistenza di un evento denominato.

Se l'evento non esiste, viene creato con la proprietà iniziale e la sicurezza del controllo di accesso che nega all'utente corrente il diritto di usare l'evento, ma concede il diritto di leggere e modificare le autorizzazioni per l'evento.

Se si esegue l'esempio compilato da due finestre di comando, la seconda copia genererà un'eccezione di violazione di accesso nella chiamata a OpenExisting(String). L'eccezione viene rilevata e l'esempio usa l'overload del OpenExisting(String, EventWaitHandleRights) metodo per attendere l'evento con i diritti necessari per leggere e modificare le autorizzazioni.

Dopo aver modificato le autorizzazioni, l'evento viene aperto con i diritti necessari per attendere e segnalarlo. Se si esegue l'esempio compilato da una terza finestra di comando, l'esempio viene eseguito usando le nuove autorizzazioni.

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

Commenti

Usare questo costruttore per applicare la sicurezza del controllo di accesso a un evento di sistema denominato quando viene creato, impedendo ad altri codici di prendere il controllo dell'evento.

Questo costruttore inizializza un oggetto che rappresenta un EventWaitHandle evento di sistema. È possibile creare più EventWaitHandle oggetti che rappresentano lo stesso evento di sistema.

Se l'evento di sistema non esiste, viene creato con la sicurezza del controllo di accesso specificata. Se l'evento esiste, la sicurezza del controllo di accesso specificata viene ignorata.

Nota

Il chiamante ha il controllo completo sull'oggetto appena creato EventWaitHandle anche se eventSecurity nega o non concede alcuni diritti di accesso all'utente corrente. Tuttavia, se l'utente corrente tenta di ottenere un altro EventWaitHandle oggetto per rappresentare lo stesso evento denominato, usando un costruttore o il metodo, viene applicata la sicurezza del OpenExisting controllo di accesso di Windows.

Può name essere preceduto da Global\ o Local\ per specificare uno spazio dei nomi. Quando viene specificato lo spazio dei nomi, l'oggetto Global di sincronizzazione può essere condiviso con tutti i processi nel sistema. Quando viene specificato lo Local spazio dei nomi, che è anche il valore predefinito quando non viene specificato alcun spazio dei nomi, l'oggetto di sincronizzazione può essere condiviso con i processi nella stessa sessione. In Windows una sessione è una sessione di accesso e i servizi vengono in genere eseguiti in una sessione non interattiva diversa. Nei sistemi operativi Unix, ogni shell ha la propria sessione. Gli oggetti di sincronizzazione locale della sessione possono essere appropriati per la sincronizzazione tra processi con una relazione padre/figlio in cui vengono eseguiti tutti nella stessa sessione. Per altre informazioni sui nomi degli oggetti di sincronizzazione in Windows, vedere Nomi oggetti.

Se esiste già un evento di sistema con il nome specificato per il name parametro, il initialState parametro viene ignorato. Dopo aver chiamato questo costruttore, usare il valore nella variabile specificata per il ref parametro (ByRef parametro in Visual Basic) createdNew per determinare se l'evento di sistema denominato esiste già o è stato creato.

Attenzione

Per impostazione predefinita, un evento denominato non è limitato all'utente che l'ha creata. Altri utenti possono essere in grado di aprire e usare l'evento, incluso l'interferimento con l'evento impostando o reimpostandolo in modo inappropriato. Per limitare l'accesso a utenti specifici, è possibile passare un EventWaitHandleSecurity oggetto durante la creazione dell'evento denominato. Evitare l'uso di eventi denominati senza restrizioni di accesso nei sistemi che potrebbero avere utenti non attendibili che eseguono codice.

Vedi anche

Panoramica delle primitive di sincronizzazione

Si applica a

Condividi tramite

EventWaitHandle Costruttori

Definizione

Overload

EventWaitHandle(Boolean, EventResetMode)

Parametri

Eccezioni

Esempio

Commenti

Vedi anche

Si applica a

EventWaitHandle(Boolean, EventResetMode, String)

Parametri

Eccezioni

Commenti

Vedi anche

Si applica a

EventWaitHandle(Boolean, EventResetMode, String, Boolean)

Parametri

Eccezioni

Commenti

Vedi anche

Si applica a

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

Parametri

Eccezioni

Esempio

Commenti

Vedi anche

Si applica a

Risorse aggiuntive