ManualResetEventSlim Osztály

Definíció

Névtér:

System.Threading

Szerelvények:

netstandard.dll, System.Threading.dll

Forrás:

ManualResetEventSlim.cs

Olyan szálszinkronizálási eseményt jelöl, amelyet a jelzéskor manuálisan kell alaphelyzetbe állítani. Ez az osztály egy egyszerű alternatíva a ManualResetEvent.

public ref class ManualResetEventSlim : IDisposable

public class ManualResetEventSlim : IDisposable

type ManualResetEventSlim = class
    interface IDisposable

Public Class ManualResetEventSlim
Implements IDisposable

Öröklődés

Object

ManualResetEventSlim

Megvalósítás

IDisposable

Példák

Az alábbi példa bemutatja, hogyan használhatja 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

Megjegyzések

Ezt az osztályt a jobb teljesítmény érdekében használhatja, mint ManualResetEvent amikor a várakozási idő várhatóan nagyon rövid lesz, és ha az esemény nem lépi át a folyamathatárt. ManualResetEventSlim az elfoglalt pörgetést rövid ideig használja, amíg az esemény jelzésére vár. Ha a várakozási idő rövid, a fonás sokkal olcsóbb lehet, mint a várakozási fogópontok használatával. Ha azonban az esemény egy bizonyos időn belül nem lesz jelezve, ManualResetEventSlim rendszeres eseménykezelő várakozásra van szükség.

Note

Az .NET Core és .NET 5+ esetén az alapértelmezett pörgetési várakozási időtartam rövid: a platformtól és a processzortól függően 10 mikroszekundumos sorrendben. Ha a várakozási idő ennél sokkal hosszabb lesz, akkor is használhatja ezt az osztályt ahelyett ManualResetEvent , hogy (esetleg kevesebb vagy nincs pörgetéses várakozással konfigurálva). A teljesítménybeli előny azonban valószínűleg csak marginális.

Konstruktorok

Name	Description
ManualResetEventSlim()	Inicializálja az ManualResetEventSlim osztály új példányát, amelynek kezdeti állapota nem alá van rendelve.
ManualResetEventSlim(Boolean, Int32)	Inicializálja az ManualResetEventSlim osztály új példányát logikai értékkel, amely azt jelzi, hogy a kezdeti állapot jelzésre van-e állítva, és egy megadott pörgetési számot.
ManualResetEventSlim(Boolean)	Inicializálja az ManualResetEventSlim osztály új példányát logikai értékkel, amely jelzi, hogy a kezdeti állapot jelzésre van-e állítva.

Tulajdonságok

Name	Description
IsSet	Lekérdezi, hogy az esemény be van-e állítva.
SpinCount	Lekéri a kernelalapú várakozási műveletre való visszalépés előtt bekövetkező pörgetési várakozások számát.
WaitHandle	Lekéri a mögöttes WaitHandle objektumot ehhez ManualResetEventSlima .

Metódusok

Name	Description
Dispose()	Az osztály aktuális példánya által használt összes erőforrást felszabadítja ManualResetEventSlim .
Dispose(Boolean)	Felszabadítja a felügyelt erőforrások által ManualResetEventSlimhasznált nem felügyelt erőforrásokat, és opcionálisan felszabadítja a felügyelt erőforrásokat.
Equals(Object)	Meghatározza, hogy a megadott objektum egyenlő-e az aktuális objektummal. (Öröklődés forrása Object)
GetHashCode()	Ez az alapértelmezett kivonatoló függvény. (Öröklődés forrása Object)
GetType()	Lekéri az Type aktuális példányt. (Öröklődés forrása Object)
MemberwiseClone()	Az aktuális Objectpéldány sekély másolatát hozza létre. (Öröklődés forrása Object)
Reset()	Az esemény állapotát nem aláírtra állítja, ami miatt a szálak blokkolva lesznek.
Set()	Beállítja az esemény állapotát jelzésre, ami lehetővé teszi az eseményre várakozó egy vagy több szál folytatását.
ToString()	Az aktuális objektumot jelképező sztringet ad vissza. (Öröklődés forrása Object)
Wait()	Letiltja az aktuális szálat, amíg be nem állítja az áramot ManualResetEventSlim .
Wait(CancellationToken)	Blokkolja az aktuális szálat, amíg az áram ManualResetEventSlim nem kap jelet, miközben megfigyel egy CancellationToken.
Wait(Int32, CancellationToken)	Letiltja az aktuális szálat az aktuális ManualResetEventSlim beállításig, egy 32 bites aláírt egész számmal méri az időintervallumot, miközben megfigyel egy CancellationToken.
Wait(Int32)	Letiltja az aktuális szálat az aktuális ManualResetEventSlim beállításig egy 32 bites aláírt egész számmal az időintervallum méréséhez.
Wait(TimeSpan, CancellationToken)	Letiltja az aktuális szálat az áram ManualResetEventSlim beállításáig, TimeSpan az időintervallum mérésére, miközben megfigyel egy CancellationToken.
Wait(TimeSpan)	Letiltja az aktuális szálat az aktuális ManualResetEventSlim beállításig, az időintervallum mérésére használva TimeSpan .

Szálbiztonság

Az összes nyilvános és védett tag ManualResetEventSlim szálbiztos, és egyidejűleg több szálból is használható, kivéve az Elidegenítést, amelyet csak akkor szabad használni, ha az ManualResetEventSlim összes többi művelet befejeződött, és az Alaphelyzetbe állítást, amelyet csak akkor szabad használni, ha más szálak nem férnek hozzá az eseményhez.

Lásd még

• A szinkronizálási primitívek áttekintése