WaitHandle.WaitOne WaitHandle.WaitOne WaitHandle.WaitOne WaitHandle.WaitOne Method

Definizione

Blocca il thread corrente finché l'oggetto WaitHandle corrente non riceve un segnale.Blocks the current thread until the current WaitHandle receives a signal.

Overload

WaitOne() WaitOne() WaitOne() WaitOne()

Blocca il thread corrente finché l'oggetto WaitHandle corrente non riceve un segnale.Blocks the current thread until the current WaitHandle receives a signal.

WaitOne(Int32) WaitOne(Int32) WaitOne(Int32) WaitOne(Int32)

Blocca il thread corrente finché l'oggetto WaitHandle corrente non riceve un segnale, usando un intero con segno a 32 bit per specificare l'intervallo di tempo.Blocks the current thread until the current WaitHandle receives a signal, using a 32-bit signed integer to specify the time interval in milliseconds.

WaitOne(TimeSpan) WaitOne(TimeSpan) WaitOne(TimeSpan) WaitOne(TimeSpan)

Blocca il thread corrente finché l'istanza corrente non riceve un segnale, usando un valore TimeSpan per specificare l'intervallo di tempo.Blocks the current thread until the current instance receives a signal, using a TimeSpan to specify the time interval.

WaitOne(Int32, Boolean) WaitOne(Int32, Boolean) WaitOne(Int32, Boolean) WaitOne(Int32, Boolean)

Blocca il thread corrente finché l'oggetto WaitHandle corrente non riceve 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.Blocks the current thread until the current WaitHandle receives a signal, using a 32-bit signed integer to specify the time interval and specifying whether to exit the synchronization domain before the wait.

WaitOne(TimeSpan, Boolean) WaitOne(TimeSpan, Boolean) WaitOne(TimeSpan, Boolean) WaitOne(TimeSpan, Boolean)

Blocca il thread corrente finché l'istanza corrente non riceve un segnale, usando un oggetto TimeSpan per specificare l'intervallo di tempo e indicando se uscire dal dominio di sincronizzazione prima dell'attesa.Blocks the current thread until the current instance receives a signal, using a TimeSpan to specify the time interval and specifying whether to exit the synchronization domain before the wait.

WaitOne() WaitOne() WaitOne() WaitOne()

Blocca il thread corrente finché l'oggetto WaitHandle corrente non riceve un segnale.Blocks the current thread until the current WaitHandle receives a signal.

public:
 virtual bool WaitOne();
public virtual bool WaitOne ();
abstract member WaitOne : unit -> bool
override this.WaitOne : unit -> bool
Public Overridable Function WaitOne () As Boolean

Restituisce

Viene restituito true se l'istanza corrente riceve un segnale.true if the current instance receives a signal. Se l'istanza corrente non viene mai segnalata, WaitOne(Int32, Boolean) non restituisce mai alcun valore.If the current instance is never signaled, WaitOne(Int32, Boolean) never returns.

Eccezioni

L'istanza corrente è già stata eliminata.The current instance has already been disposed.

L'attesa è terminata perché un thread è stato chiuso senza rilasciare un mutex.The wait completed because a thread exited without releasing a mutex. Questa eccezione non viene generata in Windows 98 o Windows Millennium Edition.This exception is not thrown on Windows 98 or Windows Millennium Edition.

L'istanza corrente corrisponde a un proxy trasparente per una classe WaitHandle in un altro dominio applicazione.The current instance is a transparent proxy for a WaitHandle in another application domain.

Esempi

Nell'esempio di codice seguente viene illustrato come utilizzare un handle di attesa per interrompere l'esecuzione di un processo durante l'attesa del completamento dell'esecuzione di un thread in background.The following code example shows how to use a wait handle to keep a process from terminating while it waits for a background thread to finish executing.

using namespace System;
using namespace System::Threading;
ref class WaitOne
{
private:
   WaitOne(){}


public:
   static void WorkMethod( Object^ stateInfo )
   {
      Console::WriteLine( "Work starting." );
      
      // Simulate time spent working.
      Thread::Sleep( (gcnew Random)->Next( 100, 2000 ) );
      
      // Signal that work is finished.
      Console::WriteLine( "Work ending." );
      dynamic_cast<AutoResetEvent^>(stateInfo)->Set();
   }

};

int main()
{
   Console::WriteLine( "Main starting." );
   AutoResetEvent^ autoEvent = gcnew AutoResetEvent( false );
   ThreadPool::QueueUserWorkItem( gcnew WaitCallback( &WaitOne::WorkMethod ), autoEvent );
   
   // Wait for work method to signal.
   autoEvent->WaitOne(  );
   Console::WriteLine( "Work method signaled.\nMain ending." );
}

using System;
using System.Threading;

class WaitOne
{
    static AutoResetEvent autoEvent = new AutoResetEvent(false);

    static void Main()
    {
        Console.WriteLine("Main starting.");

        ThreadPool.QueueUserWorkItem(
            new WaitCallback(WorkMethod), autoEvent);

        // Wait for work method to signal.
        autoEvent.WaitOne();
        Console.WriteLine("Work method signaled.\nMain ending.");
    }

    static void WorkMethod(object stateInfo) 
    {
        Console.WriteLine("Work starting.");

        // Simulate time spent working.
        Thread.Sleep(new Random().Next(100, 2000));

        // Signal that work is finished.
        Console.WriteLine("Work ending.");
        ((AutoResetEvent)stateInfo).Set();
    }
}
Imports System.Threading

Public Class WaitOne

    Shared autoEvent As New AutoResetEvent(False)

    <MTAThread> _
    Shared Sub Main()
        Console.WriteLine("Main starting.")

        ThreadPool.QueueUserWorkItem(AddressOf WorkMethod, autoEvent)

        ' Wait for work method to signal.
        autoEvent.WaitOne()
        Console.WriteLine("Work method signaled.")
        Console.WriteLine("Main ending.")
    End Sub

    Shared Sub WorkMethod(stateInfo As Object) 
        Console.WriteLine("Work starting.")

        ' Simulate time spent working.
        Thread.Sleep(New Random().Next(100, 2000))

        ' Signal that work is finished.
        Console.WriteLine("Work ending.")
        CType(stateInfo, AutoResetEvent).Set()
    End Sub

End Class

Commenti

AbandonedMutexExceptionè una novità della versione di .NET Framework 2,0.AbandonedMutexException is new in the .NET Framework version 2.0. Nelle versioni precedenti il WaitOne metodo restituisce true quando un mutex viene abbandonato.In previous versions, the WaitOne method returns true when a mutex is abandoned. Un mutex abbandonato spesso indica un errore di codifica grave.An abandoned mutex often indicates a serious coding error. Nel caso di un mutex a livello di sistema, potrebbe indicare che un'applicazione è stata interrotta bruscamente, ad esempio tramite Gestione attività di Windows.In the case of a system-wide mutex, it might indicate that an application has been terminated abruptly (for example, by using Windows Task Manager). L'eccezione contiene informazioni utili per il debug.The exception contains information useful for debugging.

Il chiamante di questo metodo si blocca all'infinito fino a quando l'istanza corrente non riceve un segnale.The caller of this method blocks indefinitely until the current instance receives a signal. Utilizzare questo metodo per bloccare finché un WaitHandle oggetto riceve un segnale da un altro thread, ad esempio quando viene completata un'operazione asincrona.Use this method to block until a WaitHandle receives a signal from another thread, such as is generated when an asynchronous operation completes. Per ulteriori informazioni, vedere l' IAsyncResult interfaccia.For more information, see the IAsyncResult interface.

La chiamata a questo overload del metodo equivale a WaitOne(Int32, Boolean) chiamare l'overload del metodo e a Timeout.Infinite specificare-1 o per false il primo parametro e per il secondo parametro.Calling this method overload is equivalent to calling the WaitOne(Int32, Boolean) method overload and specifying -1 or Timeout.Infinite for the first parameter and false for the second parameter.

Eseguire l'override di questo metodo per personalizzare il comportamento delle classi derivate.Override this method to customize the behavior of derived classes.

WaitOne(Int32) WaitOne(Int32) WaitOne(Int32) WaitOne(Int32)

Blocca il thread corrente finché l'oggetto WaitHandle corrente non riceve un segnale, usando un intero con segno a 32 bit per specificare l'intervallo di tempo.Blocks the current thread until the current WaitHandle receives a signal, using a 32-bit signed integer to specify the time interval in milliseconds.

public:
 virtual bool WaitOne(int millisecondsTimeout);
public virtual bool WaitOne (int millisecondsTimeout);
abstract member WaitOne : int -> bool
override this.WaitOne : int -> bool
Public Overridable Function WaitOne (millisecondsTimeout As Integer) As Boolean

Parametri

millisecondsTimeout
Int32 Int32 Int32 Int32

Numero di millisecondi di attesa oppure Infinite (-1) per un'attesa indefinita.The number of milliseconds to wait, or Infinite (-1) to wait indefinitely.

Restituisce

true se l'istanza corrente riceve un segnale; in caso contrario false.true if the current instance receives a signal; otherwise, false.

Eccezioni

L'istanza corrente è già stata eliminata.The current instance has already been disposed.

millisecondsTimeout è un numero negativo diverso da -1, che rappresenta un timeout infinito.millisecondsTimeout is a negative number other than -1, which represents an infinite time-out.

L'attesa è terminata perché un thread è stato chiuso senza rilasciare un mutex.The wait completed because a thread exited without releasing a mutex. Questa eccezione non viene generata in Windows 98 o Windows Millennium Edition.This exception is not thrown on Windows 98 or Windows Millennium Edition.

L'istanza corrente corrisponde a un proxy trasparente per una classe WaitHandle in un altro dominio applicazione.The current instance is a transparent proxy for a WaitHandle in another application domain.

Esempi

Nell'esempio di codice seguente viene illustrato come utilizzare un handle di attesa per interrompere l'esecuzione di un processo durante l'attesa del completamento dell'esecuzione di un thread in background.The following code example shows how to use a wait handle to keep a process from terminating while it waits for a background thread to finish executing.

using namespace System;
using namespace System::Threading;
ref class WaitOne
{
private:
   WaitOne(){}


public:
   static void WorkMethod( Object^ stateInfo )
   {
      Console::WriteLine( "Work starting." );
      
      // Simulate time spent working.
      Thread::Sleep( (gcnew Random)->Next( 100, 2000 ) );
      
      // Signal that work is finished.
      Console::WriteLine( "Work ending." );
      dynamic_cast<AutoResetEvent^>(stateInfo)->Set();
   }

};

int main()
{
   Console::WriteLine( "Main starting." );
   AutoResetEvent^ autoEvent = gcnew AutoResetEvent( false );
   ThreadPool::QueueUserWorkItem( gcnew WaitCallback( &WaitOne::WorkMethod ), autoEvent );
   
   // Wait for work method to signal.
   if ( autoEvent->WaitOne( 1000 ) )
   {
      Console::WriteLine( "Work method signaled." );
   }
   else
   {
      Console::WriteLine( "Timed out waiting for work "
      "method to signal." );
   }

   Console::WriteLine( "Main ending." );
}

using System;
using System.Threading;

class WaitOne
{
    static AutoResetEvent autoEvent = new AutoResetEvent(false);

    static void Main()
    {
        Console.WriteLine("Main starting.");

        ThreadPool.QueueUserWorkItem(
            new WaitCallback(WorkMethod), autoEvent);

        // Wait for work method to signal.
        if(autoEvent.WaitOne(1000))
        {
            Console.WriteLine("Work method signaled.");
        }
        else
        {
            Console.WriteLine("Timed out waiting for work " +
                "method to signal.");
        }
        Console.WriteLine("Main ending.");
    }

    static void WorkMethod(object stateInfo) 
    {
        Console.WriteLine("Work starting.");

        // Simulate time spent working.
        Thread.Sleep(new Random().Next(100, 2000));

        // Signal that work is finished.
        Console.WriteLine("Work ending.");
        ((AutoResetEvent)stateInfo).Set();
    }
}
Imports System.Threading

Public Class WaitOne

    Shared autoEvent As New AutoResetEvent(False)

    <MTAThread> _
    Shared Sub Main()
        Console.WriteLine("Main starting.")

        ThreadPool.QueueUserWorkItem(AddressOf WorkMethod, autoEvent)

        ' Wait for work method to signal.
        If autoEvent.WaitOne(1000) Then
            Console.WriteLine("Work method signaled.")
        Else
            Console.WriteLine("Timed out waiting for work " & _
                "method to signal.")
        End If

        Console.WriteLine("Main ending.")
    End Sub

    Shared Sub WorkMethod(stateInfo As Object) 
        Console.WriteLine("Work starting.")

        ' Simulate time spent working.
        Thread.Sleep(New Random().Next(100, 2000))

        ' Signal that work is finished.
        Console.WriteLine("Work ending.")
        CType(stateInfo, AutoResetEvent).Set()
    End Sub

End Class

Commenti

Se millisecondsTimeout è zero, il metodo non viene bloccato.If millisecondsTimeout is zero, the method does not block. Verifica lo stato dell'handle di attesa e restituisce immediatamente un risultato.It tests the state of the wait handle and returns immediately.

Il chiamante di questo metodo si blocca fino a quando l'istanza corrente non riceve un segnale o si verifica un timeout.The caller of this method blocks until the current instance receives a signal or a time-out occurs. Utilizzare questo metodo per bloccare finché un WaitHandle oggetto riceve un segnale da un altro thread, ad esempio quando viene completata un'operazione asincrona.Use this method to block until a WaitHandle receives a signal from another thread, such as is generated when an asynchronous operation completes. Per ulteriori informazioni, vedere l' IAsyncResult interfaccia.For more information, see the IAsyncResult interface.

Eseguire l'override di questo metodo per personalizzare il comportamento delle classi derivate.Override this method to customize the behavior of derived classes.

La chiamata a questo overload del metodo equivale alla chiamata WaitOne(Int32, Boolean) dell'overload e false alla exitContextspecifica di per.Calling this method overload is the same as calling the WaitOne(Int32, Boolean) overload and specifying false for exitContext.

WaitOne(TimeSpan) WaitOne(TimeSpan) WaitOne(TimeSpan) WaitOne(TimeSpan)

Blocca il thread corrente finché l'istanza corrente non riceve un segnale, usando un valore TimeSpan per specificare l'intervallo di tempo.Blocks the current thread until the current instance receives a signal, using a TimeSpan to specify the time interval.

public:
 virtual bool WaitOne(TimeSpan timeout);
public virtual bool WaitOne (TimeSpan timeout);
abstract member WaitOne : TimeSpan -> bool
override this.WaitOne : TimeSpan -> bool
Public Overridable Function WaitOne (timeout As TimeSpan) As Boolean

Parametri

timeout
TimeSpan TimeSpan TimeSpan TimeSpan

Oggetto TimeSpan che rappresenta il numero di millisecondi di attesa oppure TimeSpan che rappresenta -1 millisecondi per un'attesa indefinita.A TimeSpan that represents the number of milliseconds to wait, or a TimeSpan that represents -1 milliseconds to wait indefinitely.

Restituisce

true se l'istanza corrente riceve un segnale; in caso contrario false.true if the current instance receives a signal; otherwise, false.

Eccezioni

L'istanza corrente è già stata eliminata.The current instance has already been disposed.

timeout è un numero negativo diverso da -1 millisecondi, che rappresenta un timeout infinito.timeout is a negative number other than -1 milliseconds, which represents an infinite time-out. -oppure--or- timeout è maggiore di MaxValue.timeout is greater than MaxValue.

L'attesa è terminata perché un thread è stato chiuso senza rilasciare un mutex.The wait completed because a thread exited without releasing a mutex. Questa eccezione non viene generata in Windows 98 o Windows Millennium Edition.This exception is not thrown on Windows 98 or Windows Millennium Edition.

L'istanza corrente corrisponde a un proxy trasparente per una classe WaitHandle in un altro dominio applicazione.The current instance is a transparent proxy for a WaitHandle in another application domain.

Commenti

Se timeout è zero, il metodo non viene bloccato.If timeout is zero, the method does not block. Verifica lo stato dell'handle di attesa e restituisce immediatamente un risultato.It tests the state of the wait handle and returns immediately.

Il chiamante di questo metodo si blocca fino a quando l'istanza corrente non riceve un segnale o si verifica un timeout.The caller of this method blocks until the current instance receives a signal or a time-out occurs. Utilizzare questo metodo per bloccare finché un WaitHandle oggetto riceve un segnale da un altro thread, ad esempio quando viene completata un'operazione asincrona.Use this method to block until a WaitHandle receives a signal from another thread, such as is generated when an asynchronous operation completes. Per ulteriori informazioni, vedere l' IAsyncResult interfaccia.For more information, see the IAsyncResult interface.

Eseguire l'override di questo metodo per personalizzare il comportamento delle classi derivate.Override this method to customize the behavior of derived classes.

Il valore massimo per timeout è Int32.MaxValue.The maximum value for timeout is Int32.MaxValue.

La chiamata a questo overload del metodo equivale alla chiamata WaitOne(TimeSpan, Boolean) dell'overload e false alla exitContextspecifica di per.Calling this method overload is the same as calling the WaitOne(TimeSpan, Boolean) overload and specifying false for exitContext.

WaitOne(Int32, Boolean) WaitOne(Int32, Boolean) WaitOne(Int32, Boolean) WaitOne(Int32, Boolean)

Blocca il thread corrente finché l'oggetto WaitHandle corrente non riceve 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.Blocks the current thread until the current WaitHandle receives a signal, using a 32-bit signed integer to specify the time interval and specifying whether to exit the synchronization domain before the wait.

public:
 virtual bool WaitOne(int millisecondsTimeout, bool exitContext);
public virtual bool WaitOne (int millisecondsTimeout, bool exitContext);
abstract member WaitOne : int * bool -> bool
override this.WaitOne : int * bool -> bool
Public Overridable Function WaitOne (millisecondsTimeout As Integer, exitContext As Boolean) As Boolean

Parametri

millisecondsTimeout
Int32 Int32 Int32 Int32

Numero di millisecondi di attesa oppure Infinite (-1) per un'attesa indefinita.The number of milliseconds to wait, or Infinite (-1) to wait indefinitely.

exitContext
Boolean Boolean Boolean 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.true to exit the synchronization domain for the context before the wait (if in a synchronized context), and reacquire it afterward; otherwise, false.

Restituisce

true se l'istanza corrente riceve un segnale; in caso contrario false.true if the current instance receives a signal; otherwise, false.

Eccezioni

L'istanza corrente è già stata eliminata.The current instance has already been disposed.

millisecondsTimeout è un numero negativo diverso da -1, che rappresenta un timeout infinito.millisecondsTimeout is a negative number other than -1, which represents an infinite time-out.

L'attesa è terminata perché un thread è stato chiuso senza rilasciare un mutex.The wait completed because a thread exited without releasing a mutex. Questa eccezione non viene generata in Windows 98 o Windows Millennium Edition.This exception is not thrown on Windows 98 or Windows Millennium Edition.

L'istanza corrente corrisponde a un proxy trasparente per una classe WaitHandle in un altro dominio applicazione.The current instance is a transparent proxy for a WaitHandle in another application domain.

Esempi

Nell'esempio seguente viene illustrato il WaitOne(Int32, Boolean) comportamento dell'overload del metodo quando viene chiamato all'interno di un dominio di sincronizzazione.The following example shows how the WaitOne(Int32, Boolean) method overload behaves when it is called within a synchronization domain. In primo luogo, un thread attende exitContext che venga false impostato su e si blocchi fino alla scadenza del timeout di attesa.First, a thread waits with exitContext set to false and blocks until the wait timeout expires. Un secondo thread viene eseguito dopo che il primo thread termina e attende con exitContext impostato su. trueA second thread executes after the first thread terminates and waits with exitContext set to true. La chiamata per segnalare l'handle di attesa per questo secondo thread non è bloccata e il thread viene completato prima del timeout di attesa.The call to signal the wait handle for this second thread is not blocked, and the thread completes before the wait timeout.

using namespace System;
using namespace System::Threading;
using namespace System::Runtime::Remoting::Contexts;

[Synchronization(true)]
public ref class SyncingClass : ContextBoundObject
{
private:
    EventWaitHandle^ waitHandle;

public:
    SyncingClass()
    {
         waitHandle =
            gcnew EventWaitHandle(false, EventResetMode::ManualReset);
    }

    void Signal()
    {
        Console::WriteLine("Thread[{0:d4}]: Signalling...", Thread::CurrentThread->GetHashCode());
        waitHandle->Set();
    }

    void DoWait(bool leaveContext)
    {
        bool signalled;

        waitHandle->Reset();
        Console::WriteLine("Thread[{0:d4}]: Waiting...", Thread::CurrentThread->GetHashCode());
        signalled = waitHandle->WaitOne(3000, leaveContext);
        if (signalled)
        {
            Console::WriteLine("Thread[{0:d4}]: Wait released!!!", Thread::CurrentThread->GetHashCode());
        }
        else
        {
            Console::WriteLine("Thread[{0:d4}]: Wait timeout!!!", Thread::CurrentThread->GetHashCode());
        }
    }
};

public ref class TestSyncDomainWait
{
public:
    static void Main()
    {
        SyncingClass^ syncClass = gcnew SyncingClass();

        Thread^ runWaiter;

        Console::WriteLine("\nWait and signal INSIDE synchronization domain:\n");
        runWaiter = gcnew Thread(gcnew ParameterizedThreadStart(&TestSyncDomainWait::RunWaitKeepContext));
        runWaiter->Start(syncClass);
        Thread::Sleep(1000);
        Console::WriteLine("Thread[{0:d4}]: Signal...", Thread::CurrentThread->GetHashCode());
        // This call to Signal will block until the timeout in DoWait expires.
        syncClass->Signal();
        runWaiter->Join();

        Console::WriteLine("\nWait and signal OUTSIDE synchronization domain:\n");
        runWaiter = gcnew Thread(gcnew ParameterizedThreadStart(&TestSyncDomainWait::RunWaitLeaveContext));
        runWaiter->Start(syncClass);
        Thread::Sleep(1000);
        Console::WriteLine("Thread[{0:d4}]: Signal...", Thread::CurrentThread->GetHashCode());
        // This call to Signal is unblocked and will set the wait handle to
        // release the waiting thread.
        syncClass->Signal();
        runWaiter->Join();
    }

    static void RunWaitKeepContext(Object^ parm)
    {
        ((SyncingClass^)parm)->DoWait(false);
    }

    static void RunWaitLeaveContext(Object^ parm)
    {
        ((SyncingClass^)parm)->DoWait(true);
    }
};

int main()
{
    TestSyncDomainWait::Main();
}
// The output for the example program will be similar to the following:
//
// Wait and signal INSIDE synchronization domain:
//
// Thread[0004]: Waiting...
// Thread[0001]: Signal...
// Thread[0004]: Wait timeout!!!
// Thread[0001]: Signalling...
//
// Wait and signal OUTSIDE synchronization domain:
//
// Thread[0006]: Waiting...
// Thread[0001]: Signal...
// Thread[0001]: Signalling...
// Thread[0006]: Wait released!!!
using System;
using System.Threading;
using System.Runtime.Remoting.Contexts;

[Synchronization(true)]
public class SyncingClass : ContextBoundObject
{
    private EventWaitHandle waitHandle;

    public SyncingClass()
    {
         waitHandle =
            new EventWaitHandle(false, EventResetMode.ManualReset);
    }

    public void Signal()
    {
        Console.WriteLine("Thread[{0:d4}]: Signalling...", Thread.CurrentThread.GetHashCode());
        waitHandle.Set();
    }

    public void DoWait(bool leaveContext)
    {
        bool signalled;

        waitHandle.Reset();
        Console.WriteLine("Thread[{0:d4}]: Waiting...", Thread.CurrentThread.GetHashCode());
        signalled = waitHandle.WaitOne(3000, leaveContext);
        if (signalled)
        {
            Console.WriteLine("Thread[{0:d4}]: Wait released!!!", Thread.CurrentThread.GetHashCode());
        }
        else
        {
            Console.WriteLine("Thread[{0:d4}]: Wait timeout!!!", Thread.CurrentThread.GetHashCode());
        }
    }
}

public class TestSyncDomainWait
{
    public static void Main()
    {
        SyncingClass syncClass = new SyncingClass();

        Thread runWaiter;

        Console.WriteLine("\nWait and signal INSIDE synchronization domain:\n");
        runWaiter = new Thread(RunWaitKeepContext);
        runWaiter.Start(syncClass);
        Thread.Sleep(1000);
        Console.WriteLine("Thread[{0:d4}]: Signal...", Thread.CurrentThread.GetHashCode());
        // This call to Signal will block until the timeout in DoWait expires.
        syncClass.Signal();
        runWaiter.Join();

        Console.WriteLine("\nWait and signal OUTSIDE synchronization domain:\n");
        runWaiter = new Thread(RunWaitLeaveContext);
        runWaiter.Start(syncClass);
        Thread.Sleep(1000);
        Console.WriteLine("Thread[{0:d4}]: Signal...", Thread.CurrentThread.GetHashCode());
        // This call to Signal is unblocked and will set the wait handle to
        // release the waiting thread.
        syncClass.Signal();
        runWaiter.Join();
    }

    public static void RunWaitKeepContext(object parm)
    {
        ((SyncingClass)parm).DoWait(false);
    }

    public static void RunWaitLeaveContext(object parm)
    {
        ((SyncingClass)parm).DoWait(true);
    }
}

// The output for the example program will be similar to the following:
//
// Wait and signal INSIDE synchronization domain:
//
// Thread[0004]: Waiting...
// Thread[0001]: Signal...
// Thread[0004]: Wait timeout!!!
// Thread[0001]: Signalling...
//
// Wait and signal OUTSIDE synchronization domain:
//
// Thread[0006]: Waiting...
// Thread[0001]: Signal...
// Thread[0001]: Signalling...
// Thread[0006]: Wait released!!!
Imports System.Threading
Imports System.Runtime.Remoting.Contexts

<Synchronization(true)>
Public Class SyncingClass
    Inherits ContextBoundObject
    
    Private waitHandle As EventWaitHandle

    Public Sub New()
         waitHandle = New EventWaitHandle(false, EventResetMode.ManualReset)
    End Sub

    Public Sub Signal()
        Console.WriteLine("Thread[{0:d4}]: Signalling...", Thread.CurrentThread.GetHashCode())
        waitHandle.Set()
    End Sub

    Public Sub DoWait(leaveContext As Boolean)
        Dim signalled As Boolean

        waitHandle.Reset()
        Console.WriteLine("Thread[{0:d4}]: Waiting...", Thread.CurrentThread.GetHashCode())
        signalled = waitHandle.WaitOne(3000, leaveContext)
        If signalled Then
            Console.WriteLine("Thread[{0:d4}]: Wait released!!!", Thread.CurrentThread.GetHashCode())
        Else
            Console.WriteLine("Thread[{0:d4}]: Wait timeout!!!", Thread.CurrentThread.GetHashCode())
        End If
    End Sub
End Class

Public Class TestSyncDomainWait
    Public Shared Sub Main()
        Dim syncClass As New SyncingClass()

        Dim runWaiter As Thread

        Console.WriteLine(vbNewLine + "Wait and signal INSIDE synchronization domain:" + vbNewLine)
        runWaiter = New Thread(AddressOf RunWaitKeepContext)
        runWaiter.Start(syncClass)
        Thread.Sleep(1000)
        Console.WriteLine("Thread[{0:d4}]: Signal...", Thread.CurrentThread.GetHashCode())
        ' This call to Signal will block until the timeout in DoWait expires.
        syncClass.Signal()
        runWaiter.Join()

        Console.WriteLine(vbNewLine + "Wait and signal OUTSIDE synchronization domain:" + vbNewLine)
        runWaiter = New Thread(AddressOf RunWaitLeaveContext)
        runWaiter.Start(syncClass)
        Thread.Sleep(1000)
        Console.WriteLine("Thread[{0:d4}]: Signal...", Thread.CurrentThread.GetHashCode())
        ' This call to Signal is unblocked and will set the wait handle to
        ' release the waiting thread.
        syncClass.Signal()
        runWaiter.Join()
    End Sub

    Public Shared Sub RunWaitKeepContext(parm As Object)
        Dim syncClass As SyncingClass = CType(parm, SyncingClass)
        syncClass.DoWait(False)
    End Sub

    Public Shared Sub RunWaitLeaveContext(parm As Object)
        Dim syncClass As SyncingClass = CType(parm, SyncingClass)
        syncClass.DoWait(True)
    End Sub
End Class

' The output for the example program will be similar to the following:
'
' Wait and signal INSIDE synchronization domain:
'
' Thread[0004]: Waiting...
' Thread[0001]: Signal...
' Thread[0004]: Wait timeout!!!
' Thread[0001]: Signalling...
'
' Wait and signal OUTSIDE synchronization domain:
'
' Thread[0006]: Waiting...
' Thread[0001]: Signal...
' Thread[0001]: Signalling...
' Thread[0006]: Wait released!!!

Commenti

Se millisecondsTimeout è zero, il metodo non viene bloccato.If millisecondsTimeout is zero, the method does not block. Verifica lo stato dell'handle di attesa e restituisce immediatamente un risultato.It tests the state of the wait handle and returns immediately.

AbandonedMutexExceptionè una novità della versione di .NET Framework 2,0.AbandonedMutexException is new in the .NET Framework version 2.0. Nelle versioni precedenti il WaitOne metodo restituisce true quando un mutex viene abbandonato.In previous versions, the WaitOne method returns true when a mutex is abandoned. Un mutex abbandonato spesso indica un errore di codifica grave.An abandoned mutex often indicates a serious coding error. Nel caso di un mutex a livello di sistema, potrebbe indicare che un'applicazione è stata interrotta bruscamente, ad esempio tramite Gestione attività di Windows.In the case of a system-wide mutex, it might indicate that an application has been terminated abruptly (for example, by using Windows Task Manager). L'eccezione contiene informazioni utili per il debug.The exception contains information useful for debugging.

Il chiamante di questo metodo si blocca fino a quando l'istanza corrente non riceve un segnale o si verifica un timeout.The caller of this method blocks until the current instance receives a signal or a time-out occurs. Utilizzare questo metodo per bloccare finché un WaitHandle oggetto riceve un segnale da un altro thread, ad esempio quando viene completata un'operazione asincrona.Use this method to block until a WaitHandle receives a signal from another thread, such as is generated when an asynchronous operation completes. Per ulteriori informazioni, vedere l' IAsyncResult interfaccia.For more information, see the IAsyncResult interface.

Eseguire l'override di questo metodo per personalizzare il comportamento delle classi derivate.Override this method to customize the behavior of derived classes.

Note sull'uscita dal contestoNotes on Exiting the Context

Il exitContext parametro non ha alcun effetto a meno WaitOne che il metodo non venga chiamato dall'interno di un contesto gestito non predefinito.The exitContext parameter has no effect unless the WaitOne method is called from inside a nondefault managed context. Questo problema può verificarsi se il thread si trova all'interno di una chiamata a un'istanza di ContextBoundObjectuna classe derivata da.This can happen if your thread is inside a call to an instance of a class derived from ContextBoundObject. Anche se si sta eseguendo un metodo su una classe che non deriva da ContextBoundObject, ad esempio String, si può trovarsi in un contesto non predefinito se un ContextBoundObject è nello stack nel dominio applicazione corrente.Even if you are currently executing a method on a class that does not derive from ContextBoundObject, like String, you can be in a nondefault context if a ContextBoundObject is on your stack in the current application domain.

Quando il codice è in esecuzione in un contesto non predefinito, true specificando exitContext per il thread esce dal contesto gestito non predefinito (ovvero, per passare al contesto predefinito) prima di eseguire il WaitOne metodo.When your code is executing in a nondefault context, specifying true for exitContext causes the thread to exit the nondefault managed context (that is, to transition to the default context) before executing the WaitOne method. Il thread torna al contesto non predefinito originale dopo che la chiamata al WaitOne metodo è stata completata.The thread returns to the original nondefault context after the call to the WaitOne method completes.

Questa operazione può essere utile quando la classe associata al contesto SynchronizationAttributedispone di.This can be useful when the context-bound class has SynchronizationAttribute. In tal caso, tutte le chiamate ai membri della classe vengono sincronizzate automaticamente e il dominio di sincronizzazione è l'intero corpo del codice per la classe.In that case, all calls to members of the class are automatically synchronized, and the synchronization domain is the entire body of code for the class. Se il codice nello stack di chiamate di un membro chiama WaitOne il metodo e true specifica exitContextper, il thread esce dal dominio di sincronizzazione, consentendo a un thread bloccato in una chiamata a un membro dell'oggetto di continuare.If code in the call stack of a member calls the WaitOne method and specifies true for exitContext, the thread exits the synchronization domain, allowing a thread that is blocked on a call to any member of the object to proceed. Quando il WaitOne metodo restituisce, il thread che ha effettuato la chiamata deve attendere la reimmissione del dominio di sincronizzazione.When the WaitOne method returns, the thread that made the call must wait to reenter the synchronization domain.

WaitOne(TimeSpan, Boolean) WaitOne(TimeSpan, Boolean) WaitOne(TimeSpan, Boolean) WaitOne(TimeSpan, Boolean)

Blocca il thread corrente finché l'istanza corrente non riceve un segnale, usando un oggetto TimeSpan per specificare l'intervallo di tempo e indicando se uscire dal dominio di sincronizzazione prima dell'attesa.Blocks the current thread until the current instance receives a signal, using a TimeSpan to specify the time interval and specifying whether to exit the synchronization domain before the wait.

public:
 virtual bool WaitOne(TimeSpan timeout, bool exitContext);
public virtual bool WaitOne (TimeSpan timeout, bool exitContext);
abstract member WaitOne : TimeSpan * bool -> bool
override this.WaitOne : TimeSpan * bool -> bool
Public Overridable Function WaitOne (timeout As TimeSpan, exitContext As Boolean) As Boolean

Parametri

timeout
TimeSpan TimeSpan TimeSpan TimeSpan

Oggetto TimeSpan che rappresenta il numero di millisecondi di attesa oppure TimeSpan che rappresenta -1 millisecondi per un'attesa indefinita.A TimeSpan that represents the number of milliseconds to wait, or a TimeSpan that represents -1 milliseconds to wait indefinitely.

exitContext
Boolean Boolean Boolean 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.true to exit the synchronization domain for the context before the wait (if in a synchronized context), and reacquire it afterward; otherwise, false.

Restituisce

true se l'istanza corrente riceve un segnale; in caso contrario false.true if the current instance receives a signal; otherwise, false.

Eccezioni

L'istanza corrente è già stata eliminata.The current instance has already been disposed.

timeout è un numero negativo diverso da -1 millisecondi, che rappresenta un timeout infinito.timeout is a negative number other than -1 milliseconds, which represents an infinite time-out. In alternativa-or- timeout è maggiore di MaxValue.timeout is greater than MaxValue.

L'attesa è terminata perché un thread è stato chiuso senza rilasciare un mutex.The wait completed because a thread exited without releasing a mutex. Questa eccezione non viene generata in Windows 98 o Windows Millennium Edition.This exception is not thrown on Windows 98 or Windows Millennium Edition.

L'istanza corrente corrisponde a un proxy trasparente per una classe WaitHandle in un altro dominio applicazione.The current instance is a transparent proxy for a WaitHandle in another application domain.

Esempi

Nell'esempio di codice seguente viene illustrato come utilizzare un handle di attesa per interrompere l'esecuzione di un processo durante l'attesa del completamento dell'esecuzione di un thread in background.The following code example shows how to use a wait handle to keep a process from terminating while it waits for a background thread to finish executing.

using namespace System;
using namespace System::Threading;
ref class WaitOne
{
private:
   WaitOne(){}


public:
   static void WorkMethod( Object^ stateInfo )
   {
      Console::WriteLine( "Work starting." );
      
      // Simulate time spent working.
      Thread::Sleep( (gcnew Random)->Next( 100, 2000 ) );
      
      // Signal that work is finished.
      Console::WriteLine( "Work ending." );
      dynamic_cast<AutoResetEvent^>(stateInfo)->Set();
   }

};

int main()
{
   Console::WriteLine( "Main starting." );
   AutoResetEvent^ autoEvent = gcnew AutoResetEvent( false );
   ThreadPool::QueueUserWorkItem( gcnew WaitCallback( &WaitOne::WorkMethod ), autoEvent );
   
   // Wait for work method to signal.
   if ( autoEvent->WaitOne( TimeSpan(0,0,1), false ) )
   {
      Console::WriteLine( "Work method signaled." );
   }
   else
   {
      Console::WriteLine( "Timed out waiting for work "
      "method to signal." );
   }

   Console::WriteLine( "Main ending." );
}

using System;
using System.Threading;

class WaitOne
{
    static AutoResetEvent autoEvent = new AutoResetEvent(false);

    static void Main()
    {
        Console.WriteLine("Main starting.");

        ThreadPool.QueueUserWorkItem(
            new WaitCallback(WorkMethod), autoEvent);

        // Wait for work method to signal.
        if(autoEvent.WaitOne(new TimeSpan(0, 0, 1), false))
        {
            Console.WriteLine("Work method signaled.");
        }
        else
        {
            Console.WriteLine("Timed out waiting for work " +
                "method to signal.");
        }
        Console.WriteLine("Main ending.");
    }

    static void WorkMethod(object stateInfo) 
    {
        Console.WriteLine("Work starting.");

        // Simulate time spent working.
        Thread.Sleep(new Random().Next(100, 2000));

        // Signal that work is finished.
        Console.WriteLine("Work ending.");
        ((AutoResetEvent)stateInfo).Set();
    }
}
Imports System.Threading

Public Class WaitOne

    Shared autoEvent As New AutoResetEvent(False)

    <MTAThread> _
    Shared Sub Main()
        Console.WriteLine("Main starting.")

        ThreadPool.QueueUserWorkItem(AddressOf WorkMethod, autoEvent)

        ' Wait for work method to signal.
        If autoEvent.WaitOne(New TimeSpan(0, 0, 1), False) Then
            Console.WriteLine("Work method signaled.")
        Else
            Console.WriteLine("Timed out waiting for work " & _
                "method to signal.")
        End If

        Console.WriteLine("Main ending.")
    End Sub

    Shared Sub WorkMethod(stateInfo As Object) 
        Console.WriteLine("Work starting.")

        ' Simulate time spent working.
        Thread.Sleep(New Random().Next(100, 2000))

        ' Signal that work is finished.
        Console.WriteLine("Work ending.")
        CType(stateInfo, AutoResetEvent).Set()
    End Sub

End Class

Commenti

Se timeout è zero, il metodo non viene bloccato.If timeout is zero, the method does not block. Verifica lo stato dell'handle di attesa e restituisce immediatamente un risultato.It tests the state of the wait handle and returns immediately.

AbandonedMutexExceptionè una novità della versione di .NET Framework 2,0.AbandonedMutexException is new in the .NET Framework version 2.0. Nelle versioni precedenti il WaitOne metodo restituisce true quando un mutex viene abbandonato.In previous versions, the WaitOne method returns true when a mutex is abandoned. Un mutex abbandonato spesso indica un errore di codifica grave.An abandoned mutex often indicates a serious coding error. Nel caso di un mutex a livello di sistema, potrebbe indicare che un'applicazione è stata interrotta bruscamente, ad esempio tramite Gestione attività di Windows.In the case of a system-wide mutex, it might indicate that an application has been terminated abruptly (for example, by using Windows Task Manager). L'eccezione contiene informazioni utili per il debug.The exception contains information useful for debugging.

Il chiamante di questo metodo si blocca fino a quando l'istanza corrente non riceve un segnale o si verifica un timeout.The caller of this method blocks until the current instance receives a signal or a time-out occurs. Utilizzare questo metodo per bloccare finché un WaitHandle oggetto riceve un segnale da un altro thread, ad esempio quando viene completata un'operazione asincrona.Use this method to block until a WaitHandle receives a signal from another thread, such as is generated when an asynchronous operation completes. Per ulteriori informazioni, vedere l' IAsyncResult interfaccia.For more information, see the IAsyncResult interface.

Eseguire l'override di questo metodo per personalizzare il comportamento delle classi derivate.Override this method to customize the behavior of derived classes.

Il valore massimo per timeout è Int32.MaxValue.The maximum value for timeout is Int32.MaxValue.

Note sull'uscita dal contestoNotes on Exiting the Context

Il exitContext parametro non ha alcun effetto a meno WaitOne che il metodo non venga chiamato dall'interno di un contesto gestito non predefinito.The exitContext parameter has no effect unless the WaitOne method is called from inside a nondefault managed context. Questo problema può verificarsi se il thread si trova all'interno di una chiamata a un'istanza di ContextBoundObjectuna classe derivata da.This can happen if your thread is inside a call to an instance of a class derived from ContextBoundObject. Anche se si sta eseguendo un metodo su una classe che non deriva da ContextBoundObject, ad esempio String, si può trovarsi in un contesto non predefinito se un ContextBoundObject è nello stack nel dominio applicazione corrente.Even if you are currently executing a method on a class that does not derive from ContextBoundObject, like String, you can be in a nondefault context if a ContextBoundObject is on your stack in the current application domain.

Quando il codice è in esecuzione in un contesto non predefinito, true specificando exitContext per il thread esce dal contesto gestito non predefinito (ovvero, per passare al contesto predefinito) prima di eseguire il WaitOne metodo.When your code is executing in a nondefault context, specifying true for exitContext causes the thread to exit the nondefault managed context (that is, to transition to the default context) before executing the WaitOne method. Il thread torna al contesto non predefinito originale dopo che la chiamata al WaitOne metodo è stata completata.The thread returns to the original nondefault context after the call to the WaitOne method completes.

Questa operazione può essere utile quando la classe associata al contesto SynchronizationAttributedispone di.This can be useful when the context-bound class has SynchronizationAttribute. In tal caso, tutte le chiamate ai membri della classe vengono sincronizzate automaticamente e il dominio di sincronizzazione è l'intero corpo del codice per la classe.In that case, all calls to members of the class are automatically synchronized, and the synchronization domain is the entire body of code for the class. Se il codice nello stack di chiamate di un membro chiama WaitOne il metodo e true specifica exitContextper, il thread esce dal dominio di sincronizzazione, consentendo a un thread bloccato in una chiamata a un membro dell'oggetto di continuare.If code in the call stack of a member calls the WaitOne method and specifies true for exitContext, the thread exits the synchronization domain, allowing a thread that is blocked on a call to any member of the object to proceed. Quando il WaitOne metodo restituisce, il thread che ha effettuato la chiamata deve attendere la reimmissione del dominio di sincronizzazione.When the WaitOne method returns, the thread that made the call must wait to reenter the synchronization domain.

Si applica a