ManualResetEventSlim ManualResetEventSlim ManualResetEventSlim ManualResetEventSlim Class

Definición

Representa un evento de sincronización de subprocesos que, cuando se señale, se debe restablecer manualmente.Represents a thread synchronization event that, when signaled, must be reset manually. Esta clase es una alternativa ligera a ManualResetEvent.This class is a lightweight alternative to ManualResetEvent.

public ref class ManualResetEventSlim : IDisposable
[System.Runtime.InteropServices.ComVisible(false)]
public class ManualResetEventSlim : IDisposable
type ManualResetEventSlim = class
    interface IDisposable
Public Class ManualResetEventSlim
Implements IDisposable
Herencia
ManualResetEventSlimManualResetEventSlimManualResetEventSlimManualResetEventSlim
Atributos
Implementaciones

Ejemplos

En el ejemplo siguiente se muestra cómo utilizar ManualResetEventSlimun.The following example shows how to use a ManualResetEventSlim.

using System;
using System.Threading;
using System.Threading.Tasks;
class MRESDemo
{

    static void Main()
    {
        MRES_SetWaitReset();
        MRES_SpinCountWaitHandle();
    }
    // Demonstrates:
    //      ManualResetEventSlim construction
    //      ManualResetEventSlim.Wait()
    //      ManualResetEventSlim.Set()
    //      ManualResetEventSlim.Reset()
    //      ManualResetEventSlim.IsSet
    static void MRES_SetWaitReset()
    {
        ManualResetEventSlim mres1 = new ManualResetEventSlim(false); // initialize as unsignaled
        ManualResetEventSlim mres2 = new ManualResetEventSlim(false); // initialize as unsignaled
        ManualResetEventSlim mres3 = new ManualResetEventSlim(true);  // initialize as signaled

        // Start an asynchronous Task that manipulates mres3 and mres2
        var observer = Task.Factory.StartNew(() =>
        {
            mres1.Wait();
            Console.WriteLine("observer sees signaled mres1!");
            Console.WriteLine("observer resetting mres3...");
            mres3.Reset(); // should switch to unsignaled
            Console.WriteLine("observer signalling mres2");
            mres2.Set();
        });

        Console.WriteLine("main thread: mres3.IsSet = {0} (should be true)", mres3.IsSet);
        Console.WriteLine("main thread signalling mres1");
        mres1.Set(); // This will "kick off" the observer Task
        mres2.Wait(); // This won't return until observer Task has finished resetting mres3
        Console.WriteLine("main thread sees signaled mres2!");
        Console.WriteLine("main thread: mres3.IsSet = {0} (should be false)", mres3.IsSet);

        // It's good form to Dispose() a ManualResetEventSlim when you're done with it
        observer.Wait(); // make sure that this has fully completed
        mres1.Dispose();
        mres2.Dispose();
        mres3.Dispose();
    }

    // Demonstrates:
    //      ManualResetEventSlim construction w/ SpinCount
    //      ManualResetEventSlim.WaitHandle
    static void MRES_SpinCountWaitHandle()
    {
        // Construct a ManualResetEventSlim with a SpinCount of 1000
        // Higher spincount => longer time the MRES will spin-wait before taking lock
        ManualResetEventSlim mres1 = new ManualResetEventSlim(false, 1000);
        ManualResetEventSlim mres2 = new ManualResetEventSlim(false, 1000);

        Task bgTask = Task.Factory.StartNew(() =>
        {
            // Just wait a little
            Thread.Sleep(100);

            // Now signal both MRESes
            Console.WriteLine("Task signalling both MRESes");
            mres1.Set();
            mres2.Set();
        });

        // A common use of MRES.WaitHandle is to use MRES as a participant in 
        // WaitHandle.WaitAll/WaitAny.  Note that accessing MRES.WaitHandle will
        // result in the unconditional inflation of the underlying ManualResetEvent.
        WaitHandle.WaitAll(new WaitHandle[] { mres1.WaitHandle, mres2.WaitHandle });
        Console.WriteLine("WaitHandle.WaitAll(mres1.WaitHandle, mres2.WaitHandle) completed.");

        // Clean up
        bgTask.Wait();
        mres1.Dispose();
        mres2.Dispose();
    }
}
Imports System.Threading
Imports System.Threading.Tasks

Module MRESDemo

    Sub Main()

    End Sub
    ' Demonstrates:
    ' ManualResetEventSlim construction
    ' ManualResetEventSlim.Wait()
    ' ManualResetEventSlim.Set()
    ' ManualResetEventSlim.Reset()
    ' ManualResetEventSlim.IsSet
    Private Sub MRES_SetWaitReset()
        ' initialize as unsignaled
        Dim mres1 As New ManualResetEventSlim(False)
        ' initialize as unsignaled
        Dim mres2 As New ManualResetEventSlim(False)
        ' initialize as signaled
        Dim mres3 As New ManualResetEventSlim(True)

        ' Start an asynchronous Task that manipulates mres3 and mres2
        Dim observer = Task.Factory.StartNew(
            Sub()
                mres1.Wait()
                Console.WriteLine("observer sees signaled mres1!")
                Console.WriteLine("observer resetting mres3...")
                mres3.Reset()
                ' should switch to unsignaled
                Console.WriteLine("observer signalling mres2")
                mres2.[Set]()
            End Sub)

        Console.WriteLine("main thread: mres3.IsSet = {0} (should be true)", mres3.IsSet)
        Console.WriteLine("main thread signalling mres1")
        mres1.[Set]()
        ' This will "kick off" the observer Task
        mres2.Wait()
        ' This won't return until observer Task has finished resetting mres3
        Console.WriteLine("main thread sees signaled mres2!")
        Console.WriteLine("main thread: mres3.IsSet = {0} (should be false)", mres3.IsSet)

        ' make sure that observer has fully completed
        observer.Wait()
        ' It's good form to Dispose() a ManualResetEventSlim when you're done with it
        mres1.Dispose()
        mres2.Dispose()
        mres3.Dispose()
    End Sub

    ' Demonstrates:
    ' ManualResetEventSlim construction w/ SpinCount
    ' ManualResetEventSlim.WaitHandle
    Private Sub MRES_SpinCountWaitHandle()
        ' Construct a ManualResetEventSlim with a SpinCount of 1000
        ' Higher spincount => longer time the MRES will spin-wait before taking lock
        Dim mres1 As New ManualResetEventSlim(False, 1000)
        Dim mres2 As New ManualResetEventSlim(False, 1000)

        Dim bgTask As Task = Task.Factory.StartNew(
            Sub()
                ' Just wait a little
                Thread.Sleep(100)

                ' Now signal both MRESes
                Console.WriteLine("Task signalling both MRESes")
                mres1.[Set]()
                mres2.[Set]()
            End Sub)

        ' A common use of MRES.WaitHandle is to use MRES as a participant in 
        ' WaitHandle.WaitAll/WaitAny. Note that accessing MRES.WaitHandle will
        ' result in the unconditional inflation of the underlying ManualResetEvent.
        WaitHandle.WaitAll(New WaitHandle() {mres1.WaitHandle, mres2.WaitHandle})
        Console.WriteLine("WaitHandle.WaitAll(mres1.WaitHandle, mres2.WaitHandle) completed.")

        ' Wait for bgTask to complete and clean up
        bgTask.Wait()
        mres1.Dispose()
        mres2.Dispose()
    End Sub
End Module

Comentarios

Puede usar esta clase para mejorar el rendimiento que ManualResetEvent cuando se espera que los tiempos de espera sean muy cortos y cuando el evento no cruza un límite de proceso.You can use this class for better performance than ManualResetEvent when wait times are expected to be very short, and when the event does not cross a process boundary. ManualResetEventSlim usa giros de ocupado durante un breve tiempo mientras se espera que se señale el evento.ManualResetEventSlim uses busy spinning for a short time while it waits for the event to become signaled. Cuando los tiempos de espera son breves, los giros pueden ser mucho más económicos que si se espera con identificadores de espera.When wait times are short, spinning can be much less expensive than waiting by using wait handles. Sin embargo, si no se señala el evento dentro de cierto período de tiempo, ManualResetEventSlim recurre a una espera de controlador de evento habitual.However, if the event does not become signaled within a certain period of time, ManualResetEventSlim resorts to a regular event handle wait.

Constructores

ManualResetEventSlim() ManualResetEventSlim() ManualResetEventSlim() ManualResetEventSlim()

Inicializa una nueva instancia de la clase ManualResetEventSlim con el estado inicial establecido en nonsignaled.Initializes a new instance of the ManualResetEventSlim class with an initial state of nonsignaled.

ManualResetEventSlim(Boolean) ManualResetEventSlim(Boolean) ManualResetEventSlim(Boolean) ManualResetEventSlim(Boolean)

Inicializa una nueva instancia de la clase ManualResetEventSlim con un valor booleano que indica si hay que establecer el estado inicial en señalado.Initializes a new instance of the ManualResetEventSlim class with a Boolean value indicating whether to set the initial state to signaled.

ManualResetEventSlim(Boolean, Int32) ManualResetEventSlim(Boolean, Int32) ManualResetEventSlim(Boolean, Int32) ManualResetEventSlim(Boolean, Int32)

Inicializa una instancia nueva de la clase ManualResetEventSlim con un valor booleano que indica si hay que establecer el estado inicial en señalado y un recuento circular especificado.Initializes a new instance of the ManualResetEventSlim class with a Boolean value indicating whether to set the initial state to signaled and a specified spin count.

Propiedades

IsSet IsSet IsSet IsSet

Obtiene un valor que indica si se ha establecido el evento.Gets whether the event is set.

SpinCount SpinCount SpinCount SpinCount

Obtiene el número de esperas circulares que se van a producir antes de una operación de espera basada en kernel.Gets the number of spin waits that will occur before falling back to a kernel-based wait operation.

WaitHandle WaitHandle WaitHandle WaitHandle

Obtiene el objeto WaitHandle subyacente de este objeto ManualResetEventSlim.Gets the underlying WaitHandle object for this ManualResetEventSlim.

Métodos

Dispose() Dispose() Dispose() Dispose()

Libera todos los recursos usados por la instancia actual de la clase ManualResetEventSlim.Releases all resources used by the current instance of the ManualResetEventSlim class.

Dispose(Boolean) Dispose(Boolean) Dispose(Boolean) Dispose(Boolean)

Libera los recursos no administrados utilizados por el objeto ManualResetEventSlim y, de forma opcional, libera los recursos administrados.Releases the unmanaged resources used by the ManualResetEventSlim, and optionally releases the managed resources.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Determina si el objeto especificado es igual al objeto actual.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Sirve como la función hash predeterminada.Serves as the default hash function.

(Inherited from Object)
GetType() GetType() GetType() GetType()

Obtiene el Type de la instancia actual.Gets the Type of the current instance.

(Inherited from Object)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crea una copia superficial del objeto Object actual.Creates a shallow copy of the current Object.

(Inherited from Object)
Reset() Reset() Reset() Reset()

Establece el estado del evento en no señalado, por lo que se bloquean los subprocesos.Sets the state of the event to nonsignaled, which causes threads to block.

Set() Set() Set() Set()

Establece el estado del evento en señalado, lo que permite la continuación de uno o varios subprocesos que están esperando en el evento.Sets the state of the event to signaled, which allows one or more threads waiting on the event to proceed.

ToString() ToString() ToString() ToString()

Devuelve una cadena que representa el objeto actual.Returns a string that represents the current object.

(Inherited from Object)
Wait() Wait() Wait() Wait()

Bloquea el subproceso actual hasta que se establezca el objeto ManualResetEventSlim actual.Blocks the current thread until the current ManualResetEventSlim is set.

Wait(CancellationToken) Wait(CancellationToken) Wait(CancellationToken) Wait(CancellationToken)

Bloquea el subproceso actual hasta que el objeto ManualResetEventSlim actual reciba una señal, mientras se observa un token CancellationToken.Blocks the current thread until the current ManualResetEventSlim receives a signal, while observing a CancellationToken.

Wait(Int32) Wait(Int32) Wait(Int32) Wait(Int32)

Bloquea el subproceso actual hasta que se establezca el objeto ManualResetEventSlim actual, usando un entero de 32 bits con signo para medir el intervalo de tiempo.Blocks the current thread until the current ManualResetEventSlim is set, using a 32-bit signed integer to measure the time interval.

Wait(Int32, CancellationToken) Wait(Int32, CancellationToken) Wait(Int32, CancellationToken) Wait(Int32, CancellationToken)

Bloquea el subproceso actual hasta que se establezca el objeto ManualResetEventSlim actual, usando un entero de 32 bits con signo para medir el intervalo de tiempo, mientras se observa un token CancellationToken.Blocks the current thread until the current ManualResetEventSlim is set, using a 32-bit signed integer to measure the time interval, while observing a CancellationToken.

Wait(TimeSpan) Wait(TimeSpan) Wait(TimeSpan) Wait(TimeSpan)

Bloquea el subproceso actual hasta que se establezca el objeto ManualResetEventSlim actual, utilizando un objeto TimeSpan para medir el intervalo de tiempo.Blocks the current thread until the current ManualResetEventSlim is set, using a TimeSpan to measure the time interval.

Wait(TimeSpan, CancellationToken) Wait(TimeSpan, CancellationToken) Wait(TimeSpan, CancellationToken) Wait(TimeSpan, CancellationToken)

Bloquea el subproceso actual hasta que se establezca el objeto ManualResetEventSlim actual, usando un objeto TimeSpan para medir el intervalo de tiempo, mientras se observa un token CancellationToken.Blocks the current thread until the current ManualResetEventSlim is set, using a TimeSpan to measure the time interval, while observing a CancellationToken.

Se aplica a

Seguridad para subprocesos

Todos los miembros públicos y protegidos ManualResetEventSlim de son seguros para subprocesos y se pueden usar simultáneamente desde varios subprocesos, con la excepción de Dispose, que solo se debe usar cuando todas ManualResetEventSlim las demás operaciones de se han completado y se restablecen, que deben solo se puede usar cuando ningún otro subproceso tiene acceso al evento.All public and protected members of ManualResetEventSlim are thread-safe and may be used concurrently from multiple threads, with the exception of Dispose, which must only be used when all other operations on the ManualResetEventSlim have completed, and Reset, which should only be used when no other threads are accessing the event.

Consulte también: