Semaphore.SetAccessControl(SemaphoreSecurity) Methode

Definition

Namespace:

System.Threading

Assembly:

System.dll

Legt die Zugriffssteuerungssicherheit für ein benanntes Systemsemaphor fest.

C#

public void SetAccessControl(System.Security.AccessControl.SemaphoreSecurity semaphoreSecurity);

Parameter

semaphoreSecurity

SemaphoreSecurity

Ein SemaphoreSecurity-Objekt, das die Zugriffssteuerungssicherheit darstellt, die auf das benannte Systemsemaphor angewendet werden soll.

Ausnahmen

ArgumentNullException

semaphoreSecurity ist null.

UnauthorizedAccessException

Der Benutzer verfügt nicht über ChangePermissions-Rechte.

- oder -

Das Semaphor wurde nicht mit ChangePermissions-Rechten geöffnet.

NotSupportedException

Das aktuelle Semaphore-Objekt stellt kein benanntes Systemsemaphor dar.

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 zur Verwendung des Semaphors verweigert, aber das Recht zum Lesen und Ändern des Semaphors gewährt.

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

Nachdem die Berechtigungen mithilfe der SetAccessControl -Methode geändert wurden, wird der Semaphor mit den zum Eingeben und Freigeben erforderlichen Rechten geöffnet. Wenn Sie das kompilierte Beispiel über ein drittes Befehlsfenster ausführen, wird es mit den neuen Berechtigungen ausgeführt.

C#

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);
        }
    }
}

Hinweise

Sie können die Zugriffssteuerungssicherheit nur für Semaphore Objekte festlegen, die benannte Systemsemaphore darstellen.

Der Benutzer muss über Rechte zum Aufrufen dieser Methode verfügen SemaphoreRights.ChangePermissions , und der Semaphor muss mit SemaphoreRights.ChangePermissions Rechten geöffnet worden sein.

Gilt für:

Weitere Informationen

• Verwaltetes Threading
• Semaphore