EventWaitHandle.OpenExisting Methode
Definition
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)
Ö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.EventWaitHandlestatic member OpenExisting : string -> System.Threading.EventWaitHandlePublic Shared Function OpenExisting (name As String) As EventWaitHandleParameter
- 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.
Gibt zurück
Ein Objekt, das das benannte Systemereignis darstellt.
- Attribute
Ausnahmen
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.
name ist eine leere Zeichenfolge.
- oder -
Nur .NET Framework: name ist länger als MAX_PATH (260 Zeichen).
name ist null.
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 für den Namen und die allgemeinen Präfixe "Global" und "Local" Groß-/Kleinschreibung beachtet wird.
- oder -
Es gab einen anderen Fehler. DieHResult-Eigenschaft stellt möglicherweise weitere Informationen zur Verfügung.
Nur Windows: name hat einen unbekannten Namespace angegeben. Weitere Informationen finden Sie unter Objektnamen.
name ist zu lang. Längeneinschränkungen können vom Betriebssystem oder der Konfiguration abhängen.
Das benannte Ereignis ist vorhanden, der Benutzer verfügt jedoch nicht über den nötigen Sicherheitszugriff, um es zu verwenden.
Hinweise
Dies name kann mit Global\ oder Local\ zum Angeben eines Namespaces präfixiert werden. Wenn der Namespace angegeben wird, kann das Global Synchronisierungsobjekt für alle Prozesse im System freigegeben werden. Wenn der Local Namespace angegeben wird, was auch der Standardwert ist, wenn kein Namespace angegeben wird, wird das Synchronisierungsobjekt möglicherweise mit Prozessen in derselben Sitzung freigegeben. Auf Windows ist eine Sitzung eine Anmeldesitzung, und Dienste werden in der Regel in einer anderen nicht interaktiven Sitzung ausgeführt. Auf Unix-ähnlichen Betriebssystemen verfügt jede Shell über eine eigene Sitzung. Sitzungs-lokale Synchronisierungsobjekte können für die Synchronisierung zwischen Prozessen mit einer übergeordneten/untergeordneten Beziehung geeignet sein, in der sie alle in derselben Sitzung ausgeführt werden. Weitere Informationen zu Synchronisierungsobjektnamen auf Windows finden Sie unter Objektnamen.
Wenn ein Synchronisierungsobjekt des angeforderten Typs im Namespace vorhanden ist, wird das vorhandene Synchronisierungsobjekt geöffnet. Wenn ein Synchronisierungsobjekt nicht im Namespace vorhanden ist oder ein Synchronisierungsobjekt eines anderen Typs im Namespace vorhanden ist, wird eine 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 Konstruktoren, die EventWaitHandle über einen name Parameter verfügen.
Mehrere Aufrufe dieser Methode, die denselben Wert name verwenden, geben nicht unbedingt das gleiche EventWaitHandle Objekt zurück, auch wenn die zurückgegebenen Objekte das gleiche systemereignis darstellen.
In .NET Framework entspricht diese Methodenüberladung dem Aufrufen der System.Threading.EventWaitHandle.OpenExisting(System.String,System.Security.AccessControl.EventWaitHandleRights)-Methodenüberladung und Angabe EventWaitHandleRights.Synchronize und EventWaitHandleRights.Modify Rechte, kombiniert mit dem Bitweise-VorgangOR.
Wenn Sie das EventWaitHandleRights.Synchronize Flag angeben, kann ein Thread auf das benannte Systemereignis warten und das EventWaitHandleRights.Modify Flag angeben, dass ein Thread die Reset Set methoden aufrufen kann.
Siehe auch
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.EventWaitHandlePublic Shared Function OpenExisting (name As String, rights As EventWaitHandleRights) As EventWaitHandleParameter
- 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.
- rights
- EventWaitHandleRights
Eine bitweise Kombination von Enumerationswerten, die die gewünschten Sicherheitszugriffsrechte darstellen.
Gibt zurück
Ein Objekt, das das benannte Systemereignis darstellt.
- Attribute
Ausnahmen
name ist eine leere Zeichenfolge.
- oder -
Nur .NET Framework: name ist länger als MAX_PATH (260 Zeichen).
name ist null.
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.
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 für den Namen und die allgemeinen Präfixe "Global" und "Local" Groß-/Kleinschreibung beachtet wird.
- oder -
Es gab einen anderen Fehler. DieHResult-Eigenschaft stellt möglicherweise weitere Informationen zur Verfügung.
Nur Windows: name hat einen unbekannten Namespace angegeben. Weitere Informationen finden Sie unter Objektnamen.
name ist zu lang. Längeneinschränkungen können vom Betriebssystem oder der Konfiguration abhängen.
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 ursprünglichen Besitz- und Zugriffssteuerungssicherheit erstellt, die dem aktuellen Benutzer das Recht auf Verwendung des Ereignisses verweigert, aber das Recht gewährt, Berechtigungen für das Ereignis zu lesen und zu ändern.
Wenn Sie das kompilierte Beispiel aus zwei Befehlsfenstern ausführen, löst die zweite Kopie eine Zugriffsverletzungsausnahmeregelung für den Aufruf OpenExisting(String)aus. Die Ausnahme wird abgefangen, und das Beispiel verwendet die OpenExisting(String, EventWaitHandleRights) Methodenüberladung, 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 erforderlich sind, um darauf zu warten und zu signalisieren. Wenn Sie das kompilierte Beispiel aus einem dritten 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
Das name Präfix kann mit Global\ oder Local\ zum Angeben eines Namespaces angegeben werden. Wenn der Global Namespace angegeben wird, kann das Synchronisierungsobjekt für alle Prozesse im System freigegeben werden. Wenn der Namespace angegeben wird, was auch der Local Standardwert ist, wenn kein Namespace angegeben wird, kann das Synchronisierungsobjekt für Prozesse in derselben Sitzung freigegeben werden. Bei Windows ist eine Sitzung eine Anmeldesitzung, und Dienste werden in der Regel in einer anderen nicht interaktiven Sitzung ausgeführt. Auf Unix-ähnlichen Betriebssystemen verfügt jede Shell über eine eigene Sitzung. Sitzungs-lokale Synchronisierungsobjekte eignen sich möglicherweise für die Synchronisierung zwischen Prozessen mit einer übergeordneten/untergeordneten Beziehung, bei der alle in derselben Sitzung ausgeführt werden. Weitere Informationen zu Synchronisierungsobjektnamen für Windows finden Sie unter Objektnamen.
Wenn ein Synchronisierungsobjekt des angeforderten Typs im Namespace vorhanden ist, wird das vorhandene Synchronisierungsobjekt geöffnet. Wenn ein Synchronisierungsobjekt im Namespace nicht vorhanden ist oder ein Synchronisierungsobjekt eines anderen Typs im Namespace vorhanden ist, wird eine WaitHandleCannotBeOpenedException ausgelöst.
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 Reset Und-Methoden aufrufen können.
Die OpenExisting Methode versucht, ein vorhandenes benanntes Systemereignis zu öffnen. Verwenden Sie einen der EventWaitHandle Konstruktoren mit einem name Parameter, um das Systemereignis zu erstellen, wenn es noch nicht vorhanden ist.
Mehrere Aufrufe dieser Methode, die denselben Wert name verwenden, geben nicht unbedingt dasselbe Objekt zurück, obwohl die zurückgegebenen Objekte dasselbe EventWaitHandle benannte Systemereignis darstellen.