Semaphore.OpenExisting Méthode

Définition

Espace de noms:

System.Threading

Assemblys:

netstandard.dll, System.Threading.dll

Ouvre un sémaphore nommé spécifié, s’il existe déjà.

Surcharges

Nom	Description
OpenExisting(String)	Ouvre le sémaphore nommé spécifié, s’il existe déjà.
OpenExisting(String, NamedWaitHandleOptions)	Ouvre le sémaphore nommé spécifié, s’il existe déjà. Si les options sont définies sur l’utilisateur actuel uniquement, les contrôles d’accès de l’objet sont vérifiés pour l’utilisateur appelant.

OpenExisting(String)

Source:

Semaphore.cs

Ouvre le sémaphore nommé spécifié, s’il existe déjà.

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ètres

name

String

Nom de l’objet de synchronisation à partager avec d’autres processus. Le nom respecte la casse. La barre oblique inverse (\) est réservée et peut uniquement être utilisée pour spécifier un espace de noms. Pour plus d’informations sur les espaces de noms, consultez la section remarques. Il peut y avoir d’autres restrictions sur le nom en fonction du système d’exploitation. Par exemple, sur les systèmes d’exploitation Unix, le nom après l’exclusion de l’espace de noms doit être un nom de fichier valide.

Retours

Semaphore

Objet qui représente le sémaphore système nommé.

Attributs

SupportedOSPlatformAttribute

Exceptions

ArgumentException

name est une chaîne vide.

- ou -

.NET Framework uniquement : name est plus long que MAX_PATH (260 caractères).

ArgumentNullException

name a la valeur null.

WaitHandleCannotBeOpenedException

Impossible de créer un objet de synchronisation avec l’objet fourni name . Un objet de synchronisation d’un type différent peut avoir le même nom. Dans certains cas, cette exception peut être levée pour les noms non valides.

IOException

name n’est pas valide. Cela peut être pour diverses raisons, notamment certaines restrictions qui peuvent être placées par le système d’exploitation, telles qu’un préfixe inconnu ou des caractères non valides. Notez que le nom et les préfixes communs « Global\ » et « Local\ » respectent la casse.

- ou -

Il y a eu une autre erreur. La HResult propriété peut fournir plus d’informations.

PathTooLongException

name est trop long. Les restrictions de longueur peuvent dépendre du système d’exploitation ou de la configuration.

UnauthorizedAccessException

Le sémaphore nommé existe, mais l’utilisateur n’a pas l’accès de sécurité requis pour l’utiliser.

Exemples

L’exemple de code suivant illustre le comportement interprocesseur d’un sémaphore nommé avec la sécurité du contrôle d’accès. L’exemple utilise la OpenExisting(String) surcharge de méthode pour tester l’existence d’un sémaphore nommé.

Si le sémaphore n’existe pas, il est créé avec un nombre maximal de deux et avec la sécurité de contrôle d’accès qui refuse à l’utilisateur actuel le droit d’utiliser le sémaphore, mais qui accorde le droit de lire et de modifier les autorisations sur le sémaphore.

Si vous exécutez l’exemple compilé à partir de deux fenêtres de commandes, la deuxième copie lève une exception de violation d’accès sur l’appel à la OpenExisting(String) surcharge de méthode. L’exception est interceptée et l’exemple utilise la OpenExisting(String, SemaphoreRights) surcharge de méthode pour ouvrir le sémaphore avec les droits nécessaires pour lire et modifier les autorisations.

Une fois les autorisations modifiées, le sémaphore est ouvert avec les droits requis pour entrer et le libérer. Si vous exécutez l’exemple compilé à partir d’une troisième fenêtre de commande, il s’exécute à l’aide des nouvelles autorisations.

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

Remarques

Il name peut être préfixé Global\ ou Local\ spécifier un espace de noms. Lorsque l’espace Global de noms est spécifié, l’objet de synchronisation peut être partagé avec tous les processus sur le système. Lorsque l’espace Local de noms est spécifié, qui est également la valeur par défaut lorsqu’aucun espace de noms n’est spécifié, l’objet de synchronisation peut être partagé avec des processus dans la même session. Sur Windows, une session est une session de connexion, et les services s’exécutent généralement dans une autre session non interactive. Sur les systèmes d’exploitation de type Unix, chaque interpréteur de commandes a sa propre session. Les objets de synchronisation locale de session peuvent être appropriés pour la synchronisation entre les processus avec une relation parent/enfant où ils s’exécutent tous dans la même session. Pour plus d’informations sur les noms d’objets de synchronisation sur Windows, consultez Object Names.

Si un objet de synchronisation du type demandé existe dans l’espace de noms, l’objet de synchronisation existant est ouvert. Si un objet de synchronisation n’existe pas dans l’espace de noms ou qu’un objet de synchronisation d’un type différent existe dans l’espace de noms, un WaitHandleCannotBeOpenedException objet est levée.

La OpenExisting méthode tente d’ouvrir le sémaphore nommé spécifié. Pour créer le sémaphore système lorsqu’il n’existe pas déjà, utilisez l’un Semaphore des constructeurs qui ont un name paramètre.

Plusieurs appels à cette méthode qui utilisent la même valeur pour name ne pas nécessairement retourner le même Semaphore objet, même si les objets retournés représentent le même sémaphore système nommé.

Cette surcharge de méthode est équivalente à l’appel de la OpenExisting surcharge de méthode et à la spécification et SemaphoreRights.Modify aux SemaphoreRights.Synchronize droits, combinés à l’aide de l’opération OR au niveau du bit.

La spécification de l’indicateur SemaphoreRights.Synchronize permet à un thread d’entrer le sémaphore et de spécifier l’indicateur SemaphoreRights.Modify permet à un thread d’appeler la Release méthode.

Voir aussi

• Threading managé
• Sémaphore

OpenExisting(String, NamedWaitHandleOptions)

Source:

Semaphore.cs

Ouvre le sémaphore nommé spécifié, s’il existe déjà. Si les options sont définies sur l’utilisateur actuel uniquement, les contrôles d’accès de l’objet sont vérifiés pour l’utilisateur appelant.

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ètres

name

String

Nom de l’objet de synchronisation à partager avec d’autres processus. Le nom respecte la casse. La barre oblique inverse (\) est réservée et peut uniquement être utilisée pour spécifier un espace de noms. Pour plus d’informations sur les espaces de noms, consultez la section remarques.

options

NamedWaitHandleOptions

Options d’étendue pour le sémaphore nommé. Par défaut, l’accès est limité à l’utilisateur actuel et à la session active uniquement. Les options spécifiées peuvent affecter l’espace de noms pour le nom et l’accès à l’objet sémaphore sous-jacent.

Retours

Semaphore

Objet qui représente le sémaphore système nommé.

Attributs

SupportedOSPlatformAttribute

Exceptions

ArgumentException

name est une chaîne vide.

ArgumentNullException

name a la valeur null.

WaitHandleCannotBeOpenedException

Impossible de créer un objet de synchronisation avec l’objet fourni name . Un objet de synchronisation d’un type différent peut avoir le même nom.

- ou -

Un objet avec l’objet spécifié name existe, mais les options options spécifiées ne sont pas compatibles avec les options de l’objet existant.

IOException

name n’est pas valide. Cela peut être pour diverses raisons, notamment certaines restrictions qui peuvent être placées par le système d’exploitation, telles qu’un préfixe inconnu ou des caractères non valides. Notez que le nom et les préfixes communs « Global\ » et « Local\ » respectent la casse.

- ou -

Il y a eu une autre erreur. La HResult propriété peut fournir plus d’informations.

PathTooLongException

name est trop long. Les restrictions de longueur peuvent dépendre du système d’exploitation ou de la configuration.

UnauthorizedAccessException

Le sémaphore nommé existe, mais l’utilisateur n’a pas l’accès de sécurité requis pour l’utiliser.

Remarques

Si un objet de synchronisation du type demandé existe dans l’espace de noms, l’objet de synchronisation existant est ouvert. Toutefois, si options l’accès est limité à l’utilisateur actuel et que l’objet de synchronisation n’est pas compatible avec celui-ci, un WaitHandleCannotBeOpenedException accès est levée. Si un objet de synchronisation n’existe pas dans l’espace de noms ou qu’un objet de synchronisation d’un type différent existe dans l’espace de noms, il WaitHandleCannotBeOpenedException est également levée.

La OpenExisting méthode tente d’ouvrir le sémaphore nommé spécifié. Pour créer le sémaphore système lorsqu’il n’existe pas déjà, utilisez l’un Semaphore des constructeurs qui ont un name paramètre.

Plusieurs appels à cette méthode qui utilisent la même valeur pour name ne pas nécessairement retourner le même Semaphore objet, même si les objets retournés représentent le même sémaphore système nommé.

Voir aussi

• Threading managé
• Sémaphore