Semaphore.OpenExisting Methode

Definition

Namespace:

System.Threading

Assemblys:

netstandard.dll, System.Threading.dll

Öffnet einen angegebenen benannten Semaphor, sofern er bereits vorhanden ist.

Überlädt

Name	Beschreibung
OpenExisting(String)	Öffnet den angegebenen benannten Semaphor, sofern er bereits vorhanden ist.
OpenExisting(String, NamedWaitHandleOptions)	Öffnet den angegebenen benannten Semaphor, sofern er bereits vorhanden ist. Wenn die Optionen nur auf den aktuellen Benutzer festgelegt sind, werden die Zugriffssteuerungen des Objekts für den aufrufenden Benutzer überprüft.

OpenExisting(String)

Quelle:

Semaphore.cs

Öffnet den angegebenen benannten Semaphor, sofern er bereits vorhanden ist.

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

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

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

Public Shared Function OpenExisting (name As String) As Semaphore

Parameter

name

String

Der Name des Synchronisierungsobjekts, das für andere Prozesse freigegeben werden soll. Bei dem Namen wird die Groß-/Kleinschreibung beachtet. Das umgekehrte Schrägstrichzeichen (\) ist reserviert und kann nur verwendet werden, um einen Namespace anzugeben. Weitere Informationen zu Namespaces finden Sie im Abschnitt "Hinweise". Je nach Betriebssystem kann es weitere Einschränkungen für den Namen geben. Bei Unix-basierten Betriebssystemen muss beispielsweise der Name nach Ausschluss des Namespaces ein gültiger Dateiname sein.

Gibt zurück

Semaphore

Ein Objekt, das den benannten Systemsemaphor darstellt.

Attribute

SupportedOSPlatformAttribute

Ausnahmen

ArgumentException

name ist eine leere Zeichenfolge.

- oder -

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

ArgumentNullException

name ist null.

WaitHandleCannotBeOpenedException

Ein Synchronisierungsobjekt mit dem bereitgestellten name Objekt kann nicht erstellt werden. Ein Synchronisierungsobjekt eines anderen Typs hat möglicherweise denselben Namen. In einigen Fällen kann diese Ausnahme für ungültige Namen ausgelöst werden.

IOException

name ist ungültig. Dies kann aus verschiedenen Gründen sein, einschließlich einiger Einschränkungen, die vom Betriebssystem platziert werden können, z. B. ein unbekanntes Präfix oder ungültige Zeichen. Beachten Sie, dass bei namen und allgemeinen Präfixen "Global\" und "Local\" die Groß-/Kleinschreibung beachtet wird.

- oder -

Es gab einen anderen Fehler. Die HResult Eigenschaft kann weitere Informationen bereitstellen.

PathTooLongException

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

UnauthorizedAccessException

Der benannte Semaphor ist vorhanden, der Benutzer verfügt jedoch nicht über den sicherheitsrelevanten Zugriff, der für die Verwendung erforderlich ist.

Beispiele

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

Wenn das Semaphor nicht vorhanden ist, wird es mit einer maximalen Anzahl von zwei und mit Zugriffssteuerungssicherheit erstellt, die dem aktuellen Benutzer das Recht auf Nutzung des Semaphors verweigert, aber das Recht gewährt, Berechtigungen für das Semaphor zu lesen und zu ändern.

Wenn Sie das kompilierte Beispiel aus zwei Befehlsfenstern ausführen, löst die zweite Kopie eine Zugriffsverletzungs exception für den Aufruf der OpenExisting(String) Methodenüberladung aus. Die Ausnahme wird abgefangen, und im Beispiel wird die OpenExisting(String, SemaphoreRights) Methodenüberladung verwendet, um das Semaphor mit den zum Lesen und Ändern der Berechtigungen erforderlichen Rechte zu öffnen.

Nachdem die Berechtigungen geändert wurden, wird das Semaphor mit den zum Eingeben und Freigeben erforderlichen Rechten geöffnet. Wenn Sie das kompilierte Beispiel aus einem dritten Befehlsfenster ausführen, wird es mit den neuen Berechtigungen ausgeführt.

using System;
using System.Threading;
using System.Security.AccessControl;

internal class Example
{
    internal static void Main()
    {
        const string semaphoreName = "SemaphoreExample5";

        Semaphore sem = null;
        bool doesNotExist = false;
        bool unauthorized = false;

        // Attempt to open the named semaphore.
        try
        {
            // Open the semaphore with (SemaphoreRights.Synchronize
            // | SemaphoreRights.Modify), to enter and release the
            // named semaphore.
            //
            sem = Semaphore.OpenExisting(semaphoreName);
        }
        catch(WaitHandleCannotBeOpenedException)
        {
            Console.WriteLine("Semaphore does not exist.");
            doesNotExist = true;
        }
        catch(UnauthorizedAccessException ex)
        {
            Console.WriteLine("Unauthorized access: {0}", ex.Message);
            unauthorized = true;
        }

        // There are three cases: (1) The semaphore does not exist.
        // (2) The semaphore exists, but the current user doesn't 
        // have access. (3) The semaphore exists and the user has
        // access.
        //
        if (doesNotExist)
        {
            // The semaphore does not exist, so create it.
            //
            // The value of this variable is set by the semaphore
            // constructor. It is true if the named system semaphore was
            // created, and false if the named semaphore already existed.
            //
            bool semaphoreWasCreated;

            // Create an access control list (ACL) that denies the
            // current user the right to enter or release the 
            // semaphore, but allows the right to read and change
            // security information for the semaphore.
            //
            string user = Environment.UserDomainName + "\\" 
                + Environment.UserName;
            SemaphoreSecurity semSec = new SemaphoreSecurity();

            SemaphoreAccessRule rule = new SemaphoreAccessRule(
                user, 
                SemaphoreRights.Synchronize | SemaphoreRights.Modify, 
                AccessControlType.Deny);
            semSec.AddAccessRule(rule);

            rule = new SemaphoreAccessRule(
                user, 
                SemaphoreRights.ReadPermissions | SemaphoreRights.ChangePermissions,
                AccessControlType.Allow);
            semSec.AddAccessRule(rule);

            // Create a Semaphore object that represents the system
            // semaphore named by the constant 'semaphoreName', with
            // maximum count three, initial count three, and the
            // specified security access. The Boolean value that 
            // indicates creation of the underlying system object is
            // placed in semaphoreWasCreated.
            //
            sem = new Semaphore(3, 3, semaphoreName, 
                out semaphoreWasCreated, semSec);

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

                // Get the current ACL. This requires 
                // SemaphoreRights.ReadPermissions.
                SemaphoreSecurity semSec = sem.GetAccessControl();
                
                string user = Environment.UserDomainName + "\\" 
                    + Environment.UserName;

                // First, the rule that denied the current user 
                // the right to enter and release the semaphore must
                // be removed.
                SemaphoreAccessRule rule = new SemaphoreAccessRule(
                    user, 
                    SemaphoreRights.Synchronize | SemaphoreRights.Modify, 
                    AccessControlType.Deny);
                semSec.RemoveAccessRule(rule);

                // Now grant the user the correct rights.
                // 
                rule = new SemaphoreAccessRule(user, 
                     SemaphoreRights.Synchronize | SemaphoreRights.Modify, 
                     AccessControlType.Allow);
                semSec.AddAccessRule(rule);

                // Update the ACL. This requires
                // SemaphoreRights.ChangePermissions.
                sem.SetAccessControl(semSec);

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

                // Open the semaphore with (SemaphoreRights.Synchronize 
                // | SemaphoreRights.Modify), the rights required to
                // enter and release the semaphore.
                //
                sem = Semaphore.OpenExisting(semaphoreName);
            }
            catch(UnauthorizedAccessException ex)
            {
                Console.WriteLine("Unable to change permissions: {0}", ex.Message);
                return;
            }
        }

        // Enter the semaphore, and hold it until the program
        // exits.
        //
        try
        {
            sem.WaitOne();
            Console.WriteLine("Entered the semaphore.");
            Console.WriteLine("Press the Enter key to exit.");
            Console.ReadLine();
            sem.Release();
        }
        catch(UnauthorizedAccessException ex)
        {
            Console.WriteLine("Unauthorized access: {0}", ex.Message);
        }
    }
}

Imports System.Threading
Imports System.Security.AccessControl

Friend Class Example

    <MTAThread> _
    Friend Shared Sub Main()
        Const semaphoreName As String = "SemaphoreExample5"

        Dim sem As Semaphore = Nothing
        Dim doesNotExist as Boolean = False
        Dim unauthorized As Boolean = False

        ' Attempt to open the named semaphore.
        Try
            ' Open the semaphore with (SemaphoreRights.Synchronize
            ' Or SemaphoreRights.Modify), to enter and release the
            ' named semaphore.
            '
            sem = Semaphore.OpenExisting(semaphoreName)
        Catch ex As WaitHandleCannotBeOpenedException
            Console.WriteLine("Semaphore 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 semaphore does not exist.
        ' (2) The semaphore exists, but the current user doesn't 
        ' have access. (3) The semaphore exists and the user has
        ' access.
        '
        If doesNotExist Then
            ' The semaphore does not exist, so create it.
            '
            ' The value of this variable is set by the semaphore
            ' constructor. It is True if the named system semaphore was
            ' created, and False if the named semaphore already existed.
            '
            Dim semaphoreWasCreated As Boolean

            ' Create an access control list (ACL) that denies the
            ' current user the right to enter or release the 
            ' semaphore, but allows the right to read and change
            ' security information for the semaphore.
            '
            Dim user As String = Environment.UserDomainName _ 
                & "\" & Environment.UserName
            Dim semSec As New SemaphoreSecurity()

            Dim rule As New SemaphoreAccessRule(user, _
                SemaphoreRights.Synchronize Or SemaphoreRights.Modify, _
                AccessControlType.Deny)
            semSec.AddAccessRule(rule)

            rule = New SemaphoreAccessRule(user, _
                SemaphoreRights.ReadPermissions Or _
                SemaphoreRights.ChangePermissions, _
                AccessControlType.Allow)
            semSec.AddAccessRule(rule)

            ' Create a Semaphore object that represents the system
            ' semaphore named by the constant 'semaphoreName', with
            ' maximum count three, initial count three, and the
            ' specified security access. The Boolean value that 
            ' indicates creation of the underlying system object is
            ' placed in semaphoreWasCreated.
            '
            sem = New Semaphore(3, 3, semaphoreName, _
                semaphoreWasCreated, semSec)

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

        ElseIf unauthorized Then

            ' Open the semaphore to read and change the access
            ' control security. The access control security defined
            ' above allows the current user to do this.
            '
            Try
                sem = Semaphore.OpenExisting(semaphoreName, _
                    SemaphoreRights.ReadPermissions Or _
                    SemaphoreRights.ChangePermissions)

                ' Get the current ACL. This requires 
                ' SemaphoreRights.ReadPermissions.
                Dim semSec As SemaphoreSecurity = sem.GetAccessControl()
                
                Dim user As String = Environment.UserDomainName _ 
                    & "\" & Environment.UserName

                ' First, the rule that denied the current user 
                ' the right to enter and release the semaphore must
                ' be removed.
                Dim rule As New SemaphoreAccessRule(user, _
                    SemaphoreRights.Synchronize Or SemaphoreRights.Modify, _
                    AccessControlType.Deny)
                semSec.RemoveAccessRule(rule)

                ' Now grant the user the correct rights.
                ' 
                rule = New SemaphoreAccessRule(user, _
                    SemaphoreRights.Synchronize Or SemaphoreRights.Modify, _
                    AccessControlType.Allow)
                semSec.AddAccessRule(rule)

                ' Update the ACL. This requires
                ' SemaphoreRights.ChangePermissions.
                sem.SetAccessControl(semSec)

                Console.WriteLine("Updated semaphore security.")

                ' Open the semaphore with (SemaphoreRights.Synchronize 
                ' Or SemaphoreRights.Modify), the rights required to
                ' enter and release the semaphore.
                '
                sem = Semaphore.OpenExisting(semaphoreName)

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

        End If

        ' Enter the semaphore, and hold it until the program
        ' exits.
        '
        Try
            sem.WaitOne()
            Console.WriteLine("Entered the semaphore.")
            Console.WriteLine("Press the Enter key to exit.")
            Console.ReadLine()
            sem.Release()
        Catch ex As UnauthorizedAccessException
            Console.WriteLine("Unauthorized access: {0}", _
                ex.Message)
        End Try
    End Sub 
End Class

Hinweise

Möglicherweise name wird dem Namespace ein Präfix vorangestellt Global\ oder Local\ angegeben. Wenn der Global Namespace angegeben ist, 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. 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. Sitzungslokale Synchronisierungsobjekte können für die Synchronisierung zwischen Prozessen mit einer Beziehung zwischen übergeordnetem/untergeordnetem Element geeignet sein, in der sie alle in derselben Sitzung ausgeführt werden. Weitere Informationen zu Synchronisierungsobjektnamen in Windows finden Sie unter Object Names.

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 ein WaitHandleCannotBeOpenedException Fehler ausgelöst.

Die OpenExisting Methode versucht, das angegebene benannte Semaphor zu öffnen. Verwenden Sie einen der Semaphore Konstruktoren, die über einen name Parameter verfügen, um das Systemsemaphor zu erstellen, wenn es noch nicht vorhanden ist.

Mehrere Aufrufe dieser Methode, für die derselbe Wert name verwendet wird, geben nicht unbedingt dasselbe Semaphore Objekt zurück, obwohl die zurückgegebenen Objekte denselben benannten Systemsemaphor darstellen.

Diese Methodenüberladung entspricht dem Aufrufen der OpenExisting Methodenüberladung und der Angabe SemaphoreRights.Synchronize und SemaphoreRights.Modify Rechte, kombiniert mit dem bitweisen OR-Vorgang.

Wenn Sie das SemaphoreRights.Synchronize Flag angeben, kann ein Thread das Semaphor eingeben und das SemaphoreRights.Modify Flag angeben, dass ein Thread die Release Methode aufrufen kann.

Weitere Informationen

• Verwaltetes Thread-Management
• Semaphor

OpenExisting(String, NamedWaitHandleOptions)

Quelle:

Semaphore.cs

Öffnet den angegebenen benannten Semaphor, sofern er bereits vorhanden ist. Wenn die Optionen nur auf den aktuellen Benutzer festgelegt sind, werden die Zugriffssteuerungen des Objekts für den aufrufenden Benutzer überprüft.

public:
 static System::Threading::Semaphore ^ OpenExisting(System::String ^ name, System::Threading::NamedWaitHandleOptions options);

[System.Runtime.Versioning.SupportedOSPlatform("windows")]
public static System.Threading.Semaphore OpenExisting(string name, System.Threading.NamedWaitHandleOptions options);

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

Public Shared Function OpenExisting (name As String, options As NamedWaitHandleOptions) As Semaphore

Parameter

name

String

Der Name des Synchronisierungsobjekts, das für andere Prozesse freigegeben werden soll. Bei dem Namen wird die Groß-/Kleinschreibung beachtet. Das umgekehrte Schrägstrichzeichen (\) ist reserviert und kann nur verwendet werden, um einen Namespace anzugeben. Weitere Informationen zu Namespaces finden Sie im Abschnitt "Hinweise".

options

NamedWaitHandleOptions

Die Bereichsoptionen für den benannten Semaphor. Standardmäßig ist der Zugriff auf den aktuellen Benutzer und die aktuelle Sitzung beschränkt. Die angegebenen Optionen können sich auf den Namespace für den Namen und den Zugriff auf das zugrunde liegende Semaphorobjekt auswirken.

Gibt zurück

Semaphore

Ein Objekt, das den benannten Systemsemaphor darstellt.

Attribute

SupportedOSPlatformAttribute

Ausnahmen

ArgumentException

name ist eine leere Zeichenfolge.

ArgumentNullException

name ist null.

WaitHandleCannotBeOpenedException

Ein Synchronisierungsobjekt mit dem bereitgestellten name Objekt kann nicht erstellt werden. Ein Synchronisierungsobjekt eines anderen Typs hat möglicherweise denselben Namen.

- oder -

Ein Objekt mit dem angegebenen name Objekt ist vorhanden, die angegebenen options Sind jedoch nicht mit den Optionen des vorhandenen Objekts kompatibel.

IOException

name ist ungültig. Dies kann aus verschiedenen Gründen sein, einschließlich einiger Einschränkungen, die vom Betriebssystem platziert werden können, z. B. ein unbekanntes Präfix oder ungültige Zeichen. Beachten Sie, dass bei namen und allgemeinen Präfixen "Global\" und "Local\" die Groß-/Kleinschreibung beachtet wird.

- oder -

Es gab einen anderen Fehler. Die HResult Eigenschaft kann weitere Informationen bereitstellen.

PathTooLongException

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

UnauthorizedAccessException

Der benannte Semaphor ist vorhanden, der Benutzer verfügt jedoch nicht über den sicherheitsrelevanten Zugriff, der für die Verwendung erforderlich ist.

Hinweise

Wenn ein Synchronisierungsobjekt des angeforderten Typs im Namespace vorhanden ist, wird das vorhandene Synchronisierungsobjekt geöffnet. Wenn options jedoch der Zugriff auf den aktuellen Benutzer beschränkt ist und das Synchronisierungsobjekt nicht kompatibel ist, wird ein WaitHandleCannotBeOpenedException Fehler ausgelöst. Wenn im Namespace kein Synchronisierungsobjekt vorhanden ist oder ein Synchronisierungsobjekt eines anderen Typs im Namespace vorhanden ist, wird auch ein WaitHandleCannotBeOpenedException Synchronisierungsobjekt ausgelöst.

Die OpenExisting Methode versucht, das angegebene benannte Semaphor zu öffnen. Verwenden Sie einen der Semaphore Konstruktoren, die über einen name Parameter verfügen, um das Systemsemaphor zu erstellen, wenn es noch nicht vorhanden ist.

Mehrere Aufrufe dieser Methode, für die derselbe Wert name verwendet wird, geben nicht unbedingt dasselbe Semaphore Objekt zurück, obwohl die zurückgegebenen Objekte denselben benannten Systemsemaphor darstellen.

Weitere Informationen

• Verwaltetes Thread-Management
• Semaphor