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 EventWaitHandle.OpenExisting (String, EventWaitHandleRights)

 

Data di pubblicazione: ottobre 2016

Apre lo specificato denominato evento di sincronizzazione, se esiste già, con l'accesso di sicurezza desiderato.

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

[SecurityCriticalAttribute]
public static EventWaitHandle OpenExisting(
	string name,
	EventWaitHandleRights rights
)

Parametri

name
Type: System.String

Il nome dell'evento di sincronizzazione del sistema da aprire.

rights
Type: System.Security.AccessControl.EventWaitHandleRights

Combinazione bit per bit dei valori di enumerazione che rappresentano l'accesso di sicurezza desiderato.

Valore restituito

Type: System.Threading.EventWaitHandle

Oggetto che rappresenta l'evento 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

L'evento di sistema denominato non esiste.

IOException

Errore Win32.

UnauthorizedAccessException

L'evento denominato esiste, ma l'utente non dispone di accesso di sicurezza desiderato.

Il rights parametro deve includere il EventWaitHandleRights.Synchronize flag per consentire ai thread in attesa dell'evento e il EventWaitHandleRights.Modify flag per consentire ai thread di chiamare il Set e Reset metodi.

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

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

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

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

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, EventWaitHandleRights) overload del metodo per attendere l'evento con i diritti necessari per leggere e modificare le autorizzazioni.

Dopo la modifica delle autorizzazioni, l'evento viene aperto con i diritti necessari per l'attesa e la segnalazione. Se si esegue l'esempio compilato da una terza finestra di comando, nell'esempio viene eseguito con le nuove autorizzazioni.

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

internal class Example
{
    internal static void Main()
    {
        const string ewhName = "EventWaitHandleExample5";

        EventWaitHandle ewh = null;
        bool doesNotExist = false;
        bool unauthorized = false;

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

        // Attempt to open the named event.
        try
        {
            // Open the event with (EventWaitHandleRights.Synchronize
            // | EventWaitHandleRights.Modify), to wait on and 
            // signal the named event.
            //
            ewh = EventWaitHandle.OpenExisting(ewhName);
        }
        catch (WaitHandleCannotBeOpenedException)
        {
            Console.WriteLine("Named event does not exist.");
            doesNotExist = true;
        }
        catch (UnauthorizedAccessException ex)
        {
            Console.WriteLine("Unauthorized access: {0}", ex.Message);
            unauthorized = true;
        }

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

            // Create an access control list (ACL) that denies the
            // current user the right to wait on or signal the 
            // event, but allows the right to read and change
            // security information for the event.
            //
            string user = Environment.UserDomainName + "\\"
                + Environment.UserName;
            EventWaitHandleSecurity ewhSec = 
                new EventWaitHandleSecurity();

            EventWaitHandleAccessRule rule = 
                new EventWaitHandleAccessRule(user, 
                    EventWaitHandleRights.Synchronize | 
                    EventWaitHandleRights.Modify, 
                    AccessControlType.Deny);
            ewhSec.AddAccessRule(rule);

            rule = new EventWaitHandleAccessRule(user, 
                EventWaitHandleRights.ReadPermissions | 
                EventWaitHandleRights.ChangePermissions, 
                AccessControlType.Allow);
            ewhSec.AddAccessRule(rule);

            // Create an EventWaitHandle object that represents
            // the system event named by the constant 'ewhName', 
            // initially signaled, with automatic reset, and with
            // the specified security access. The Boolean value that 
            // indicates creation of the underlying system object
            // is placed in wasCreated.
            //
            ewh = new EventWaitHandle(true, 
                EventResetMode.AutoReset, 
                ewhName, 
                out wasCreated, 
                ewhSec);

            // If the named system event 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 event. Otherwise, exit the program.
            // 
            if (wasCreated)
            {
                Console.WriteLine("Created the named event.");
            }
            else
            {
                Console.WriteLine("Unable to create the event.");
                return;
            }
        }
        else if (unauthorized)
        {
            // Open the event to read and change the access control
            // security. The access control security defined above
            // allows the current user to do this.
            //
            try
            {
                ewh = EventWaitHandle.OpenExisting(ewhName, 
                    EventWaitHandleRights.ReadPermissions | 
                    EventWaitHandleRights.ChangePermissions);

                // Get the current ACL. This requires 
                // EventWaitHandleRights.ReadPermissions.
                EventWaitHandleSecurity ewhSec = ewh.GetAccessControl();

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

                // First, the rule that denied the current user 
                // the right to enter and release the event must
                // be removed.
                EventWaitHandleAccessRule rule = 
                    new EventWaitHandleAccessRule(user, 
                        EventWaitHandleRights.Synchronize | 
                        EventWaitHandleRights.Modify, 
                        AccessControlType.Deny);
                ewhSec.RemoveAccessRule(rule);

                // Now grant the user the correct rights.
                // 
                rule = new EventWaitHandleAccessRule(user, 
                    EventWaitHandleRights.Synchronize | 
                    EventWaitHandleRights.Modify, 
                    AccessControlType.Allow);
                ewhSec.AddAccessRule(rule);

                // Update the ACL. This requires
                // EventWaitHandleRights.ChangePermissions.
                ewh.SetAccessControl(ewhSec);

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

                // Open the event with (EventWaitHandleRights.Synchronize 
                // | EventWaitHandleRights.Modify), the rights required
                // to wait on and signal the event.
                //
                ewh = EventWaitHandle.OpenExisting(ewhName);

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

        }

        // Wait on the event, and hold it until the program
        // exits.
        //
        try
        {
            Console.WriteLine("Wait on the event.");
            ewh.WaitOne();
            Console.WriteLine("Event was signaled.");
            Console.WriteLine("Press the Enter key to signal the event and exit.");
            Console.ReadLine();
        }
        catch (UnauthorizedAccessException ex)
        {
            Console.WriteLine("Unauthorized access: {0}", ex.Message);
        }
        finally
        {
            ewh.Set();
        }
    }
}

SecurityCriticalAttribute

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

.NET Framework
Disponibile da 2.0
Torna all'inizio
Mostra: