Esporta (0) Stampa
Espandi tutto
Il presente articolo è stato tradotto automaticamente. Passare il puntatore sulle frasi nell'articolo per visualizzare il testo originale. Ulteriori informazioni.
Traduzione
Originale

Costruttore Semaphore (Int32, Int32, String, Boolean, SemaphoreSecurity)

Inizializza una nuova istanza della classe Semaphore, specificando il numero massimo di accessi contemporanei, riservando facoltativamente alcuni accessi per il thread chiamante, indicando eventualmente il nome di un oggetto semaforo di sistema e specificando una variabile che riceve un valore che indica se è stato creato un nuovo semaforo di sistema e la sicurezza del controllo di accesso per il semaforo di sistema.

Spazio dei nomi:  System.Threading
Assembly:  System (in System.dll)

public Semaphore(
	int initialCount,
	int maximumCount,
	string name,
	out bool createdNew,
	SemaphoreSecurity semaphoreSecurity
)

Parametri

initialCount
Tipo: System.Int32
Numero iniziale di richieste per il semaforo che possono essere soddisfatte contemporaneamente.
maximumCount
Tipo: System.Int32
Numero massimo di richieste per il semaforo che possono essere soddisfatte contemporaneamente.
name
Tipo: System.String
Nome di un oggetto semaforo di sistema denominato.
createdNew
Tipo: System.Boolean
Quando questo metodo viene restituito, contiene true se è stato creato un semaforo locale (ovvero, se il valore di name è null o una stringa vuota) oppure se è stato creato il semaforo di sistema denominato specificato; false se il semaforo di sistema denominato specificato è già esistente. Questo parametro viene passato non inizializzato.
semaphoreSecurity
Tipo: System.Security.AccessControl.SemaphoreSecurity
Oggetto SemaphoreSecurity che rappresenta la sicurezza del controllo di accesso da applicare al semaforo di sistema denominato.

EccezioneCondizione
ArgumentException

initialCount è maggiore di maximumCount.

In alternativa

name è di lunghezza superiore a 260 caratteri.

ArgumentOutOfRangeException

maximumCount è minore di 1.

In alternativa

initialCount è minore di 0.

UnauthorizedAccessException

Il semaforo denominato esiste ed è dotato di sicurezza del controllo di accesso e l'utente non dispone di SemaphoreRights.FullControl.

IOException

Si è verificato un errore Win32.

WaitHandleCannotBeOpenedException

Non è possibile creare il semaforo denominato, probabilmente a causa di un handle di attesa di tipo diverso con lo stesso nome.

Utilizzare questo costruttore per applicare la sicurezza del controllo di accesso a un semaforo di sistema denominato al momento della creazione, in modo da impedire ad altro codice di assumere il controllo del semaforo.

Questo costruttore inizializza un oggetto Semaphore che rappresenta un semaforo di sistema denominato. È possibile creare più oggetti Semaphore che rappresentano lo stesso semaforo di sistema denominato.

Se il semaforo di sistema denominato non esiste, verrà creato con la sicurezza del controllo di accesso specificata. Se il semaforo denominato esiste, la sicurezza del controllo di accesso specificata verrà ignorata.

NotaNota

Il chiamante ha il pieno controllo sull'oggetto Semaphore appena creato anche se semaphoreSecurity nega o non concede alcuni diritti di accesso all'utente corrente. Tuttavia, se l'utente corrente tenta di ottenere un altro oggetto Semaphore per rappresentare mediante un costruttore o il metodo OpenExisting lo stesso semaforo denominato, verrà applicata la sicurezza del controllo di accesso di Windows.

Se il semaforo di sistema denominato non esiste, viene creato con il conteggio iniziale e il conteggio massimo specificati da initialCount e maximumCount. Se il semaforo di sistema denominato esiste già, initialCount e maximumCount non vengono utilizzati, nonostante valori non validi possano comunque causare eccezioni. Utilizzare il parametro createdNew per determinare se il semaforo di sistema è stato creato da questo costruttore.

Se initialCount è minore di maximumCount e createdNew è true, si ottiene lo stesso risultato raggiunto chiamando WaitOne nel thread corrente per un numero di volte pari a (maximumCount - initialCount).

Se per name si specifica null o una stringa vuota, viene creato un semaforo locale come se fosse stato chiamato l'overload del costruttore Semaphore(Int32, Int32). In questo caso, createdNew è sempre true.

Poiché i semafori denominati sono visibili nell'intero sistema operativo, possono essere utilizzati per coordinare l'utilizzo delle risorse attraverso i limiti dei processi.

Nell'esempio di codice riportato di seguito viene illustrato il comportamento tra più processi di un semaforo denominato con sicurezza del controllo di accesso. Nell'esempio viene utilizzato l'overload del metodo OpenExisting(String) per verificare l'esistenza di un semaforo denominato. Se il semaforo non esiste, viene creato con un conteggio massimo pari a due e con la sicurezza del controllo di accesso che nega all'utente corrente il diritto di utilizzo il semaforo, ma concede il diritto di lettura e modifica delle autorizzazioni sul semaforo. Se si esegue l'esempio compilato da due finestre di comando, la seconda copia genererà un'eccezione di violazione di accesso sulla chiamata del metodo OpenExisting(String). L'eccezione viene intercettata e nell'esempio viene utilizzato l'overload del metodo OpenExisting(String, SemaphoreRights) per aprire il semaforo con i diritti necessari per leggere e modificare le autorizzazioni.

Dopo la modifica delle autorizzazioni, il semaforo viene aperto con i diritti richiesti per l'accesso e il rilascio. Se si esegue l'esempio compilato da una terza finestra di comando, l'esempio viene eseguito con le nuove autorizzazioni.


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

Supportato in: 4.5, 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Supportato in: 4, 3.5 SP1

Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (ruoli di base del server non supportati), Windows Server 2008 R2 (ruoli di base del server supportati con SP1 o versione successiva, Itanium non supportato)

.NET Framework non supporta tutte le versioni di ciascuna piattaforma. Per un elenco delle versioni supportate, vedere Requisiti di sistema di .NET Framework.

Aggiunte alla community

AGGIUNGI
Mostra:
© 2014 Microsoft