ManualResetEventSlim ManualResetEventSlim ManualResetEventSlim ManualResetEventSlim Class

Definition

Stellt ein Threadsynchronisierungsereignis dar, das bei Signalisierung manuell zurückgesetzt werden muss.Represents a thread synchronization event that, when signaled, must be reset manually. Diese Klasse ist eine einfache Alternative zu 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
Vererbung
ManualResetEventSlimManualResetEventSlimManualResetEventSlimManualResetEventSlim
Attribute
Implementiert

Beispiele

Im folgenden Beispiel wird gezeigt, wie Sie ManualResetEventSlimverwenden.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

Hinweise

Sie können diese Klasse verwenden, um die Leistung ManualResetEvent zu verbessern, als zu erwarten ist, dass Wartezeiten sehr kurz sind und wenn das Ereignis keine Prozess Grenze überschreitet.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 verwendet während des Wartens auf die Signalisierung des Ereignisses für kurze Zeit ausgelastete Spinvorgänge.ManualResetEventSlim uses busy spinning for a short time while it waits for the event to become signaled. Bei kurzen Wartezeiten können Spinvorgänge sehr viel weniger ressourcenintensiv sein als das Warten mit Wait-Handles.When wait times are short, spinning can be much less expensive than waiting by using wait handles. Wenn das Ereignis jedoch nicht innerhalb eines bestimmten Zeitraums signalisiert wird, greift ManualResetEventSlim auf einen normalen Wartevorgang mit Ereignishandle zurück.However, if the event does not become signaled within a certain period of time, ManualResetEventSlim resorts to a regular event handle wait.

Konstruktoren

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

Initialisiert eine neue Instanz der ManualResetEventSlim-Klasse mit dem Anfangszustand "nicht signalisiert".Initializes a new instance of the ManualResetEventSlim class with an initial state of nonsignaled.

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

Initialisiert eine neue Instanz der ManualResetEventSlim-Klasse mit einem booleschen Wert, der angibt, ob der anfängliche Zustand auf signalisiert festgelegt werden soll.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)

Initialisiert eine neue Instanz der ManualResetEventSlim-Klasse mit einem booleschen Wert, der angibt, ob der Anfangszustand auf „signalisiert“ festgelegt werden soll, und einer festgelegten Spin-Anzahl.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.

Eigenschaften

IsSet IsSet IsSet IsSet

Ruft einen Wert ab, der angibt, ob das Ereignis festgelegt wurde.Gets whether the event is set.

SpinCount SpinCount SpinCount SpinCount

Ruft die Anzahl von Spin-Wartevorgängen an, die vor dem Fallback auf einen kernelbasierten Wartevorgang stattfinden.Gets the number of spin waits that will occur before falling back to a kernel-based wait operation.

WaitHandle WaitHandle WaitHandle WaitHandle

Ruft das zugrunde liegende WaitHandle-Objekt für dieses ManualResetEventSlim ab.Gets the underlying WaitHandle object for this ManualResetEventSlim.

Methoden

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

Gibt alle von der aktuellen Instanz der ManualResetEventSlim-Klasse verwendeten Ressourcen frei.Releases all resources used by the current instance of the ManualResetEventSlim class.

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

Gibt die von ManualResetEventSlim verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei.Releases the unmanaged resources used by the ManualResetEventSlim, and optionally releases the managed resources.

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

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist.Determines whether the specified object is equal to the current object.

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

Fungiert als Standardhashfunktion.Serves as the default hash function.

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

Ruft den Type der aktuellen Instanz ab.Gets the Type of the current instance.

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

Erstellt eine flache Kopie des aktuellen Object.Creates a shallow copy of the current Object.

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

Legt den Zustand des Ereignisses auf „nicht signalisiert“ fest, sodass Threads blockiert werden.Sets the state of the event to nonsignaled, which causes threads to block.

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

Legt den Zustand des Ereignisses auf „signalisiert“ fest und ermöglicht so die weitere Ausführung eines oder mehrerer wartender Threads.Sets the state of the event to signaled, which allows one or more threads waiting on the event to proceed.

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

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.Returns a string that represents the current object.

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

Blockiert den aktuellen Thread, bis das aktuelle ManualResetEventSlim festgelegt wird.Blocks the current thread until the current ManualResetEventSlim is set.

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

Blockiert den aktuellen Thread, bis das aktuelle ManualResetEventSlim ein Signal empfängt, wobei ein CancellationToken überwacht wird.Blocks the current thread until the current ManualResetEventSlim receives a signal, while observing a CancellationToken.

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

Blockiert den aktuellen Thread, bis das aktuelle ManualResetEventSlim festgelegt wird, wobei eine 32-Bit-Ganzzahl mit Vorzeichen zum Messen des Zeitintervalls verwendet wird.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)

Blockiert den aktuellen Thread, bis das aktuelle ManualResetEventSlim festgelegt wird, wobei eine 32-Bit-Ganzzahl mit Vorzeichen zum Messen des Zeitintervalls verwendet und ein CancellationToken überwacht wird.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)

Blockiert den aktuellen Thread, bis das aktuelle ManualResetEventSlim festgelegt wird, wobei ein TimeSpan zum Messen des Zeitintervalls verwendet wird.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)

Blockiert den aktuellen Thread, bis das aktuelle ManualResetEventSlim festgelegt wird, wobei ein TimeSpan zum Messen des Zeitintervalls verwendet und ein CancellationToken überwacht wird.Blocks the current thread until the current ManualResetEventSlim is set, using a TimeSpan to measure the time interval, while observing a CancellationToken.

Gilt für:

Threadsicherheit

Alle öffentlichen und geschützten Member von ManualResetEventSlim sind Thread sicher und können gleichzeitig von mehreren Threads verwendet werden, mit Ausnahme von "verwerfen", die nur verwendet werden muss, wenn alle anderen Vorgänge ManualResetEventSlim auf dem abgeschlossen sind, und zurückgesetzt wird, was wird nur verwendet, wenn keine anderen Threads auf das Ereignis zugreifen.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.

Siehe auch