Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch

Semaphore.GetAccessControl-Methode: ()

 

Veröffentlicht: Juli 2016

Ruft die Zugriffssteuerungssicherheit für ein benanntes Systemsemaphor ab.

Namespace:   System.Threading
Assembly:  System (in System.dll)

public SemaphoreSecurity GetAccessControl()

Rückgabewert

Type: System.Security.AccessControl.SemaphoreSecurity

Ein SemaphoreSecurity-Objekt, das die Zugriffssteuerungssicherheit für das benannte Systemsemaphor darstellt.

Exception Condition
UnauthorizedAccessException

Das aktuelle Semaphore-Objekt stellt einen benannten Systemsemaphor dar, und der Benutzer verfügt nicht über SemaphoreRights.ReadPermissions-Berechtigung.

- oder -

Das aktuelle Semaphore-Objekt stellt einen benannten Systemsemaphor dar und wurde nicht mit SemaphoreRights.ReadPermissions-Berechtigung geöffnet.

NotSupportedException

Wird nicht für Windows 98 oder Windows Millennium Edition unterstützt.

Die GetAccessControl Methode verwendet die folgende Kombination von Flags, die (mit dem bitweisen OR-Operation kombiniert) zu suchende Berechtigungen: AccessControlSections.Access, AccessControlSections.Owner, und AccessControlSections.Group.

Der Benutzer benötigt SemaphoreRights.ReadPermissions Rechte für diese Methode aufzurufen, und das Semaphor müssen mit geöffnet wurden SemaphoreRights.ReadPermissions Rechte.

Auf ein lokales Semaphor ist zugriffssteuerungssicherheit spielt keine Rolle. Wenn die Semaphore Objekt stellt kein benanntes Systemsemaphor dar, die diese Methode gibt ein SemaphoreSecurity -Objekt, das für jeden Benutzer alle Rechte gewährt.

Im folgenden Codebeispiel wird das Verhalten prozessübergreifend ein benanntes Semaphor mit zugriffssteuerungssicherheit veranschaulicht. Im Beispiel wird die OpenExisting(String) -methodenüberladung, um das Vorhandensein des ein benanntes Semaphor testen.

Wenn das Semaphor nicht vorhanden ist, wird es erstellt, mit einer maximalen Zähler von zwei und zugriffssteuerungssicherheit, die verweigert des aktuellen Benutzers des rechts, das Semaphor verwenden, aber das Recht zum Lesen und Ändern von Berechtigungen für das Semaphor gewährt.

Wenn Sie das kompilierte Beispiel aus zwei Befehlsfenstern ausführen, löst die zweite Kopie eine Zugriffsverletzungsausnahme beim Aufruf von der OpenExisting(String) Methode. Die Ausnahme abgefangen wird, und im Beispiel wird die OpenExisting(String, SemaphoreRights) -methodenüberladung, um das Semaphor mit den Berechtigungen zum Lesen und ändern Sie die Berechtigungen zu öffnen. Die zugriffssteuerungssicherheit für das Systemsemaphor abgerufen wird, mithilfe der GetAccessControl Methode.

Nachdem die Berechtigungen geändert werden, wird das Semaphor geöffnet, mit den erforderlichen Benutzerrechten zum eingeben und freigeben. Wenn Sie das kompilierte Beispiel in einem dritten Befehlsfenster ausführen, wird die Verwendung der 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);
        }
    }
}

.NET Framework
Verfügbar seit 2.0
Zurück zum Anfang
Anzeigen: