Semaphore.OpenExisting Metódus

Definíció

Névtér:

System.Threading

Szerelvények:

netstandard.dll, System.Threading.dll

Megnyitja a megadott nevű szemaphore-t, ha már létezik.

Túlterhelések

Név	Description
OpenExisting(String)	Megnyitja a megadott névvel ellátott szemaphore-t, ha már létezik.
OpenExisting(String, NamedWaitHandleOptions)	Megnyitja a megadott névvel ellátott szemaphore-t, ha már létezik. Ha a beállítások csak az aktuális felhasználóra vannak beállítva, a rendszer ellenőrzi az objektum hozzáférés-vezérlését a hívó felhasználó számára.

OpenExisting(String)

Forrás:

Semaphore.cs

Megnyitja a megadott névvel ellátott szemaphore-t, ha már létezik.

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

[System.Runtime.Versioning.SupportedOSPlatform("windows")]
public static System.Threading.Semaphore OpenExisting(string name);

[<System.Runtime.Versioning.SupportedOSPlatform("windows")>]
static member OpenExisting : string -> System.Threading.Semaphore

Public Shared Function OpenExisting (name As String) As Semaphore

Paraméterek

name

String

A más folyamatokkal megosztani kívánt szinkronizálási objektum neve. A név megkülönbözteti a kis- és nagybetűket. A fordított perjel karakter (\) fenntartott, és csak névtér megadására használható. A névterekről további információt a megjegyzések szakaszban talál. Az operációs rendszertől függően további korlátozások is lehetnek a névre. Unix-alapú operációs rendszereken például a névtér kizárása utáni névnek érvényes fájlnévnek kell lennie.

Válaszok

Semaphore

Egy objektum, amely a nevesített rendszerszemafort jelöli.

Attribútumok

SupportedOSPlatformAttribute

Kivételek

ArgumentException

name üres sztring.

-vagy-

csak .NET keretrendszer: name hosszabb, mint MAX_PATH (260 karakter).

ArgumentNullException

name az null.

WaitHandleCannotBeOpenedException

A megadott name szinkronizálási objektum nem hozható létre. Előfordulhat, hogy egy másik típusú szinkronizálási objektum neve megegyezik. Bizonyos esetekben előfordulhat, hogy ez a kivétel érvénytelen nevek esetén jelenik meg.

IOException

name érvénytelen. Ennek különböző okai lehetnek, beleértve az operációs rendszer által esetleg elhelyezett korlátozásokat, például ismeretlen előtagot vagy érvénytelen karaktereket. Vegye figyelembe, hogy a "Global\" és a "Local\" név és gyakori előtagok megkülönböztetik a kis- és nagybetűket.

-vagy-

Más hiba történt. Előfordulhat, hogy a HResult tulajdonság további információkat tartalmaz.

PathTooLongException

Túl name hosszú. A hosszkorlátozások az operációs rendszertől vagy a konfigurációtól függhetnek.

UnauthorizedAccessException

A névvel ellátott szemaphore létezik, de a felhasználó nem rendelkezik a használatához szükséges biztonsági hozzáféréssel.

Példák

Az alábbi példakód egy elnevezett, hozzáférés-vezérlési biztonsággal rendelkező szemapó folyamatközi viselkedését mutatja be. A példa a OpenExisting(String) metódus túlterhelésével teszteli a nevesített szemapóra meglétét.

Ha a szemaphore nem létezik, akkor a rendszer legfeljebb két darabszámmal és hozzáférés-vezérlési biztonsággal hozza létre, amely tagadja az aktuális felhasználót a szemaphore használatára vonatkozó jogtól, de amely jogot biztosít a szemapóre engedélyeinek olvasására és módosítására.

Ha a lefordított példát két parancsablakból futtatja, a második példány hozzáférés-megsértési kivételt küld a metódus túlterhelésére irányuló hívásra OpenExisting(String) . A kivétel kivételt kap, és a példa a OpenExisting(String, SemaphoreRights) metódus túlterhelésével nyitja meg a szemafort az olvasáshoz és az engedélyek módosításához szükséges jogosultságokkal.

Az engedélyek módosítása után a szemaphore megnyílik a belépéshez és a kiadáshoz szükséges jogosultságokkal. Ha a lefordított példát egy harmadik parancsablakból futtatja, az új engedélyekkel fut.

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

Imports System.Threading
Imports System.Security.AccessControl

Friend Class Example

    <MTAThread> _
    Friend Shared Sub Main()
        Const semaphoreName As String = "SemaphoreExample5"

        Dim sem As Semaphore = Nothing
        Dim doesNotExist as Boolean = False
        Dim unauthorized As Boolean = False

        ' Attempt to open the named semaphore.
        Try
            ' Open the semaphore with (SemaphoreRights.Synchronize
            ' Or SemaphoreRights.Modify), to enter and release the
            ' named semaphore.
            '
            sem = Semaphore.OpenExisting(semaphoreName)
        Catch ex As WaitHandleCannotBeOpenedException
            Console.WriteLine("Semaphore 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 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 Then
            ' 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.
            '
            Dim semaphoreWasCreated As Boolean

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

            Dim rule As New SemaphoreAccessRule(user, _
                SemaphoreRights.Synchronize Or SemaphoreRights.Modify, _
                AccessControlType.Deny)
            semSec.AddAccessRule(rule)

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

        ElseIf unauthorized Then

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

                ' Get the current ACL. This requires 
                ' SemaphoreRights.ReadPermissions.
                Dim semSec As SemaphoreSecurity = sem.GetAccessControl()
                
                Dim user As String = Environment.UserDomainName _ 
                    & "\" & Environment.UserName

                ' First, the rule that denied the current user 
                ' the right to enter and release the semaphore must
                ' be removed.
                Dim rule As New SemaphoreAccessRule(user, _
                    SemaphoreRights.Synchronize Or SemaphoreRights.Modify, _
                    AccessControlType.Deny)
                semSec.RemoveAccessRule(rule)

                ' Now grant the user the correct rights.
                ' 
                rule = New SemaphoreAccessRule(user, _
                    SemaphoreRights.Synchronize Or 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 
                ' Or SemaphoreRights.Modify), the rights required to
                ' enter and release the semaphore.
                '
                sem = Semaphore.OpenExisting(semaphoreName)

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

        End If

        ' 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 ex As UnauthorizedAccessException
            Console.WriteLine("Unauthorized access: {0}", _
                ex.Message)
        End Try
    End Sub 
End Class

Megjegyzések

Az name előtag lehet névtérrel, Global\ vagy Local\ megadható. Global A névtér megadása után a szinkronizálási objektum megosztható a rendszer bármely folyamatával. Ha a Local névtér meg van adva, ami szintén az alapértelmezett, ha nincs megadva névtér, a szinkronizálási objektum megosztható az ugyanabban a munkamenetben lévő folyamatokkal. A Windows a munkamenet egy bejelentkezési munkamenet, és a szolgáltatások általában egy másik, nem interaktív munkamenetben futnak. Unix-szerű operációs rendszereken minden rendszerhéj saját munkamenettel rendelkezik. A munkamenet-helyi szinkronizálási objektumok megfelelőek lehetnek a szülő-gyermek kapcsolattal rendelkező folyamatok közötti szinkronizáláshoz, ahol mind ugyanabban a munkamenetben futnak. Az Windows szinkronizálási objektumneveiről további információt a Object Names című témakörben talál.

Ha a névtérben a kért típusú szinkronizálási objektum található, a meglévő szinkronizálási objektum megnyílik. Ha egy szinkronizálási objektum nem létezik a névtérben, vagy egy másik típusú szinkronizálási objektum található a névtérben, a program eldobja az objektumot WaitHandleCannotBeOpenedException .

A OpenExisting metódus megpróbálja megnyitni a megadott nevű szemaphore-t. Ha még nem létezik rendszerszemafortot létrehozni, használja a Semaphore paraméterrel name rendelkező konstruktorok egyikét.

A metódus több hívása, amelyek ugyanazt az értéket name használják, nem feltétlenül ugyanazt Semaphore az objektumot adják vissza, annak ellenére, hogy a visszaadott objektumok ugyanazt a nevesített rendszerszemaphore-t képviselik.

Ez a metódus túlterhelése egyenértékű a metódus túlterhelésének OpenExisting meghívásával, valamint a megadásával SemaphoreRights.Synchronize és SemaphoreRights.Modify a jogosultságokkal, a bitenkénti VAGY művelettel kombinálva.

A jelölő megadásával egy SemaphoreRights.Synchronize szál beléphet a szemaforba, a jelölő megadásával SemaphoreRights.Modify pedig egy szál meghívhatja a metódust Release .

Lásd még

• felügyelt szálkezelés
• Szemafor

OpenExisting(String, NamedWaitHandleOptions)

Forrás:

Semaphore.cs

Megnyitja a megadott névvel ellátott szemaphore-t, ha már létezik. Ha a beállítások csak az aktuális felhasználóra vannak beállítva, a rendszer ellenőrzi az objektum hozzáférés-vezérlését a hívó felhasználó számára.

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

[System.Runtime.Versioning.SupportedOSPlatform("windows")]
public static System.Threading.Semaphore OpenExisting(string name, System.Threading.NamedWaitHandleOptions options);

[<System.Runtime.Versioning.SupportedOSPlatform("windows")>]
static member OpenExisting : string * System.Threading.NamedWaitHandleOptions -> System.Threading.Semaphore

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

Paraméterek

name

String

A más folyamatokkal megosztani kívánt szinkronizálási objektum neve. A név megkülönbözteti a kis- és nagybetűket. A fordított perjel karakter (\) fenntartott, és csak névtér megadására használható. A névterekről további információt a megjegyzések szakaszban talál.

options

NamedWaitHandleOptions

A névvel ellátott szemapóra hatókörbeállításai. Alapértelmezés szerint a hozzáférés csak az aktuális felhasználóra és az aktuális munkamenetre korlátozódik. A megadott beállítások hatással lehetnek a névtérre és a mögöttes szemaphore objektumhoz való hozzáférésre.

Válaszok

Semaphore

Egy objektum, amely a nevesített rendszerszemafort jelöli.

Attribútumok

SupportedOSPlatformAttribute

Kivételek

ArgumentException

name üres sztring.

ArgumentNullException

name az null.

WaitHandleCannotBeOpenedException

A megadott name szinkronizálási objektum nem hozható létre. Előfordulhat, hogy egy másik típusú szinkronizálási objektum neve megegyezik.

-vagy-

A megadott name objektum létezik, de a megadott options objektum nem kompatibilis a meglévő objektum beállításaival.

IOException

name érvénytelen. Ennek különböző okai lehetnek, beleértve az operációs rendszer által esetleg elhelyezett korlátozásokat, például ismeretlen előtagot vagy érvénytelen karaktereket. Vegye figyelembe, hogy a "Global\" és a "Local\" név és gyakori előtagok megkülönböztetik a kis- és nagybetűket.

-vagy-

Más hiba történt. Előfordulhat, hogy a HResult tulajdonság további információkat tartalmaz.

PathTooLongException

Túl name hosszú. A hosszkorlátozások az operációs rendszertől vagy a konfigurációtól függhetnek.

UnauthorizedAccessException

A névvel ellátott szemaphore létezik, de a felhasználó nem rendelkezik a használatához szükséges biztonsági hozzáféréssel.

Megjegyzések

Ha a névtérben a kért típusú szinkronizálási objektum található, a meglévő szinkronizálási objektum megnyílik. Ha azonban az aktuális felhasználó számára korlátozott hozzáférést ad meg, options és a szinkronizálási objektum nem kompatibilis vele, akkor a rendszer eldobja a parancsot WaitHandleCannotBeOpenedException . Ha egy szinkronizálási objektum nem létezik a névtérben, vagy egy másik típusú szinkronizálási objektum létezik a névtérben, WaitHandleCannotBeOpenedException akkor a program a névtérben is megjelenik.

A OpenExisting metódus megpróbálja megnyitni a megadott nevű szemaphore-t. Ha még nem létezik rendszerszemafortot létrehozni, használja a Semaphore paraméterrel name rendelkező konstruktorok egyikét.

A metódus több hívása, amelyek ugyanazt az értéket name használják, nem feltétlenül ugyanazt Semaphore az objektumot adják vissza, annak ellenére, hogy a visszaadott objektumok ugyanazt a nevesített rendszerszemaphore-t képviselik.

Lásd még

• felügyelt szálkezelés
• Szemafor