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

Esempio di codice seguente viene illustrato come utilizzare un handle di attesa per mantenere un processo venga terminato durante l'attesa di un thread in background terminare l'esecuzione.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
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 è stata introdotta in .NET Framework versione 2.0.AbandonedMutexException is new in the .NET Framework version 2.0. Nelle versioni precedenti, il WaitOne restituzione del metodo true quando viene abbandonato un mutex.In previous versions, the WaitOne method returns true when a mutex is abandoned. Un mutex abbandonato indica spesso un grave errore di codifica.An abandoned mutex often indicates a serious coding error. Nel caso di un mutex di sistema, può indicare che un'applicazione è stata terminata in modo anomalo (ad esempio, usando Gestione attività 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 in modo indefinito finché l'istanza corrente riceve un segnale.The caller of this method blocks indefinitely until the current instance receives a signal. Usare questo metodo per bloccare fino a un WaitHandle riceve un segnale da un altro thread, ad esempio viene generato 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 altre informazioni, vedere il IAsyncResult interfaccia.For more information, see the IAsyncResult interface.

Chiamare questo overload del metodo è equivalente alla chiamata di WaitOne(Int32, Boolean) overload del metodo e specificare -1 o Timeout.Infinite per il primo parametro e false 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

Esempio di codice seguente viene illustrato come utilizzare un handle di attesa per mantenere un processo venga terminato durante l'attesa di un thread in background terminare l'esecuzione.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
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 è uguale a zero, il metodo non blocca.If millisecondsTimeout is zero, the method does not block. Verifica lo stato dell'handle di attesa e restituisce immediatamente.It tests the state of the wait handle and returns immediately.

Si verifica il chiamante di questo metodo si blocca fino a quando l'istanza corrente riceve un segnale o un timeout.The caller of this method blocks until the current instance receives a signal or a time-out occurs. Usare questo metodo per bloccare fino a un WaitHandle riceve un segnale da un altro thread, ad esempio viene generato 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 altre informazioni, vedere il 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.

Chiamare questo overload del metodo è uguale alla chiamata al metodo il WaitOne(Int32, Boolean) overload e specificare false per exitContext.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. 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.

Commenti

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

Si verifica il chiamante di questo metodo si blocca fino a quando l'istanza corrente riceve un segnale o un timeout.The caller of this method blocks until the current instance receives a signal or a time-out occurs. Usare questo metodo per bloccare fino a un WaitHandle riceve un segnale da un altro thread, ad esempio viene generato 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 altre informazioni, vedere il 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 timeout è Int32.MaxValue.The maximum value for timeout is Int32.MaxValue.

Chiamare questo overload del metodo è uguale alla chiamata al metodo il WaitOne(TimeSpan, Boolean) overload e specificare false per exitContext.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

L'esempio seguente illustra come il WaitOne(Int32, Boolean) overload del metodo si comporta 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 con exitContext impostato su false e blocca fino a quando non scade il 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 il primo thread termina e resta in attesa con exitContext impostato su true.A second thread executes after the first thread terminates and waits with exitContext set to true. La chiamata per segnalare l'handle di attesa per il secondo thread non è bloccata e il thread viene completata 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
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 è uguale a zero, il metodo non blocca.If millisecondsTimeout is zero, the method does not block. Verifica lo stato dell'handle di attesa e restituisce immediatamente.It tests the state of the wait handle and returns immediately.

AbandonedMutexException è stata introdotta in .NET Framework versione 2.0.AbandonedMutexException is new in the .NET Framework version 2.0. Nelle versioni precedenti, il WaitOne restituzione del metodo true quando viene abbandonato un mutex.In previous versions, the WaitOne method returns true when a mutex is abandoned. Un mutex abbandonato indica spesso un grave errore di codifica.An abandoned mutex often indicates a serious coding error. Nel caso di un mutex di sistema, può indicare che un'applicazione è stata terminata in modo anomalo (ad esempio, usando Gestione attività 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.

Si verifica il chiamante di questo metodo si blocca fino a quando l'istanza corrente riceve un segnale o un timeout.The caller of this method blocks until the current instance receives a signal or a time-out occurs. Usare questo metodo per bloccare fino a un WaitHandle riceve un segnale da un altro thread, ad esempio viene generato 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 altre informazioni, vedere il 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 ha effetto solo se il WaitOne metodo chiamato dall'interno di un contesto gestito.The exitContext parameter has no effect unless the WaitOne method is called from inside a nondefault managed context. Questa situazione può verificarsi se il thread si trova all'interno di una chiamata a un'istanza di una classe derivata da ContextBoundObject.This can happen if your thread is inside a call to an instance of a class derived from ContextBoundObject. Anche se un metodo attualmente in esecuzione in una classe che non deriva da ContextBoundObject, ad esempio String, è possibile essere in un contesto non predefinite se un ContextBoundObject nello stack nel dominio dell'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, che specifica true per exitContext fa sì che il thread esce dal contesto gestito (vale a dire, per eseguire la transizione 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 viene restituito il contesto originale non predefinita dopo la chiamata al WaitOne metodo viene completato.The thread returns to the original nondefault context after the call to the WaitOne method completes.

Ciò può essere utile quando la classe associata al contesto presenta SynchronizationAttribute.This can be useful when the context-bound class has SynchronizationAttribute. In tal caso, tutte le chiamate ai membri della classe sono automaticamente sincronizzate 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 nello stack di chiamate di un membro codice chiama il WaitOne (metodo) e specifica true per exitContext, il thread esce dal dominio di sincronizzazione, consentendo a un thread bloccato in una chiamata a qualsiasi membro dell'oggetto per 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 viene restituito, il thread che ha effettuato la chiamata deve attendere per immettere di nuovo il 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

Esempio di codice seguente viene illustrato come utilizzare un handle di attesa per mantenere un processo venga terminato durante l'attesa di un thread in background terminare l'esecuzione.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
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 è uguale a zero, il metodo non blocca.If timeout is zero, the method does not block. Verifica lo stato dell'handle di attesa e restituisce immediatamente.It tests the state of the wait handle and returns immediately.

AbandonedMutexException è stata introdotta in .NET Framework versione 2.0.AbandonedMutexException is new in the .NET Framework version 2.0. Nelle versioni precedenti, il WaitOne restituzione del metodo true quando viene abbandonato un mutex.In previous versions, the WaitOne method returns true when a mutex is abandoned. Un mutex abbandonato indica spesso un grave errore di codifica.An abandoned mutex often indicates a serious coding error. Nel caso di un mutex di sistema, può indicare che un'applicazione è stata terminata in modo anomalo (ad esempio, usando Gestione attività 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.

Si verifica il chiamante di questo metodo si blocca fino a quando l'istanza corrente riceve un segnale o un timeout.The caller of this method blocks until the current instance receives a signal or a time-out occurs. Usare questo metodo per bloccare fino a un WaitHandle riceve un segnale da un altro thread, ad esempio viene generato 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 altre informazioni, vedere il 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 timeout è Int32.MaxValue.The maximum value for timeout is Int32.MaxValue.

Note sull'uscita dal contestoNotes on Exiting the Context

Il exitContext parametro ha effetto solo se il WaitOne metodo chiamato dall'interno di un contesto gestito.The exitContext parameter has no effect unless the WaitOne method is called from inside a nondefault managed context. Questa situazione può verificarsi se il thread si trova all'interno di una chiamata a un'istanza di una classe derivata da ContextBoundObject.This can happen if your thread is inside a call to an instance of a class derived from ContextBoundObject. Anche se un metodo attualmente in esecuzione in una classe che non deriva da ContextBoundObject, ad esempio String, è possibile essere in un contesto non predefinite se un ContextBoundObject nello stack nel dominio dell'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, che specifica true per exitContext fa sì che il thread esce dal contesto gestito (vale a dire, per eseguire la transizione 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 viene restituito il contesto originale non predefinita dopo la chiamata al WaitOne metodo viene completato.The thread returns to the original nondefault context after the call to the WaitOne method completes.

Ciò può essere utile quando la classe associata al contesto presenta SynchronizationAttribute.This can be useful when the context-bound class has SynchronizationAttribute. In tal caso, tutte le chiamate ai membri della classe sono automaticamente sincronizzate 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 nello stack di chiamate di un membro codice chiama il WaitOne (metodo) e specifica true per exitContext, il thread esce dal dominio di sincronizzazione, consentendo a un thread bloccato in una chiamata a qualsiasi membro dell'oggetto per 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 viene restituito, il thread che ha effettuato la chiamata deve attendere per immettere di nuovo il dominio di sincronizzazione.When the WaitOne method returns, the thread that made the call must wait to reenter the synchronization domain.

Si applica a