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

Metodo Mutex.OpenExisting (String)

 

Data di pubblicazione: ottobre 2016

Apre il mutex denominato specificato, se esistente.

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

[SecurityCriticalAttribute]
public static Mutex OpenExisting(
	string name
)

Parametri

name
Type: System.String

Nome del mutex di sistema da aprire.

Valore restituito

Type: System.Threading.Mutex

Oggetto che rappresenta il mutex di sistema denominato.

Exception Condition
ArgumentException

Il parametro name è una stringa vuota.

-oppure-

La lunghezza di name supera i 260 caratteri.

ArgumentNullException

name è null.

WaitHandleCannotBeOpenedException

Il mutex denominato non esiste.

IOException

Errore Win32.

UnauthorizedAccessException

Il mutex denominato esiste, ma l'utente non dispone dell'accesso di protezione necessaria per utilizzarlo.

Il OpenExisting metodo tenta di aprire il mutex di sistema denominato. Se il mutex di sistema non esiste, questo metodo genera un'eccezione anziché creare l'oggetto di sistema. Per creare il mutex di sistema quando non esiste già, utilizzare uno del Mutex costruttori che dispone di un name parametro.

Più chiamate al metodo che utilizzano lo stesso valore per name non restituiscono necessariamente lo stesso Mutex dell'oggetto, anche se gli oggetti restituiti rappresentano lo stesso mutex di sistema denominato.

Questo overload del metodo è equivalente alla chiamata di OpenExisting(String, MutexRights) overload del metodo e specificando MutexRights.Synchronize e MutexRights.Modify diritti, combinati tramite l'operazione OR bit per bit.

Specifica il MutexRights.Synchronize flag consente a un thread in attesa del mutex e specificando il MutexRights.Modify flag consente a un thread chiamare il ReleaseMutex metodo.

Questo metodo non viene richiesta la proprietà del mutex.

Esempio di codice seguente viene illustrato il comportamento tra più processi di un mutex denominato con sicurezza del controllo di accesso. Nell'esempio viene utilizzata la OpenExisting(String) overload del metodo per verificare l'esistenza di un mutex denominato.

Se il mutex non esiste, viene creato con la proprietà iniziale e del controllo di accesso che nega all'utente corrente il diritto di utilizzo del mutex, ma concede il diritto di leggere e modificare le autorizzazioni per il mutex.

Se si esegue l'esempio compilato da due finestre di comando, la seconda copia genererà un'eccezione di violazione di accesso durante la chiamata a OpenExisting(String). L'eccezione viene intercettata e nell'esempio viene utilizzata la OpenExisting(String, MutexRights) overload del metodo per aprire il mutex con i diritti necessari per leggere e modificare le autorizzazioni.

Dopo la modifica delle autorizzazioni, il mutex viene aperto con i diritti necessari per immettere e rilasciarlo. Se si esegue l'esempio compilato da una terza finestra di comando, viene eseguito con le nuove autorizzazioni.

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

internal class Example
{
    internal static void Main()
    {
        const string mutexName = "MutexExample4";

        Mutex m = null;
        bool doesNotExist = false;
        bool unauthorized = false;

        // The value of this variable is set by the mutex
        // constructor. It is true if the named system mutex was
        // created, and false if the named mutex already existed.
        //
        bool mutexWasCreated = false;

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

        // There are three cases: (1) The mutex does not exist.
        // (2) The mutex exists, but the current user doesn't 
        // have access. (3) The mutex exists and the user has
        // access.
        //
        if (doesNotExist)
        {
            // The mutex does not exist, so create it.

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

            MutexAccessRule rule = new MutexAccessRule(user, 
                MutexRights.Synchronize | MutexRights.Modify, 
                AccessControlType.Deny);
            mSec.AddAccessRule(rule);

            rule = new MutexAccessRule(user, 
                MutexRights.ReadPermissions | MutexRights.ChangePermissions,
                AccessControlType.Allow);
            mSec.AddAccessRule(rule);

            // Create a Mutex object that represents the system
            // mutex named by the constant 'mutexName', with
            // initial ownership for this thread, and with the
            // specified security access. The Boolean value that 
            // indicates creation of the underlying system object
            // is placed in mutexWasCreated.
            //
            m = new Mutex(true, mutexName, out mutexWasCreated, mSec);

            // If the named system mutex was created, it can be
            // used by the current instance of this program, even 
            // though the current user is denied access. The current
            // program owns the mutex. Otherwise, exit the program.
            // 
            if (mutexWasCreated)
            {
                Console.WriteLine("Created the mutex.");
            }
            else
            {
                Console.WriteLine("Unable to create the mutex.");
                return;
            }

        }
        else if (unauthorized)
        {
            // Open the mutex to read and change the access control
            // security. The access control security defined above
            // allows the current user to do this.
            //
            try
            {
                m = Mutex.OpenExisting(mutexName, 
                    MutexRights.ReadPermissions | MutexRights.ChangePermissions);

                // Get the current ACL. This requires 
                // MutexRights.ReadPermissions.
                MutexSecurity mSec = m.GetAccessControl();

                string user = Environment.UserDomainName + "\\"
                    + Environment.UserName;

                // First, the rule that denied the current user 
                // the right to enter and release the mutex must
                // be removed.
                MutexAccessRule rule = new MutexAccessRule(user, 
                     MutexRights.Synchronize | MutexRights.Modify,
                     AccessControlType.Deny);
                mSec.RemoveAccessRule(rule);

                // Now grant the user the correct rights.
                // 
                rule = new MutexAccessRule(user, 
                    MutexRights.Synchronize | MutexRights.Modify,
                    AccessControlType.Allow);
                mSec.AddAccessRule(rule);

                // Update the ACL. This requires
                // MutexRights.ChangePermissions.
                m.SetAccessControl(mSec);

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

                // Open the mutex with (MutexRights.Synchronize 
                // | MutexRights.Modify), the rights required to
                // enter and release the mutex.
                //
                m = Mutex.OpenExisting(mutexName);

            }
            catch(UnauthorizedAccessException ex)
            {
                Console.WriteLine("Unable to change permissions: {0}",
                    ex.Message);
                return;
            }

        }

        // If this program created the mutex, it already owns
        // the mutex.
        //
        if (!mutexWasCreated)
        {
            // Enter the mutex, and hold it until the program
            // exits.
            //
            try
            {
                Console.WriteLine("Wait for the mutex.");
                m.WaitOne();
                Console.WriteLine("Entered the mutex.");
            }
            catch(UnauthorizedAccessException ex)
            {
                Console.WriteLine("Unauthorized access: {0}", ex.Message);
            }
        }

        Console.WriteLine("Press the Enter key to exit.");
        Console.ReadLine();
        m.ReleaseMutex();
        m.Dispose();
    }
}

SecurityCriticalAttribute

Requires full trust for the immediate caller. This member cannot be used by partially trusted or transparent code.

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: