Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Costruttore Semaphore (Int32, Int32, String, Boolean)

 

Inizializza una nuova istanza della classe Semaphore, specificando il numero di accessi iniziale e il numero massimo di accessi contemporanei, indicando facoltativamente 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.

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

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

Parametri

initialCount
Type: System.Int32

Numero iniziale di richieste per il semaforo che possono essere soddisfatte contemporaneamente.

maximumCount
Type: System.Int32

Numero massimo di richieste per il semaforo che possono essere soddisfatte contemporaneamente.

name
Type: System.String

Nome di un oggetto semaforo di sistema denominato.

createdNew
Type: 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.

Exception Condition
ArgumentException

initialCount è maggiore di maximumCount.

-oppure-

La lunghezza di name supera i 260 caratteri.

ArgumentOutOfRangeException

maximumCount è minore di 1.

-oppure-

initialCount è minore di 0.

IOException

Errore Win32.

UnauthorizedAccessException

Il semaforo denominato esiste e ha accesso alla sicurezza controllo, ma l'utente non dispone di SemaphoreRights.FullControl.

WaitHandleCannotBeOpenedException

Il semaforo denominato non può essere creato, forse perché ha lo stesso nome di un handle di attesa di tipo diverso.

This constructor initializes a T:System.Threading.Semaphore object that represents a named system semaphore. You can create multiple T:System.Threading.Semaphore objects that represent the same named system semaphore.

If the named system semaphore does not exist, it is created with the initial count and maximum count specified by initialCount and maximumCount. If the named system semaphore already exists, initialCount and maximumCount are not used, although invalid values still cause exceptions. Use createdNew to determine whether the system semaphore was created.

If initialCount is less than maximumCount, and createdNew is true, the effect is the same as if the current thread had called Overload:System.Threading.WaitHandle.WaitOne (maximumCount minus initialCount) times.

If you specify null or an empty string for name, a local semaphore is created, as if you had called the M:System.Threading.Semaphore.#ctor(System.Int32,System.Int32) constructor overload. In this case, createdNew is always true.

Because named semaphores are visible throughout the operating system, they can be used to coordinate resource use across process boundaries.

The following code example demonstrates the cross-process behavior of a named semaphore. The example creates a named semaphore with a maximum count of five and an initial count of two. That is, it reserves three entries for the thread that calls the constructor. If createNew is false, the program makes three calls to the Overload:System.Threading.WaitHandle.WaitOne method. Thus, if you run the compiled example from two command windows, the second copy will block on the third call to Overload:System.Threading.WaitHandle.WaitOne. Release one or more entries in the first copy of the program to unblock the second.

using System;
using System.Threading;

public class Example
{
    public static void Main()
    {
        // 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 a Semaphore object that represents the named 
        // system semaphore "SemaphoreExample". The semaphore has a
        // maximum count of five, and an initial count of two. The
        // Boolean value that indicates creation of the underlying 
        // system object is placed in semaphoreWasCreated.
        //
        Semaphore sem = new Semaphore(2, 5, "SemaphoreExample", 
            out semaphoreWasCreated);

        if (semaphoreWasCreated)
        {
            // If the named system semaphore was created, its count is
            // set to the initial count requested in the constructor.
            // In effect, the current thread has entered the semaphore
            // three times.
            // 
            Console.WriteLine("Entered the semaphore three times.");
        }
        else
        {      
            // If the named system semaphore was not created,  
            // attempt to enter it three times. If another copy of
            // this program is already running, only the first two
            // requests can be satisfied. The third blocks.
            //
            sem.WaitOne();
            Console.WriteLine("Entered the semaphore once.");
            sem.WaitOne();
            Console.WriteLine("Entered the semaphore twice.");
            sem.WaitOne();
            Console.WriteLine("Entered the semaphore three times.");
        }

        // The thread executing this program has entered the 
        // semaphore three times. If a second copy of the program
        // is run, it will block until this program releases the 
        // semaphore at least once.
        //
        Console.WriteLine("Enter the number of times to call Release.");
        int n;
        if (int.TryParse(Console.ReadLine(), out n))
        {
            sem.Release(n);
        }

        int remaining = 3 - n;
        if (remaining > 0)
        {
            Console.WriteLine("Press Enter to release the remaining " +
                "count ({0}) and exit the program.", remaining);
            Console.ReadLine();
            sem.Release(remaining);
        }
    } 
} 

SecurityPermission

for calling unmanaged code to create a named system semaphore. Associated enumeration: F:System.Security.Permissions.SecurityPermissionFlag.UnmanagedCode.

Security action: F:System.Security.Permissions.SecurityAction.LinkDemand.

Universal Windows Platform
Disponibile da 8
.NET Framework
Disponibile da 2.0
Libreria di classi portabile
Supportato in: piattaforme .NET portabili
Windows Phone Silverlight
Disponibile da 8.0
Windows Phone
Disponibile da 8.1
Torna all'inizio
Mostra: