ManualResetEventSlim ManualResetEventSlim ManualResetEventSlim ManualResetEventSlim Class

Definizione

Rappresenta un evento di sincronizzazione dei thread che, quando viene segnalato, deve essere reimpostato manualmente.Represents a thread synchronization event that, when signaled, must be reset manually. La classe è un'alternativa leggera 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
Ereditarietà
ManualResetEventSlimManualResetEventSlimManualResetEventSlimManualResetEventSlim
Attributi
Implementazioni

Esempi

Nell'esempio seguente viene illustrato come utilizzare un ManualResetEventSlim.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

Commenti

È possibile usare questa classe per ottenere prestazioni migliori rispetto a ManualResetEvent quando si prevedono tempi di attesa molto brevi e quando l'evento non supera un limite di processo.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 una rotazione per un breve periodo di tempo mentre si attende che l'evento venga segnalato.ManualResetEventSlim uses busy spinning for a short time while it waits for the event to become signaled. Quando i tempi di attesa sono brevi, la rotazione può essere molto meno costosa rispetto all'attesa tramite handle di attesa.When wait times are short, spinning can be much less expensive than waiting by using wait handles. Se tuttavia l'evento non viene segnalato entro un determinato periodo di tempo, ManualResetEventSlim ricorre a una normale attesa di handle dell'evento.However, if the event does not become signaled within a certain period of time, ManualResetEventSlim resorts to a regular event handle wait.

Costruttori

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

Inizializza una nuova istanza della classe ManualResetEventSlim con uno stato iniziale di non segnalato.Initializes a new instance of the ManualResetEventSlim class with an initial state of nonsignaled.

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

Consente l'inizializzazione di una nuova istanza della classe ManualResetEventSlim con un valore Booleano che indica se lo stato iniziale deve essere impostato su segnalato.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)

Inizializza una nuova istanza della classe ManualResetEventSlim con un valore booleano che indica se impostare lo stato iniziale su segnalato e un conteggio delle rotazioni specificato.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.

Proprietà

IsSet IsSet IsSet IsSet

Ottiene un valore che indica se l'evento è impostato.Gets whether the event is set.

SpinCount SpinCount SpinCount SpinCount

Ottiene il numero di attese di rotazione che devono verificarsi prima di eseguire il fallback su un'operazione di attesa basata sul kernel.Gets the number of spin waits that will occur before falling back to a kernel-based wait operation.

WaitHandle WaitHandle WaitHandle WaitHandle

Ottiene l'oggetto WaitHandle sottostante per questo oggetto ManualResetEventSlim.Gets the underlying WaitHandle object for this ManualResetEventSlim.

Metodi

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

Rilascia tutte le risorse usate dall'istanza corrente della classe ManualResetEventSlim.Releases all resources used by the current instance of the ManualResetEventSlim class.

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

Rilascia le risorse non gestite usate dall'oggetto ManualResetEventSlim e, facoltativamente, le risorse gestite.Releases the unmanaged resources used by the ManualResetEventSlim, and optionally releases the managed resources.

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

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

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

Funge da funzione hash predefinita.Serves as the default hash function.

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

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

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

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

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

Imposta lo stato dell'evento su non segnalato, provocando il blocco dei thread.Sets the state of the event to nonsignaled, which causes threads to block.

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

Imposta lo stato dell'evento su segnalato, per consentire a uno o più thread in attesa dell'evento di procedere.Sets the state of the event to signaled, which allows one or more threads waiting on the event to proceed.

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

Restituisce una stringa che rappresenta l'oggetto corrente.Returns a string that represents the current object.

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

Blocca il thread corrente finché l'oggetto ManualResetEventSlim corrente non viene impostato.Blocks the current thread until the current ManualResetEventSlim is set.

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

Blocca il thread corrente finché l'oggetto ManualResetEventSlim corrente non riceve un segnale, osservando un oggetto CancellationToken.Blocks the current thread until the current ManualResetEventSlim receives a signal, while observing a CancellationToken.

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

Blocca il thread corrente finché l'oggetto ManualResetEventSlim corrente non viene impostato, utilizzando un intero con segno a 32 bit per misurare l'intervallo di tempo.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)

Blocca il thread corrente finché l'oggetto ManualResetEventSlim corrente non viene impostato, utilizzando un intero con segno a 32 bit per misurare l'intervallo di tempo e al contempo osservando un oggetto 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)

Blocca il thread corrente finché l'oggetto ManualResetEventSlim corrente non viene impostato, utilizzando un oggetto TimeSpan per misurare l'intervallo di tempo.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)

Blocca il thread corrente finché l'oggetto ManualResetEventSlim corrente non viene impostato, utilizzando un oggetto TimeSpan per misurare l'intervallo di tempo e al contempo osservando un oggetto CancellationToken.Blocks the current thread until the current ManualResetEventSlim is set, using a TimeSpan to measure the time interval, while observing a CancellationToken.

Si applica a

Thread safety

Tutti i membri pubblici e protetti della ManualResetEventSlim sono thread-safe e possono essere usati contemporaneamente da più thread, ad eccezione di Dispose, che deve essere utilizzato quando tutte le altre operazioni sul ManualResetEventSlim completato e reimposta, quali dovrebbe essere usato solo quando nessun altro thread sta accedendo all'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.

Vedi anche