EventWaitHandle.OpenExisting Methode

Referenz

Definition

Namespace:: System.Threading

Assembly:: System.Threading.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Öffnet ein bestimmtes benanntes Synchronisierungsereignis, wenn es bereits vorhanden ist.

Überlädt

OpenExisting(String)	Öffnet das bestimmte benannte Synchronisierungsereignis, wenn es bereits vorhanden ist.
OpenExisting(String, EventWaitHandleRights)	Öffnet das angegebene benannte Synchronisierungsereignis, wenn es bereits vorhanden ist, mit dem gewünschten Sicherheitszugriff.

OpenExisting(String)

Quelle:: EventWaitHandle.cs

Quelle:: EventWaitHandle.cs

Quelle:: EventWaitHandle.cs

Öffnet das bestimmte benannte Synchronisierungsereignis, wenn es bereits vorhanden ist.

public:
 static System::Threading::EventWaitHandle ^ OpenExisting(System::String ^ name);

[System.Security.SecurityCritical]
public static System.Threading.EventWaitHandle OpenExisting (string name);

[System.Runtime.Versioning.SupportedOSPlatform("windows")]
public static System.Threading.EventWaitHandle OpenExisting (string name);

public static System.Threading.EventWaitHandle OpenExisting (string name);

[<System.Security.SecurityCritical>]
static member OpenExisting : string -> System.Threading.EventWaitHandle

[<System.Runtime.Versioning.SupportedOSPlatform("windows")>]
static member OpenExisting : string -> System.Threading.EventWaitHandle

static member OpenExisting : string -> System.Threading.EventWaitHandle

Public Shared Function OpenExisting (name As String) As EventWaitHandle

Parameter

name: String

Der Name des Synchronisierungsobjekts, das geöffnet und für andere Prozesse freigegeben werden soll. Bei dem Namen wird die Groß- und Kleinschreibung berücksichtigt. Der umgekehrte Schrägstrich (\) ist reserviert und kann nur zum Angeben eines Namespace verwendet werden. Weitere Informationen zu Namespaces finden Sie im Abschnitt Hinweise. Je nach Betriebssystem kann es weitere Einschränkungen für den Namen geben. Unter Unix-basierten Betriebssystemen muss der Name nach dem Ausschluss des Namespace beispielsweise ein gültiger Dateiname sein.

Gibt zurück

EventWaitHandle

Ein Objekt, das das benannte Systemereignis darstellt.

Attribute: SecurityCriticalAttribute SupportedOSPlatformAttribute

Ausnahmen

WaitHandleCannotBeOpenedException

Ein Synchronisierungsobjekt mit dem angegebenen name kann nicht geöffnet werden. Möglicherweise ist es nicht vorhanden, oder ein Synchronisierungsobjekt eines anderen Typs weist ggf. denselben Namen auf. In einigen Fällen kann diese Ausnahme für ungültige Namen ausgelöst werden.

ArgumentException

name ist eine leere Zeichenfolge.

- oder -

Nur .NET Framework: name ist länger als MAX_PATH (260 Zeichen).

ArgumentNullException

name ist null.

IOException

name ist ungültig. Dies kann aus verschiedenen Gründen der Fall sein, z. B. durch Einschränkungen, die vom Betriebssystem auferlegt werden, etwa ein unbekanntes Präfix oder ungültige Zeichen. Beachten Sie, dass bei dem Namen und den gängigen Präfixen "Global\" und "Local\" die Groß-/Kleinschreibung beachtet wird.

- oder -

Es ist ein anderer Fehler aufgetreten. DieHResult-Eigenschaft stellt möglicherweise weitere Informationen zur Verfügung.

DirectoryNotFoundException

Nur Windows: name hat einen unbekannten Namespace angegeben. Weitere Informationen finden Sie unter Objektnamen.

PathTooLongException

name ist zu lang. Längeneinschränkungen können vom Betriebssystem oder der Konfiguration abhängen.

UnauthorizedAccessException

Das benannte Ereignis ist vorhanden, der Benutzer verfügt jedoch nicht über den nötigen Sicherheitszugriff, um es zu verwenden.

Hinweise

Der name kann mit Global\ dem Präfix oder Local\ versehen sein, um einen Namespace anzugeben. Wenn der Global Namespace angegeben wird, kann das Synchronisierungsobjekt für alle Prozesse im System freigegeben werden. Wenn der Local Namespace angegeben ist, was auch der Standardwert ist, wenn kein Namespace angegeben wird, kann das Synchronisierungsobjekt für Prozesse in derselben Sitzung freigegeben werden. Unter Windows ist eine Sitzung eine Anmeldesitzung, und Dienste werden in der Regel in einer anderen nicht interaktiven Sitzung ausgeführt. Unter Unix-ähnlichen Betriebssystemen verfügt jede Shell über eine eigene Sitzung. Sitzungslokale Synchronisierungsobjekte eignen sich möglicherweise für die Synchronisierung zwischen Prozessen mit einer übergeordneten/untergeordneten Beziehung, bei der sie alle in derselben Sitzung ausgeführt werden. Weitere Informationen zu Synchronisierungsobjektnamen unter Windows finden Sie unter Objektnamen.

Wenn ein Synchronisierungsobjekt des angeforderten Typs im Namespace vorhanden ist, wird das vorhandene Synchronisierungsobjekt geöffnet. Wenn im Namespace kein Synchronisierungsobjekt vorhanden ist oder ein Synchronisierungsobjekt eines anderen Typs im Namespace vorhanden ist, wird ein WaitHandleCannotBeOpenedException ausgelöst.

Die OpenExisting -Methode versucht, das angegebene benannte Systemereignis zu öffnen. Um das Systemereignis zu erstellen, wenn es noch nicht vorhanden ist, verwenden Sie einen der EventWaitHandle Konstruktoren mit einem name Parameter.

Mehrere Aufrufe dieser Methode, die denselben Wert für name verwenden, geben nicht unbedingt dasselbe EventWaitHandle Objekt zurück, obwohl die zurückgegebenen Objekte das gleiche benannte Systemereignis darstellen.

In .NET Framework entspricht diese Methodenüberladung dem Aufrufen der System.Threading.EventWaitHandle.OpenExisting(System.String,System.Security.AccessControl.EventWaitHandleRights)- Methode überladen und angeben EventWaitHandleRights.Synchronize und EventWaitHandleRights.Modify rechte, kombiniert mit dem bitweisen OR Vorgang.

Das Angeben des EventWaitHandleRights.Synchronize Flags ermöglicht es einem Thread, auf das benannte Systemereignis zu warten, und die Angabe des EventWaitHandleRights.Modify Flags ermöglicht es einem Thread, die Set Methoden und Reset aufzurufen.

Weitere Informationen

Übersicht über Synchronisierungsprimitiven

Gilt für:

OpenExisting(String, EventWaitHandleRights)

Öffnet das angegebene benannte Synchronisierungsereignis, wenn es bereits vorhanden ist, mit dem gewünschten Sicherheitszugriff.

public:
 static System::Threading::EventWaitHandle ^ OpenExisting(System::String ^ name, System::Security::AccessControl::EventWaitHandleRights rights);

public static System.Threading.EventWaitHandle OpenExisting (string name, System.Security.AccessControl.EventWaitHandleRights rights);

[System.Security.SecurityCritical]
public static System.Threading.EventWaitHandle OpenExisting (string name, System.Security.AccessControl.EventWaitHandleRights rights);

static member OpenExisting : string * System.Security.AccessControl.EventWaitHandleRights -> System.Threading.EventWaitHandle

[<System.Security.SecurityCritical>]
static member OpenExisting : string * System.Security.AccessControl.EventWaitHandleRights -> System.Threading.EventWaitHandle

Public Shared Function OpenExisting (name As String, rights As EventWaitHandleRights) As EventWaitHandle

Parameter

name: String

rights: EventWaitHandleRights

Eine bitweise Kombination von Enumerationswerten, die die gewünschten Sicherheitszugriffsrechte darstellen.

Gibt zurück

EventWaitHandle

Ein Objekt, das das benannte Systemereignis darstellt.

Attribute: SecurityCriticalAttribute

Ausnahmen

ArgumentException

name ist eine leere Zeichenfolge.

- oder -

Nur .NET Framework: name ist länger als MAX_PATH (260 Zeichen).

ArgumentNullException

name ist null.

WaitHandleCannotBeOpenedException

IOException

- oder -

Es ist ein anderer Fehler aufgetreten. DieHResult-Eigenschaft stellt möglicherweise weitere Informationen zur Verfügung.

DirectoryNotFoundException

Nur Windows: name hat einen unbekannten Namespace angegeben. Weitere Informationen finden Sie unter Objektnamen.

PathTooLongException

name ist zu lang. Längeneinschränkungen können vom Betriebssystem oder der Konfiguration abhängen.

UnauthorizedAccessException

Das benannte Ereignis ist vorhanden, aber der Benutzer verfügt nicht über den erforderlichen Sicherheitszugriff.

Beispiele

Im folgenden Codebeispiel wird das prozessübergreifende Verhalten eines benannten Systemereignisses mit Zugriffssteuerungssicherheit veranschaulicht. Im Beispiel wird die OpenExisting(String) Methodenüberladung verwendet, um das Vorhandensein eines benannten Ereignisses zu testen.

Wenn das Ereignis nicht vorhanden ist, wird es mit der anfänglichen Besitz- und Zugriffssteuerungssicherheit erstellt, die dem aktuellen Benutzer das Recht zur Verwendung des Ereignisses verweigert, aber das Recht zum Lesen und Ändern von Berechtigungen für das Ereignis gewährt.

Wenn Sie das kompilierte Beispiel über zwei Befehlsfenster ausführen, löst die zweite Kopie eine Zugriffsverletzungs-Ausnahme für den Aufruf von aus OpenExisting(String). Die Ausnahme wird abgefangen, und im Beispiel wird die OpenExisting(String, EventWaitHandleRights) Methodenüberladung verwendet, um auf das Ereignis mit den Zum Lesen und Ändern der Berechtigungen erforderlichen Rechten zu warten.

Nachdem die Berechtigungen geändert wurden, wird das Ereignis mit den Rechten geöffnet, die zum Warten und Signalisieren erforderlich sind. Wenn Sie das kompilierte Beispiel über ein drittes Befehlsfenster ausführen, wird das Beispiel mit den neuen Berechtigungen ausgeführt.

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

Hinweise

Der rights Parameter muss das EventWaitHandleRights.Synchronize Flag enthalten, damit Threads auf das Ereignis warten können, und das EventWaitHandleRights.Modify Flag, damit Threads die Set Methoden und Reset aufrufen können.

Die OpenExisting -Methode versucht, ein vorhandenes benanntes Systemereignis zu öffnen. Um das Systemereignis zu erstellen, wenn es noch nicht vorhanden ist, verwenden Sie einen der EventWaitHandle Konstruktoren mit einem name Parameter.

Weitere Informationen

Übersicht über Synchronisierungsprimitiven

Gilt für:

Freigeben über

EventWaitHandle.OpenExisting Methode

Definition

Überlädt

OpenExisting(String)

Parameter

Gibt zurück

Ausnahmen

Hinweise

Weitere Informationen

Gilt für:

OpenExisting(String, EventWaitHandleRights)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Weitere Informationen

Gilt für:

Zusätzliche Ressourcen