Mutex.OpenExisting Metoda

Definice

Obor názvů:

System.Threading

Sestavení:

netstandard.dll, System.Threading.dll

Otevře zadaný pojmenovaný mutex, pokud již existuje.

Přetížení

Name	Description
OpenExisting(String)	Otevře zadaný pojmenovaný mutex, pokud již existuje.
OpenExisting(String, NamedWaitHandleOptions)	Otevře zadaný pojmenovaný mutex, pokud již existuje. Pokud jsou možnosti nastaveny pouze na aktuálního uživatele, ověří se u volajícího uživatele řízení přístupu objektu.

OpenExisting(String)

Zdroj:

Mutex.cs

Otevře zadaný pojmenovaný mutex, pokud již existuje.

public:
 static System::Threading::Mutex ^ OpenExisting(System::String ^ name);

public static System.Threading.Mutex OpenExisting(string name);

static member OpenExisting : string -> System.Threading.Mutex

Public Shared Function OpenExisting (name As String) As Mutex

Parametry

name

String

Název synchronizačního objektu, který se má sdílet s jinými procesy. Název je citlivý na velikost písmen. Znak zpětného lomítka (\) je vyhrazen a lze ho použít pouze k určení oboru názvů. Další informace o oborech názvů najdete v části Poznámky. V závislosti na operačním systému můžou existovat další omezení názvu. Například v operačních systémech se systémem Unix musí být název po vyloučení oboru názvů platným názvem souboru.

Návraty

Mutex

Objekt, který představuje pojmenovaný systémový mutex.

Výjimky

ArgumentException

name je prázdný řetězec.

nebo

pouze .NET Framework: name je delší než MAX_PATH (260 znaků).

ArgumentNullException

name je null.

WaitHandleCannotBeOpenedException

Synchronizační objekt se zadaným objektem name nelze vytvořit. Synchronizační objekt jiného typu může mít stejný název. V některých případech může být tato výjimka vyvolán pro neplatné názvy.

IOException

name je neplatný. Může to být z různých důvodů, včetně některých omezení, která může operační systém umístit, například neznámé předpony nebo neplatné znaky. Všimněte si, že název a běžné předpony "Global\" a "Local\" rozlišují malá a velká písmena.

nebo

Došlo k nějaké jiné chybě. Vlastnost HResult může poskytnout další informace.

DirectoryNotFoundException

pouze Windows: name zadal neznámý obor názvů. Další informace najdete v tématu Názvy objektů .

PathTooLongException

name je příliš dlouhý. Omezení délky můžou záviset na operačním systému nebo konfiguraci.

UnauthorizedAccessException

Pojmenovaný mutex existuje, ale uživatel nemá přístup zabezpečení potřebný k jeho použití.

Příklady

Následující příklad kódu ukazuje chování křížového procesu pojmenovaného mutex se zabezpečením řízení přístupu. Příklad používá OpenExisting(String) přetížení metody k otestování existence pojmenovaného mutex.

Pokud mutex neexistuje, vytvoří se s počátečním vlastnictvím a zabezpečením řízení přístupu, které aktuálnímu uživateli odepře právo používat mutex, ale uděluje právo číst a měnit oprávnění k mutexu.

Pokud spustíte zkompilovaný příklad ze dvou oken příkazů, druhá kopie vyvolá výjimku porušení přístupu při volání OpenExisting(String). Výjimka je zachycena a příklad používá OpenExisting(String, MutexRights) přetížení metody k otevření mutex s právy potřebnými ke čtení a změně oprávnění.

Po změně oprávnění se mutex otevře s právy potřebnými k jeho zadání a uvolnění. Pokud spustíte zkompilovaný příklad z třetího příkazového okna, spustí se pomocí nových oprávnění.

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

Imports System.Threading
Imports System.Security.AccessControl

Friend Class Example

    <MTAThread> _
    Friend Shared Sub Main()
        Const mutexName As String = "MutexExample4"

        Dim m As Mutex = Nothing
        Dim doesNotExist as Boolean = False
        Dim unauthorized As Boolean = 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.
        '
        Dim mutexWasCreated As Boolean

        ' Attempt to open the named mutex.
        Try
            ' Open the mutex with (MutexRights.Synchronize Or
            ' MutexRights.Modify), to enter and release the
            ' named mutex.
            '
            m = Mutex.OpenExisting(mutexName)
        Catch ex As WaitHandleCannotBeOpenedException
            Console.WriteLine("Mutex does not exist.")
            doesNotExist = True
        Catch ex As UnauthorizedAccessException
            Console.WriteLine("Unauthorized access: {0}", ex.Message)
            unauthorized = True
        End Try

        ' 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 Then
            ' 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.
            '
            Dim user As String = Environment.UserDomainName _ 
                & "\" & Environment.UserName
            Dim mSec As New MutexSecurity()

            Dim rule As New MutexAccessRule(user, _
                MutexRights.Synchronize Or MutexRights.Modify, _
                AccessControlType.Deny)
            mSec.AddAccessRule(rule)

            rule = New MutexAccessRule(user, _
                MutexRights.ReadPermissions Or _
                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, 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 Then
                Console.WriteLine("Created the mutex.")
            Else
                Console.WriteLine("Unable to create the mutex.")
                Return
            End If

        ElseIf unauthorized Then

            ' 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 Or _
                    MutexRights.ChangePermissions)

                ' Get the current ACL. This requires 
                ' MutexRights.ReadPermissions.
                Dim mSec As MutexSecurity = m.GetAccessControl()
                
                Dim user As String = Environment.UserDomainName _ 
                    & "\" & Environment.UserName

                ' First, the rule that denied the current user 
                ' the right to enter and release the mutex must
                ' be removed.
                Dim rule As New MutexAccessRule(user, _
                    MutexRights.Synchronize Or MutexRights.Modify, _
                    AccessControlType.Deny)
                mSec.RemoveAccessRule(rule)

                ' Now grant the user the correct rights.
                ' 
                rule = New MutexAccessRule(user, _
                    MutexRights.Synchronize Or 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 
                ' Or MutexRights.Modify), the rights required to
                ' enter and release the mutex.
                '
                m = Mutex.OpenExisting(mutexName)

            Catch ex As UnauthorizedAccessException
                Console.WriteLine("Unable to change permissions: {0}", _
                    ex.Message)
                Return
            End Try

        End If

        ' If this program created the mutex, it already owns
        ' the mutex.
        '
        If Not mutexWasCreated Then
            ' 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 ex As UnauthorizedAccessException
                Console.WriteLine("Unauthorized access: {0}", _
                    ex.Message)
            End Try
        End If

        Console.WriteLine("Press the Enter key to exit.")
        Console.ReadLine()
        m.ReleaseMutex()
        m.Dispose()
    End Sub 
End Class

Poznámky

Může name mít předponu Global\ nebo Local\ zadat obor názvů. Global Po zadání oboru názvů může být synchronizační objekt sdílen se všemi procesy v systému. Local Pokud je zadán obor názvů, což je také výchozí, pokud není zadán žádný obor názvů, synchronizační objekt může být sdílen s procesy ve stejné relaci. Na Windows je relace relace přihlášení a služby se obvykle spouští v jiné neinteraktivní relaci. V operačních systémech Unix má každé prostředí vlastní relaci. Objekty místní synchronizace relace můžou být vhodné pro synchronizaci mezi procesy s vztahem nadřazenosti nebo podřízenosti, kde se všechny spouští ve stejné relaci. Další informace o názvech synchronizačních objektů v Windows najdete v tématu Názvové objektyobjektu.

Pokud v oboru názvů existuje objekt synchronizace požadovaného typu, otevře se existující objekt synchronizace. Pokud synchronizační objekt v oboru názvů neexistuje nebo existuje objekt synchronizace jiného typu v oboru názvů, WaitHandleCannotBeOpenedException vyvolá se.

Metoda OpenExisting se pokusí otevřít zadaný pojmenovaný systémový mutex. Chcete-li vytvořit systémový mutex, pokud ještě neexistuje, použijte jeden z Mutex konstruktorů, které mají name parametr.

Více volání této metody, které používají stejnou hodnotu pro name nemusí nutně vrátit stejný Mutex objekt, i když vrácené objekty představují stejný pojmenovaný systémový mutex.

Toto přetížení metody je ekvivalentní volání OpenExisting(String, MutexRights) přetížení metody a určení MutexRights.Synchronize a MutexRights.Modify práva v kombinaci pomocí bitové OPERACE OR.

Určení příznaku MutexRights.Synchronize umožňuje vláknu čekat na mutex a zadáním MutexRights.Modify příznaku umožňuje vlákno volat metodu ReleaseMutex .

Tato metoda nevyžaduje vlastnictví mutexu.

OpenExisting(String, NamedWaitHandleOptions)

Zdroj:

Mutex.cs

Otevře zadaný pojmenovaný mutex, pokud již existuje. Pokud jsou možnosti nastaveny pouze na aktuálního uživatele, ověří se u volajícího uživatele řízení přístupu objektu.

public:
 static System::Threading::Mutex ^ OpenExisting(System::String ^ name, System::Threading::NamedWaitHandleOptions options);

public static System.Threading.Mutex OpenExisting(string name, System.Threading.NamedWaitHandleOptions options);

static member OpenExisting : string * System.Threading.NamedWaitHandleOptions -> System.Threading.Mutex

Public Shared Function OpenExisting (name As String, options As NamedWaitHandleOptions) As Mutex

Parametry

name

String

Název synchronizačního objektu, který se má sdílet s jinými procesy. Název je citlivý na velikost písmen.

options

NamedWaitHandleOptions

Možnosti oboru pojmenovaného systémového mutexu. Ve výchozím nastavení je přístup omezený pouze na aktuálního uživatele a aktuální relaci. Zadané možnosti můžou mít vliv na obor názvů pro název a přístup k podkladovému systémovému objektu mutex.

Návraty

Mutex

Objekt, který představuje pojmenovaný systémový mutex.

Výjimky

ArgumentException

name je prázdný řetězec.

ArgumentNullException

name je null.

WaitHandleCannotBeOpenedException

Synchronizační objekt se zadaným objektem name nelze vytvořit. Synchronizační objekt jiného typu může mít stejný název. V některých případech může být tato výjimka vyvolán pro neplatné názvy.

nebo

Objekt se zadaným name objektem existuje, ale zadaný options objekt není kompatibilní s možnostmi existujícího objektu.

IOException

name je neplatný. Může to být z různých důvodů, včetně některých omezení, která může operační systém umístit, například neznámé předpony nebo neplatné znaky. Všimněte si, že název a běžné předpony "Global\" a "Local\" rozlišují malá a velká písmena.

nebo

Došlo k nějaké jiné chybě. Vlastnost HResult může poskytnout další informace.

DirectoryNotFoundException

pouze Windows: name zadal neznámý obor názvů. Další informace najdete v tématu Názvy objektů .

PathTooLongException

name je příliš dlouhý. Omezení délky můžou záviset na operačním systému nebo konfiguraci.

UnauthorizedAccessException

Pojmenovaný mutex existuje, ale uživatel nemá přístup zabezpečení potřebný k jeho použití.

Poznámky

Pokud v oboru názvů existuje objekt synchronizace požadovaného typu, otevře se existující objekt synchronizace. Pokud options však určuje přístup omezený na aktuálního uživatele a synchronizační objekt není kompatibilní s ním, WaitHandleCannotBeOpenedException vyvolá se vyvolá. Pokud synchronizační objekt v oboru názvů neexistuje nebo existuje objekt synchronizace jiného typu v oboru názvů, WaitHandleCannotBeOpenedException vyvolá se také.

Metoda OpenExisting se pokusí otevřít zadaný pojmenovaný systémový mutex. Chcete-li vytvořit systémový mutex, pokud ještě neexistuje, použijte jeden z Mutex konstruktorů, které mají name parametr.

Více volání této metody, které používají stejnou hodnotu pro name nemusí nutně vrátit stejný Mutex objekt, i když vrácené objekty představují stejný pojmenovaný systémový mutex.

Tato metoda nevyžaduje vlastnictví mutexu.