ThreadPool.RegisterWaitForSingleObject Método

Definição

Namespace:

System.Threading

Assembly:

System.Threading.ThreadPool.dll

Registra um representante que está aguardando um WaitHandle.

Sobrecargas

RegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, UInt32, Boolean)	Registra um delegado para aguardar um WaitHandle, especificando um inteiro sem sinal de 32 bits para o tempo limite em milissegundos.
RegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, TimeSpan, Boolean)	Registra um delegado para aguardar um WaitHandle, especificando um valor TimeSpan para o tempo limite.
RegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, Int32, Boolean)	Registra um delegado para esperar um WaitHandle, especificando um inteiro com sinal de 32 bits para o tempo limite em milissegundos.
RegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, Int64, Boolean)	Registra um delegado para esperar um WaitHandle, especificando um inteiro com sinal de 64 bits para o tempo limite em milissegundos.

RegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, UInt32, Boolean)

Origem:

ThreadPoolWorkQueue.cs

Importante

Esta API não está em conformidade com CLS.

Registra um delegado para aguardar um WaitHandle, especificando um inteiro sem sinal de 32 bits para o tempo limite em milissegundos.

public:
 static System::Threading::RegisteredWaitHandle ^ RegisterWaitForSingleObject(System::Threading::WaitHandle ^ waitObject, System::Threading::WaitOrTimerCallback ^ callBack, System::Object ^ state, System::UInt32 millisecondsTimeOutInterval, bool executeOnlyOnce);

[System.CLSCompliant(false)]
[System.Runtime.Versioning.UnsupportedOSPlatform("browser")]
public static System.Threading.RegisteredWaitHandle RegisterWaitForSingleObject (System.Threading.WaitHandle waitObject, System.Threading.WaitOrTimerCallback callBack, object? state, uint millisecondsTimeOutInterval, bool executeOnlyOnce);

[<System.CLSCompliant(false)>]
[<System.Runtime.Versioning.UnsupportedOSPlatform("browser")>]
static member RegisterWaitForSingleObject : System.Threading.WaitHandle * System.Threading.WaitOrTimerCallback * obj * uint32 * bool -> System.Threading.RegisteredWaitHandle

Public Shared Function RegisterWaitForSingleObject (waitObject As WaitHandle, callBack As WaitOrTimerCallback, state As Object, millisecondsTimeOutInterval As UInteger, executeOnlyOnce As Boolean) As RegisteredWaitHandle

Parâmetros

waitObject

WaitHandle

O WaitHandle a ser registrado. Use um WaitHandle diferente do Mutex.

callBack

WaitOrTimerCallback

O delegado WaitOrTimerCallback a ser chamado quando o parâmetro waitObject é sinalizado.

state

Object

O objeto passado ao delegado.

millisecondsTimeOutInterval

UInt32

O tempo limite em milissegundos. Se o parâmetro millisecondsTimeOutInterval for 0 (zero), a função testará o estado do objeto e será imediatamente retornada. Se millisecondsTimeOutInterval for -1, o intervalo de tempo limite da função nunca expirará.

executeOnlyOnce

Boolean

true para indicar que o thread não esperará o parâmetro waitObject depois que o delegado for chamado; false para indicar que o temporizador será reiniciado sempre que a operação de espera for concluída até que o registro da espera seja cancelado.

Retornos

RegisteredWaitHandle

O RegisteredWaitHandle que pode ser usado para cancelar a operação de espera registrada.

Atributos

CLSCompliantAttribute UnsupportedOSPlatformAttribute

Exceções

ArgumentOutOfRangeException

O parâmetro millisecondsTimeOutInterval é menor que -1.

Exemplos

O exemplo a seguir mostra como usar o RegisterWaitForSingleObject método para executar um método de retorno de chamada especificado quando um identificador de espera especificado é sinalizado. Neste exemplo, o método de retorno de chamada é WaitProce o identificador de espera é um AutoResetEvent.

O exemplo define uma TaskInfo classe para manter as informações passadas para o retorno de chamada quando ela é executada. O exemplo cria um TaskInfo objeto e atribui a ele alguns dados de cadeia de caracteres. O RegisteredWaitHandle retornado pelo RegisterWaitForSingleObject método é atribuído ao campo do TaskInfo objeto para Handle que o método de retorno de chamada tenha acesso ao RegisteredWaitHandle.

Além de TaskInfo especificar como o objeto a ser passado para o método de retorno de chamada, a chamada para o RegisterWaitForSingleObject método especifica o AutoResetEvent pelo qual a tarefa aguardará, um WaitOrTimerCallback delegado que representa o WaitProc método de retorno de chamada, um intervalo de tempo limite de um segundo e vários retornos de chamada.

Quando o thread main sinaliza o AutoResetEvent chamando seu Set método, o WaitOrTimerCallback delegado é invocado. O WaitProc método testa RegisteredWaitHandle para determinar se ocorreu um tempo limite. Se o retorno de chamada foi invocado porque o identificador de espera foi sinalizado, o WaitProc método cancela o registro do RegisteredWaitHandle, interrompendo retornos de chamada adicionais. No caso de um tempo limite, a tarefa continua aguardando. O WaitProc método termina imprimindo uma mensagem no console.

using namespace System;
using namespace System::Threading;

// TaskInfo contains data that will be passed to the callback
// method.
public ref class TaskInfo
{
public:
   TaskInfo()
   {
      Handle = nullptr;
      OtherInfo = "default";
   }

   RegisteredWaitHandle^ Handle;
   String^ OtherInfo;
};

ref class Example
{
public:

   // The callback method executes when the registered wait times out,
   // or when the WaitHandle (in this case AutoResetEvent) is signaled.
   // WaitProc unregisters the WaitHandle the first time the event is 
   // signaled.
   static void WaitProc( Object^ state, bool timedOut )
   {
      
      // The state Object must be cast to the correct type, because the
      // signature of the WaitOrTimerCallback delegate specifies type
      // Object.
      TaskInfo^ ti = static_cast<TaskInfo^>(state);
      String^ cause = "TIMED OUT";
      if (  !timedOut )
      {
         cause = "SIGNALED";
         
         // If the callback method executes because the WaitHandle is
         // signaled, stop future execution of the callback method
         // by unregistering the WaitHandle.
         if ( ti->Handle != nullptr )
                  ti->Handle->Unregister( nullptr );
      }

      Console::WriteLine( "WaitProc( {0}) executes on thread {1}; cause = {2}.", ti->OtherInfo, Thread::CurrentThread->GetHashCode(), cause );
   }

};

int main()
{
   
   // The main thread uses AutoResetEvent to signal the
   // registered wait handle, which executes the callback
   // method.
   AutoResetEvent^ ev = gcnew AutoResetEvent( false );
   TaskInfo^ ti = gcnew TaskInfo;
   ti->OtherInfo = "First task";
   
   // The TaskInfo for the task includes the registered wait
   // handle returned by RegisterWaitForSingleObject.  This
   // allows the wait to be terminated when the object has
   // been signaled once (see WaitProc).
   ti->Handle = ThreadPool::RegisterWaitForSingleObject( ev, gcnew WaitOrTimerCallback( Example::WaitProc ), ti, 1000, false );
   
   // The main thread waits three seconds, to demonstrate the
   // time-outs on the queued thread, and then signals.
   Thread::Sleep( 3100 );
   Console::WriteLine( "Main thread signals." );
   ev->Set();
   
   // The main thread sleeps, which should give the callback
   // method time to execute.  If you comment out this line, the
   // program usually ends before the ThreadPool thread can execute.
   Thread::Sleep( 1000 );
   
   // If you start a thread yourself, you can wait for it to end
   // by calling Thread::Join.  This option is not available with 
   // thread pool threads.
   return 0;
}

using System;
using System.Threading;

// TaskInfo contains data that will be passed to the callback
// method.
public class TaskInfo {
    public RegisteredWaitHandle Handle = null;
    public string OtherInfo = "default";
}

public class Example {
    public static void Main(string[] args) {
        // The main thread uses AutoResetEvent to signal the
        // registered wait handle, which executes the callback
        // method.
        AutoResetEvent ev = new AutoResetEvent(false);

        TaskInfo ti = new TaskInfo();
        ti.OtherInfo = "First task";
        // The TaskInfo for the task includes the registered wait
        // handle returned by RegisterWaitForSingleObject.  This
        // allows the wait to be terminated when the object has
        // been signaled once (see WaitProc).
        ti.Handle = ThreadPool.RegisterWaitForSingleObject(
            ev,
            new WaitOrTimerCallback(WaitProc),
            ti,
            1000,
            false
        );

        // The main thread waits three seconds, to demonstrate the
        // time-outs on the queued thread, and then signals.
        Thread.Sleep(3100);
        Console.WriteLine("Main thread signals.");
        ev.Set();

        // The main thread sleeps, which should give the callback
        // method time to execute.  If you comment out this line, the
        // program usually ends before the ThreadPool thread can execute.
        Thread.Sleep(1000);
        // If you start a thread yourself, you can wait for it to end
        // by calling Thread.Join.  This option is not available with 
        // thread pool threads.
    }
   
    // The callback method executes when the registered wait times out,
    // or when the WaitHandle (in this case AutoResetEvent) is signaled.
    // WaitProc unregisters the WaitHandle the first time the event is 
    // signaled.
    public static void WaitProc(object state, bool timedOut) {
        // The state object must be cast to the correct type, because the
        // signature of the WaitOrTimerCallback delegate specifies type
        // Object.
        TaskInfo ti = (TaskInfo) state;

        string cause = "TIMED OUT";
        if (!timedOut) {
            cause = "SIGNALED";
            // If the callback method executes because the WaitHandle is
            // signaled, stop future execution of the callback method
            // by unregistering the WaitHandle.
            if (ti.Handle != null)
                ti.Handle.Unregister(null);
        } 

        Console.WriteLine("WaitProc( {0} ) executes on thread {1}; cause = {2}.",
            ti.OtherInfo, 
            Thread.CurrentThread.GetHashCode().ToString(), 
            cause
        );
    }
}

Imports System.Threading

' TaskInfo contains data that will be passed to the callback
' method.
Public Class TaskInfo
    public Handle As RegisteredWaitHandle = Nothing
    public OtherInfo As String = "default"
End Class

Public Class Example

    <MTAThread> _
    Public Shared Sub Main()
        ' The main thread uses AutoResetEvent to signal the
        ' registered wait handle, which executes the callback
        ' method.
        Dim ev As New AutoResetEvent(false)

        Dim ti As New TaskInfo()
        ti.OtherInfo = "First task"
        ' The TaskInfo for the task includes the registered wait
        ' handle returned by RegisterWaitForSingleObject.  This
        ' allows the wait to be terminated when the object has
        ' been signaled once (see WaitProc).
        ti.Handle = ThreadPool.RegisterWaitForSingleObject( _
            ev, _
            New WaitOrTimerCallback(AddressOf WaitProc), _
            ti, _
            1000, _
            false _
        )

        ' The main thread waits about three seconds, to demonstrate 
        ' the time-outs on the queued task, and then signals.
        Thread.Sleep(3100)
        Console.WriteLine("Main thread signals.")
        ev.Set()

        ' The main thread sleeps, which should give the callback
        ' method time to execute.  If you comment out this line, the
        ' program usually ends before the ThreadPool thread can execute.
        Thread.Sleep(1000)
        ' If you start a thread yourself, you can wait for it to end
        ' by calling Thread.Join.  This option is not available with 
        ' thread pool threads.
    End Sub
   
    ' The callback method executes when the registered wait times out,
    ' or when the WaitHandle (in this case AutoResetEvent) is signaled.
    ' WaitProc unregisters the WaitHandle the first time the event is 
    ' signaled.
    Public Shared Sub WaitProc(state As Object, timedOut As Boolean)
        ' The state object must be cast to the correct type, because the
        ' signature of the WaitOrTimerCallback delegate specifies type
        ' Object.
        Dim ti As TaskInfo = CType(state, TaskInfo)

        Dim cause As String = "TIMED OUT"
        If Not timedOut Then
            cause = "SIGNALED"
            ' If the callback method executes because the WaitHandle is
            ' signaled, stop future execution of the callback method
            ' by unregistering the WaitHandle.
            If Not ti.Handle Is Nothing Then
                ti.Handle.Unregister(Nothing)
            End If
        End If 

        Console.WriteLine("WaitProc( {0} ) executes on thread {1}; cause = {2}.", _
            ti.OtherInfo, _
            Thread.CurrentThread.GetHashCode().ToString(), _
            cause _
        )
    End Sub
End Class

Comentários

Quando terminar de usar o RegisteredWaitHandle retornado por esse método, chame seu RegisteredWaitHandle.Unregister método para liberar referências ao identificador de espera. Recomendamos que você sempre chame o RegisteredWaitHandle.Unregister método , mesmo que especifique true para executeOnlyOnce. A coleta de lixo funcionará com mais eficiência se você chamar o RegisteredWaitHandle.Unregister método em vez de depender do finalizador do identificador de espera registrado.

O RegisterWaitForSingleObject método enfileira o delegado especificado para o pool de threads. Um thread de trabalho executará o delegado quando ocorrer um dos seguintes procedimentos:

• O objeto especificado está no estado sinalizado.
• O intervalo de tempo limite passa.

O RegisterWaitForSingleObject método verifica o estado atual do objeto WaitHandleespecificado. Se o estado do objeto não estiver assinado, o método registrará uma operação de espera. A operação de espera é executada por um thread do pool de threads. O delegado é executado por um thread de trabalho quando o estado do objeto é sinalizado ou o intervalo de tempo limite decorrido. Se o timeOutInterval parâmetro não for 0 (zero) e o executeOnlyOnce parâmetro for false, o temporizador será redefinido sempre que o evento for sinalizado ou o intervalo de tempo limite decorrido.

Importante

O uso de um Mutex para waitObject não fornece exclusão mútua para os retornos de chamada porque a API subjacente do Windows usa o sinalizador padrão WT_EXECUTEDEFAULT , portanto, cada retorno de chamada é expedido em um thread de pool de threads separado. Em vez de um Mutex, use um Semaphore com uma contagem máxima de 1.

Para cancelar a operação de espera, chame o RegisteredWaitHandle.Unregister método .

O thread de espera usa a função Win32 WaitForMultipleObjects para monitorar operações de espera registradas. Portanto, se você precisar usar o mesmo identificador do sistema operacional nativo em várias chamadas para RegisterWaitForSingleObject, deverá duplicar o identificador usando a função Win32 DuplicateHandle . Observe que você não deve pulsar um objeto de evento passado para RegisterWaitForSingleObject, porque o thread de espera pode não detectar que o evento é sinalizado antes de ser redefinido.

Antes de retornar, a função modifica o estado de alguns tipos de objetos de sincronização. A modificação ocorre apenas para o objeto cujo estado sinalizado fez com que a condição de espera fosse atendida. Por exemplo, a contagem de um semáforo é reduzida em um.

Confira também

• O pool de threads gerenciados

RegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, TimeSpan, Boolean)

Origem:

ThreadPoolWorkQueue.cs

Registra um delegado para aguardar um WaitHandle, especificando um valor TimeSpan para o tempo limite.

public:
 static System::Threading::RegisteredWaitHandle ^ RegisterWaitForSingleObject(System::Threading::WaitHandle ^ waitObject, System::Threading::WaitOrTimerCallback ^ callBack, System::Object ^ state, TimeSpan timeout, bool executeOnlyOnce);

[System.Runtime.Versioning.UnsupportedOSPlatform("browser")]
public static System.Threading.RegisteredWaitHandle RegisterWaitForSingleObject (System.Threading.WaitHandle waitObject, System.Threading.WaitOrTimerCallback callBack, object? state, TimeSpan timeout, bool executeOnlyOnce);

[<System.Runtime.Versioning.UnsupportedOSPlatform("browser")>]
static member RegisterWaitForSingleObject : System.Threading.WaitHandle * System.Threading.WaitOrTimerCallback * obj * TimeSpan * bool -> System.Threading.RegisteredWaitHandle

Public Shared Function RegisterWaitForSingleObject (waitObject As WaitHandle, callBack As WaitOrTimerCallback, state As Object, timeout As TimeSpan, executeOnlyOnce As Boolean) As RegisteredWaitHandle

Parâmetros

waitObject

WaitHandle

O WaitHandle a ser registrado. Use um WaitHandle diferente do Mutex.

callBack

WaitOrTimerCallback

O delegado WaitOrTimerCallback a ser chamado quando o parâmetro waitObject é sinalizado.

state

Object

O objeto passado ao delegado.

timeout

TimeSpan

O tempo limite representado por um TimeSpan. Se timeout for 0 (zero), a função testará o estado do objeto e será retornada imediatamente. Se timeout for -1, o intervalo de tempo limite da função nunca expirará.

executeOnlyOnce

Boolean

true para indicar que o thread não esperará o parâmetro waitObject depois que o delegado for chamado; false para indicar que o temporizador será reiniciado sempre que a operação de espera for concluída até que o registro da espera seja cancelado.

Retornos

RegisteredWaitHandle

O RegisteredWaitHandle que encapsula o identificador nativo.

Atributos

UnsupportedOSPlatformAttribute

Exceções

ArgumentOutOfRangeException

O parâmetro timeout é menor que -1.

NotSupportedException

O timeout parâmetro é maior que Int32.MaxValue.

Comentários

Quando terminar de usar o RegisteredWaitHandle retornado por esse método, chame seu RegisteredWaitHandle.Unregister método para liberar referências ao identificador de espera. Recomendamos que você sempre chame o RegisteredWaitHandle.Unregister método , mesmo que especifique true para executeOnlyOnce. A coleta de lixo funcionará com mais eficiência se você chamar o RegisteredWaitHandle.Unregister método em vez de depender do finalizador do identificador de espera registrado.

O RegisterWaitForSingleObject método enfileira o delegado especificado para o pool de threads. Um thread de trabalho executará o delegado quando ocorrer um dos seguintes procedimentos:

• O objeto especificado está no estado sinalizado.
• O intervalo de tempo limite passa.

O RegisterWaitForSingleObject método verifica o estado atual do objeto WaitHandleespecificado. Se o estado do objeto não estiver assinado, o método registrará uma operação de espera. A operação de espera é executada por um thread do pool de threads. O delegado é executado por um thread de trabalho quando o estado do objeto é sinalizado ou o intervalo de tempo limite decorrido. Se o timeOutInterval parâmetro não for 0 (zero) e o executeOnlyOnce parâmetro for false, o temporizador será redefinido sempre que o evento for sinalizado ou o intervalo de tempo limite decorrido.

Importante

O uso de um Mutex para waitObject não fornece exclusão mútua para os retornos de chamada porque a API subjacente do Windows usa o sinalizador padrão WT_EXECUTEDEFAULT , portanto, cada retorno de chamada é expedido em um thread de pool de threads separado. Em vez de um Mutex, use um Semaphore com uma contagem máxima de 1.

Para cancelar a operação de espera, chame o RegisteredWaitHandle.Unregister método .

O thread de espera usa a função Win32 WaitForMultipleObjects para monitorar operações de espera registradas. Portanto, se você precisar usar o mesmo identificador do sistema operacional nativo em várias chamadas para RegisterWaitForSingleObject, deverá duplicar o identificador usando a função Win32 DuplicateHandle . Observe que você não deve pulsar um objeto de evento passado para RegisterWaitForSingleObject, porque o thread de espera pode não detectar que o evento é sinalizado antes de ser redefinido.

Antes de retornar, a função modifica o estado de alguns tipos de objetos de sincronização. A modificação ocorre apenas para o objeto cujo estado sinalizado fez com que a condição de espera fosse atendida. Por exemplo, a contagem de um semáforo é reduzida em um.

Confira também

• O pool de threads gerenciados

RegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, Int32, Boolean)

Origem:

ThreadPoolWorkQueue.cs

Registra um delegado para esperar um WaitHandle, especificando um inteiro com sinal de 32 bits para o tempo limite em milissegundos.

public:
 static System::Threading::RegisteredWaitHandle ^ RegisterWaitForSingleObject(System::Threading::WaitHandle ^ waitObject, System::Threading::WaitOrTimerCallback ^ callBack, System::Object ^ state, int millisecondsTimeOutInterval, bool executeOnlyOnce);

[System.Runtime.Versioning.UnsupportedOSPlatform("browser")]
public static System.Threading.RegisteredWaitHandle RegisterWaitForSingleObject (System.Threading.WaitHandle waitObject, System.Threading.WaitOrTimerCallback callBack, object? state, int millisecondsTimeOutInterval, bool executeOnlyOnce);

[<System.Runtime.Versioning.UnsupportedOSPlatform("browser")>]
static member RegisterWaitForSingleObject : System.Threading.WaitHandle * System.Threading.WaitOrTimerCallback * obj * int * bool -> System.Threading.RegisteredWaitHandle

Public Shared Function RegisterWaitForSingleObject (waitObject As WaitHandle, callBack As WaitOrTimerCallback, state As Object, millisecondsTimeOutInterval As Integer, executeOnlyOnce As Boolean) As RegisteredWaitHandle

Parâmetros

waitObject

WaitHandle

O WaitHandle a ser registrado. Use um WaitHandle diferente do Mutex.

callBack

WaitOrTimerCallback

O delegado WaitOrTimerCallback para chamar quando o parâmetro waitObject for sinalizado.

state

Object

O objeto que é passado para o delegado.

millisecondsTimeOutInterval

Int32

O tempo limite em milissegundos. Se o parâmetro millisecondsTimeOutInterval for 0 (zero), a função testará o estado do objeto e será imediatamente retornada. Se millisecondsTimeOutInterval for -1, o intervalo de tempo limite da função nunca expirará.

executeOnlyOnce

Boolean

true para indicar que o thread não esperará o parâmetro waitObject depois que o delegado for chamado; false para indicar que o temporizador será reiniciado sempre que a operação de espera for concluída até que o registro da espera seja cancelado.

Retornos

RegisteredWaitHandle

O RegisteredWaitHandle que encapsula o identificador nativo.

Atributos

UnsupportedOSPlatformAttribute

Exceções

ArgumentOutOfRangeException

O parâmetro millisecondsTimeOutInterval é menor que -1.

Comentários

Quando terminar de usar o RegisteredWaitHandle que é retornado por esse método, chame seu RegisteredWaitHandle.Unregister método para liberar referências ao identificador de espera. Recomendamos que você sempre chame o RegisteredWaitHandle.Unregister método , mesmo que especifique true para executeOnlyOnce. A coleta de lixo funciona com mais eficiência se você chamar o RegisteredWaitHandle.Unregister método em vez de depender do finalizador do identificador de espera registrado.

O RegisterWaitForSingleObject método enfileira o delegado especificado para o pool de threads. Um thread de trabalho executará o delegado quando ocorrer um dos seguintes procedimentos:

• O objeto especificado está no estado sinalizado.
• O intervalo de tempo limite passa.

O RegisterWaitForSingleObject método verifica o estado atual do objeto WaitHandleespecificado. Se o estado do objeto não estiver assinado, o método registrará uma operação de espera. A operação de espera é executada por um thread do pool de threads. O delegado é executado por um thread de trabalho quando o estado do objeto é sinalizado ou o intervalo de tempo limite passa. Se o timeOutInterval parâmetro não for 0 (zero) e o executeOnlyOnce parâmetro for false, o temporizador será redefinido sempre que o evento for sinalizado ou o intervalo de tempo limite decorrer.

Importante

O uso de um Mutex para waitObject não fornece exclusão mútua para os retornos de chamada porque a API subjacente do Windows usa o sinalizador padrão WT_EXECUTEDEFAULT , portanto, cada retorno de chamada é expedido em um thread de pool de threads separado. Em vez de um Mutex, use um Semaphore com uma contagem máxima de 1.

Para cancelar a operação de espera, chame o RegisteredWaitHandle.Unregister método .

O thread de espera usa a função Win32 WaitForMultipleObjects para monitorar operações de espera registradas. Portanto, se você precisar usar o mesmo identificador de sistema operacional nativo em várias chamadas para RegisterWaitForSingleObject, deverá duplicar o identificador usando a função Win32 DuplicateHandle . Observe que você não deve pulsar um objeto de evento passado para RegisterWaitForSingleObject, porque o thread de espera pode não detectar que o evento é sinalizado antes de ser redefinido.

Antes de retornar, a função modifica o estado de alguns tipos de objetos de sincronização. A modificação ocorre apenas para o objeto cujo estado sinalizado fez com que a condição de espera fosse atendida. Por exemplo, a contagem de um semáforo é reduzida em um.

Confira também

• O pool de threads gerenciados

RegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, Int64, Boolean)

Origem:

ThreadPoolWorkQueue.cs

Registra um delegado para esperar um WaitHandle, especificando um inteiro com sinal de 64 bits para o tempo limite em milissegundos.

public:
 static System::Threading::RegisteredWaitHandle ^ RegisterWaitForSingleObject(System::Threading::WaitHandle ^ waitObject, System::Threading::WaitOrTimerCallback ^ callBack, System::Object ^ state, long millisecondsTimeOutInterval, bool executeOnlyOnce);

[System.Runtime.Versioning.UnsupportedOSPlatform("browser")]
public static System.Threading.RegisteredWaitHandle RegisterWaitForSingleObject (System.Threading.WaitHandle waitObject, System.Threading.WaitOrTimerCallback callBack, object? state, long millisecondsTimeOutInterval, bool executeOnlyOnce);

[<System.Runtime.Versioning.UnsupportedOSPlatform("browser")>]
static member RegisterWaitForSingleObject : System.Threading.WaitHandle * System.Threading.WaitOrTimerCallback * obj * int64 * bool -> System.Threading.RegisteredWaitHandle

Public Shared Function RegisterWaitForSingleObject (waitObject As WaitHandle, callBack As WaitOrTimerCallback, state As Object, millisecondsTimeOutInterval As Long, executeOnlyOnce As Boolean) As RegisteredWaitHandle

Parâmetros

waitObject

WaitHandle

O WaitHandle a ser registrado. Use um WaitHandle diferente do Mutex.

callBack

WaitOrTimerCallback

O delegado WaitOrTimerCallback a ser chamado quando o parâmetro waitObject é sinalizado.

state

Object

O objeto passado ao delegado.

millisecondsTimeOutInterval

Int64

O tempo limite em milissegundos. Se o parâmetro millisecondsTimeOutInterval for 0 (zero), a função testará o estado do objeto e será imediatamente retornada. Se millisecondsTimeOutInterval for -1, o intervalo de tempo limite da função nunca expirará.

executeOnlyOnce

Boolean

true para indicar que o thread não esperará o parâmetro waitObject depois que o delegado for chamado; false para indicar que o temporizador será reiniciado sempre que a operação de espera for concluída até que o registro da espera seja cancelado.

Retornos

RegisteredWaitHandle

O RegisteredWaitHandle que encapsula o identificador nativo.

Atributos

UnsupportedOSPlatformAttribute

Exceções

ArgumentOutOfRangeException

O parâmetro millisecondsTimeOutInterval é menor que -1.

Comentários

Quando terminar de usar o RegisteredWaitHandle que é retornado por esse método, chame seu RegisteredWaitHandle.Unregister método para liberar referências ao identificador de espera. Recomendamos que você sempre chame o RegisteredWaitHandle.Unregister método , mesmo que especifique true para executeOnlyOnce. A coleta de lixo funciona com mais eficiência se você chamar o RegisteredWaitHandle.Unregister método em vez de depender do finalizador do identificador de espera registrado.

O RegisterWaitForSingleObject método enfileira o delegado especificado para o pool de threads. Um thread de trabalho executará o delegado quando ocorrer um dos seguintes procedimentos:

• O objeto especificado está no estado sinalizado.
• O intervalo de tempo limite passa.

O RegisterWaitForSingleObject método verifica o estado atual do objeto WaitHandleespecificado. Se o estado do objeto não estiver assinado, o método registrará uma operação de espera. A operação de espera é executada por um thread do pool de threads. O delegado é executado por um thread de trabalho quando o estado do objeto é sinalizado ou o intervalo de tempo limite passa. Se o timeOutInterval parâmetro não for 0 (zero) e o executeOnlyOnce parâmetro for false, o temporizador será redefinido sempre que o evento for sinalizado ou o intervalo de tempo limite decorrer.

Importante

O uso de um Mutex para waitObject não fornece exclusão mútua para os retornos de chamada porque a API subjacente do Windows usa o sinalizador padrão WT_EXECUTEDEFAULT , portanto, cada retorno de chamada é expedido em um thread de pool de threads separado. Em vez de um Mutex, use um Semaphore com uma contagem máxima de 1.

Para cancelar a operação de espera, chame o RegisteredWaitHandle.Unregister método .

O thread de espera usa a função Win32 WaitForMultipleObjects para monitorar operações de espera registradas. Portanto, se você precisar usar o mesmo identificador de sistema operacional nativo em várias chamadas para RegisterWaitForSingleObject, deverá duplicar o identificador usando a função Win32 DuplicateHandle . Observe que você não deve pulsar um objeto de evento passado para RegisterWaitForSingleObject, porque o thread de espera pode não detectar que o evento é sinalizado antes de ser redefinido.

Antes de retornar, a função modifica o estado de alguns tipos de objetos de sincronização. A modificação ocorre apenas para o objeto cujo estado sinalizado fez com que a condição de espera fosse atendida. Por exemplo, a contagem de um semáforo é reduzida em um.

Confira também

• O pool de threads gerenciados