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 WaitHandle.WaitAny (WaitHandle[], Int32, Boolean)

 

Data di pubblicazione: ottobre 2016

Attende che uno degli elementi nella matrice specificata riceva un segnale, usando un intero con segno a 32 bit per specificare l'intervallo di tempo e indicando se uscire dal dominio di sincronizzazione prima dell'attesa.

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

public static int WaitAny(
	WaitHandle[] waitHandles,
	int millisecondsTimeout,
	bool exitContext
)

Parametri

waitHandles
Type: System.Threading.WaitHandle[]

Matrice WaitHandle contenente gli oggetti per i quali l'istanza corrente attenderà.

millisecondsTimeout
Type: System.Int32

Numero di millisecondi di attesa oppure Timeout.Infinite (-1) per un'attesa indefinita.

exitContext
Type: System.Boolean

true per uscire dal dominio di sincronizzazione per il contesto prima dell'attesa, se all'interno di un contesto sincronizzato, e riacquisirlo successivamente; in caso contrario, false.

Valore restituito

Type: System.Int32

Indice della matrice dell'oggetto che ha soddisfatto l'attesa oppure WaitTimeout se nessun oggetto ha soddisfatto l'attesa ed è trascorso un intervallo di tempo equivalente a millisecondsTimeout.

Exception Condition
ArgumentNullException

Il valore del parametro waitHandles è null.

-oppure-

Uno o più degli oggetti di waitHandles matrice null.

NotSupportedException

Il numero di oggetti in waitHandles è maggiore di quanto consentito dal sistema.

ApplicationException

waitHandles è una matrice senza elementi e la versione di .NET Framework è 1.0 o 1.1.

ArgumentOutOfRangeException

millisecondsTimeout è un numero negativo diverso da -1, che rappresenta un timeout infinito.

AbandonedMutexException

Attesa completata perché un thread terminato senza rilasciare il mutex. In Windows 98 o Windows Millennium Edition non viene generata questa eccezione.

ArgumentException

waitHandles è una matrice senza elementi e la versione di .NET Framework è 2.0 o versione successiva.

InvalidOperationException

Il waitHandles matrice contiene un proxy trasparente per un WaitHandle in un altro dominio applicazione.

Se millisecondsTimeout è zero, il metodo si blocca. Il test dello stato degli handle di attesa e restituisce immediatamente.

AbandonedMutexException è stato introdotto in .NET Framework versione 2.0. Nelle versioni precedenti, il WaitAny restituisce true Se il tempo di attesa viene completata perché un mutex viene abbandonato. Un mutex abbandonato indica spesso un errore di codifica grave. Nel caso di un mutex di sistema, potrebbe indicare che un'applicazione è stata terminata in modo anomalo (ad esempio, utilizzando Gestione attività Windows). L'eccezione contiene informazioni utili per il debug.

Il WaitAny genererà un AbandonedMutexException solo quando l'attesa viene completata a causa di un mutex abbandonato. Se waitHandles contiene un mutex rilasciato con un numero di indice inferiore rispetto al mutex abbandonato la WaitAny metodo viene completata e non viene generata l'eccezione.

System_CAPS_noteNota

Nelle versioni di .NET Framework precedenti alla versione 2.0, se un thread viene chiuso o annullato senza rilasciare esplicitamente un Mutex, e che Mutex in corrispondenza dell'indice 0 (zero) è un WaitAny matrice in un altro thread, l'indice restituito da WaitAny è 128 anziché 0.

Questo metodo viene restituito quando l'attesa termina quando uno degli handle di segnale o quando si verifica un timeout. Se più di un oggetto diventa segnalato durante la chiamata, il valore restituito è l'indice della matrice dell'oggetto con il valore di indice minimo di tutti gli oggetti segnalati segnalato. In alcune implementazioni, se più di 64 handle vengono passati, un NotSupportedException viene generata un'eccezione.

Il exitContext parametro ha effetto solo se il WaitAny metodo chiamato dall'interno di un contesto gestito. Questa situazione può verificarsi se il thread si trova all'interno di una chiamata a un'istanza di una classe derivata da ContextBoundObject. Anche se un metodo attualmente in esecuzione in una classe che deriva da ContextBoundObject, come String, è possibile trovarsi in un contesto non predefinito se un ContextBoundObject nello stack nel dominio applicazione corrente.

Quando il codice è in esecuzione in un contesto non predefinito, specificare true per exitContext fa sì che il thread esce dal contesto gestito (vale a dire a cui passare il contesto predefinito) prima di eseguire il WaitAny (metodo). Il thread viene restituito il contesto non predefinito originale dopo la chiamata al WaitAny metodo viene completato.

Ciò può essere utile quando la classe associata al contesto dispone SynchronizationAttribute. In tal caso, vengono sincronizzate automaticamente tutte le chiamate ai membri della classe e il dominio di sincronizzazione è l'intero corpo del codice per la classe. Se viene chiamato codice nello stack di chiamate di un membro di WaitAny (metodo) e specifica true per exitContext, il dominio di sincronizzazione, consentendo a un thread bloccato su una chiamata a un membro dell'oggetto di procedere si esce dal thread. Quando il WaitAny metodo viene restituito, il thread che ha effettuato la chiamata deve attendere di riaccedere al dominio di sincronizzazione.

Esempio di codice seguente viene illustrato come utilizzare il pool di thread per cercare simultaneamente un file su più dischi. Per motivi di spazio, viene cercata solo nella directory radice di ogni disco.

using System;
using System.IO;
using System.Threading;

class Test
{
    static void Main()
    {
        Search search = new Search();
        search.FindFile("SomeFile.dat");
    }
}

class Search
{
    // Maintain state information to pass to FindCallback.
    class State
    {
        public AutoResetEvent autoEvent;
        public string         fileName;

        public State(AutoResetEvent autoEvent, string fileName)
        {
            this.autoEvent    = autoEvent;
            this.fileName     = fileName;
        }
    }

    AutoResetEvent[] autoEvents;
    String[] diskLetters;

    public Search()
    {
        // Retrieve an array of disk letters.
        diskLetters = Environment.GetLogicalDrives();

        autoEvents = new AutoResetEvent[diskLetters.Length];
        for(int i = 0; i < diskLetters.Length; i++)
        {
            autoEvents[i] = new AutoResetEvent(false);
        }
    }

    // Search for fileName in the root directory of all disks.
    public void FindFile(string fileName)
    {
        for(int i = 0; i < diskLetters.Length; i++)
        {
            Console.WriteLine("Searching for {0} on {1}.",
                fileName, diskLetters[i]);
            ThreadPool.QueueUserWorkItem(
                new WaitCallback(FindCallback), 
                new State(autoEvents[i], diskLetters[i] + fileName));
        }

        // Wait for the first instance of the file to be found.
        int index = WaitHandle.WaitAny(autoEvents, 3000, false);
        if(index == WaitHandle.WaitTimeout)
        {
            Console.WriteLine("\n{0} not found.", fileName);
        }
        else
        {
            Console.WriteLine("\n{0} found on {1}.", fileName,
                diskLetters[index]);
        }
    }

    // Search for stateInfo.fileName.
    void FindCallback(object state)
    {
        State stateInfo = (State)state;

        // Signal if the file is found.
        if(File.Exists(stateInfo.fileName))
        {
            stateInfo.autoEvent.Set();
        }
    }
}

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