ManualResetEvent Klasse

Referenz

Definition

Namespace:: System.Threading

Assembly:: System.Threading.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Stellt ein Threadsynchronisierungsereignis dar, das bei Signalisierung manuell zurückgesetzt werden muss. Diese Klasse kann nicht vererbt werden.

public ref class ManualResetEvent sealed : System::Threading::EventWaitHandle

public ref class ManualResetEvent sealed : System::Threading::WaitHandle

public sealed class ManualResetEvent : System.Threading.EventWaitHandle

public sealed class ManualResetEvent : System.Threading.WaitHandle

[System.Runtime.InteropServices.ComVisible(true)]
public sealed class ManualResetEvent : System.Threading.EventWaitHandle

type ManualResetEvent = class
    inherit EventWaitHandle

type ManualResetEvent = class
    inherit WaitHandle

[<System.Runtime.InteropServices.ComVisible(true)>]
type ManualResetEvent = class
    inherit EventWaitHandle

Public NotInheritable Class ManualResetEvent
Inherits EventWaitHandle

Public NotInheritable Class ManualResetEvent
Inherits WaitHandle

Vererbung: Object

WaitHandle

EventWaitHandle
ManualResetEvent

Vererbung: Object

MarshalByRefObject

WaitHandle

EventWaitHandle
ManualResetEvent

Vererbung: Object

MarshalByRefObject

WaitHandle
ManualResetEvent

Attribute: ComVisibleAttribute

Beispiele

Im folgenden Beispiel wird veranschaulicht, wie ManualResetEvent funktioniert. Das Beispiel beginnt mit einem ManualResetEvent unsignalierten Zustand (das heißt, false wird an den Konstruktor übergeben). Im Beispiel werden drei Threads erstellt, die jeweils durch Aufrufen der ManualResetEvent WaitOne Methode blockiert werden. Wenn der Benutzer die EINGABETASTE drückt, ruft das Beispiel die Set Methode auf, die alle drei Threads veröffentlicht. Kontrastieren Sie dies mit dem Verhalten der AutoResetEvent Klasse, die Threads gleichzeitig veröffentlicht, automatisch nach jeder Version zurück.

Durch Drücken der EINGABETASTE wird erneut veranschaulicht, dass die ManualResetEvent Weiterhin im signalierten Zustand angezeigt wird, bis die Reset Methode aufgerufen wird: Das Beispiel startet zwei weitere Threads. Diese Threads blockieren nicht, wenn sie die WaitOne Methode aufrufen, sondern zum Abschluss ausführen.

Durch drücken der EINGABETASTE wird das Beispiel erneut zum Aufrufen der Reset Methode und zum Starten eines weiteren Threads verursacht, der beim Aufrufen WaitOneblockiert wird. Drücken Sie die EINGABETASTE ein letztes Set Mal, wenn Aufrufe zum Freigeben des letzten Threads aufgerufen werden, und das Programm endet.

using namespace System;
using namespace System::Threading;

ref class Example
{
private:
    // mre is used to block and release threads manually. It is
    // created in the unsignaled state.
    static ManualResetEvent^ mre = gcnew ManualResetEvent(false);

    static void ThreadProc()
    {
        String^ name = Thread::CurrentThread->Name;

        Console::WriteLine(name + " starts and calls mre->WaitOne()");

        mre->WaitOne();

        Console::WriteLine(name + " ends.");
    }

public:
    static void Demo()
    {
        Console::WriteLine("\nStart 3 named threads that block on a ManualResetEvent:\n");

        for(int i = 0; i <=2 ; i++)
        {
            Thread^ t = gcnew Thread(gcnew ThreadStart(ThreadProc));
            t->Name = "Thread_" + i;
            t->Start();
        }

        Thread::Sleep(500);
        Console::WriteLine("\nWhen all three threads have started, press Enter to call Set()" +
                           "\nto release all the threads.\n");
        Console::ReadLine();

        mre->Set();

        Thread::Sleep(500);
        Console::WriteLine("\nWhen a ManualResetEvent is signaled, threads that call WaitOne()" +
                           "\ndo not block. Press Enter to show this.\n");
        Console::ReadLine();

        for(int i = 3; i <= 4; i++)
        {
            Thread^ t = gcnew Thread(gcnew ThreadStart(ThreadProc));
            t->Name = "Thread_" + i;
            t->Start();
        }

        Thread::Sleep(500);
        Console::WriteLine("\nPress Enter to call Reset(), so that threads once again block" +
                           "\nwhen they call WaitOne().\n");
        Console::ReadLine();

        mre->Reset();

        // Start a thread that waits on the ManualResetEvent.
        Thread^ t5 = gcnew Thread(gcnew ThreadStart(ThreadProc));
        t5->Name = "Thread_5";
        t5->Start();

        Thread::Sleep(500);
        Console::WriteLine("\nPress Enter to call Set() and conclude the demo.");
        Console::ReadLine();

        mre->Set();

        // If you run this example in Visual Studio, uncomment the following line:
        //Console::ReadLine();
    }
};

int main()
{
   Example::Demo();
}

/* This example produces output similar to the following:

Start 3 named threads that block on a ManualResetEvent:

Thread_0 starts and calls mre->WaitOne()
Thread_1 starts and calls mre->WaitOne()
Thread_2 starts and calls mre->WaitOne()

When all three threads have started, press Enter to call Set()
to release all the threads.


Thread_2 ends.
Thread_1 ends.
Thread_0 ends.

When a ManualResetEvent is signaled, threads that call WaitOne()
do not block. Press Enter to show this.


Thread_3 starts and calls mre->WaitOne()
Thread_3 ends.
Thread_4 starts and calls mre->WaitOne()
Thread_4 ends.

Press Enter to call Reset(), so that threads once again block
when they call WaitOne().


Thread_5 starts and calls mre->WaitOne()

Press Enter to call Set() and conclude the demo.

Thread_5 ends.
 */

using System;
using System.Threading;

public class Example
{
    // mre is used to block and release threads manually. It is
    // created in the unsignaled state.
    private static ManualResetEvent mre = new ManualResetEvent(false);

    static void Main()
    {
        Console.WriteLine("\nStart 3 named threads that block on a ManualResetEvent:\n");

        for(int i = 0; i <= 2; i++)
        {
            Thread t = new Thread(ThreadProc);
            t.Name = "Thread_" + i;
            t.Start();
        }

        Thread.Sleep(500);
        Console.WriteLine("\nWhen all three threads have started, press Enter to call Set()" +
                          "\nto release all the threads.\n");
        Console.ReadLine();

        mre.Set();

        Thread.Sleep(500);
        Console.WriteLine("\nWhen a ManualResetEvent is signaled, threads that call WaitOne()" +
                          "\ndo not block. Press Enter to show this.\n");
        Console.ReadLine();

        for(int i = 3; i <= 4; i++)
        {
            Thread t = new Thread(ThreadProc);
            t.Name = "Thread_" + i;
            t.Start();
        }

        Thread.Sleep(500);
        Console.WriteLine("\nPress Enter to call Reset(), so that threads once again block" +
                          "\nwhen they call WaitOne().\n");
        Console.ReadLine();

        mre.Reset();

        // Start a thread that waits on the ManualResetEvent.
        Thread t5 = new Thread(ThreadProc);
        t5.Name = "Thread_5";
        t5.Start();

        Thread.Sleep(500);
        Console.WriteLine("\nPress Enter to call Set() and conclude the demo.");
        Console.ReadLine();

        mre.Set();

        // If you run this example in Visual Studio, uncomment the following line:
        //Console.ReadLine();
    }

    private static void ThreadProc()
    {
        string name = Thread.CurrentThread.Name;

        Console.WriteLine(name + " starts and calls mre.WaitOne()");

        mre.WaitOne();

        Console.WriteLine(name + " ends.");
    }
}

/* This example produces output similar to the following:

Start 3 named threads that block on a ManualResetEvent:

Thread_0 starts and calls mre.WaitOne()
Thread_1 starts and calls mre.WaitOne()
Thread_2 starts and calls mre.WaitOne()

When all three threads have started, press Enter to call Set()
to release all the threads.


Thread_2 ends.
Thread_0 ends.
Thread_1 ends.

When a ManualResetEvent is signaled, threads that call WaitOne()
do not block. Press Enter to show this.


Thread_3 starts and calls mre.WaitOne()
Thread_3 ends.
Thread_4 starts and calls mre.WaitOne()
Thread_4 ends.

Press Enter to call Reset(), so that threads once again block
when they call WaitOne().


Thread_5 starts and calls mre.WaitOne()

Press Enter to call Set() and conclude the demo.

Thread_5 ends.
 */

Imports System.Threading

Public Class Example

    ' mre is used to block and release threads manually. It is
    ' created in the unsignaled state.
    Private Shared mre As New ManualResetEvent(False)

    <MTAThreadAttribute> _
    Shared Sub Main()

        Console.WriteLine(vbLf & _
            "Start 3 named threads that block on a ManualResetEvent:" & vbLf)

        For i As Integer = 0 To 2
            Dim t As New Thread(AddressOf ThreadProc)
            t.Name = "Thread_" & i
            t.Start()
        Next i

        Thread.Sleep(500)
        Console.WriteLine(vbLf & _
            "When all three threads have started, press Enter to call Set()" & vbLf & _
            "to release all the threads." & vbLf)
        Console.ReadLine()

        mre.Set()

        Thread.Sleep(500)
        Console.WriteLine(vbLf & _
            "When a ManualResetEvent is signaled, threads that call WaitOne()" & vbLf & _
            "do not block. Press Enter to show this." & vbLf)
        Console.ReadLine()

        For i As Integer = 3 To 4
            Dim t As New Thread(AddressOf ThreadProc)
            t.Name = "Thread_" & i
            t.Start()
        Next i

        Thread.Sleep(500)
        Console.WriteLine(vbLf & _
            "Press Enter to call Reset(), so that threads once again block" & vbLf & _
            "when they call WaitOne()." & vbLf)
        Console.ReadLine()

        mre.Reset()

        ' Start a thread that waits on the ManualResetEvent.
        Dim t5 As New Thread(AddressOf ThreadProc)
        t5.Name = "Thread_5"
        t5.Start()

        Thread.Sleep(500)
        Console.WriteLine(vbLf & "Press Enter to call Set() and conclude the demo.")
        Console.ReadLine()

        mre.Set()

        ' If you run this example in Visual Studio, uncomment the following line:
        'Console.ReadLine()

    End Sub


    Private Shared Sub ThreadProc()

        Dim name As String = Thread.CurrentThread.Name

        Console.WriteLine(name & " starts and calls mre.WaitOne()")

        mre.WaitOne()

        Console.WriteLine(name & " ends.")

    End Sub

End Class

' This example produces output similar to the following:
'
'Start 3 named threads that block on a ManualResetEvent:
'
'Thread_0 starts and calls mre.WaitOne()
'Thread_1 starts and calls mre.WaitOne()
'Thread_2 starts and calls mre.WaitOne()
'
'When all three threads have started, press Enter to call Set()
'to release all the threads.
'
'
'Thread_2 ends.
'Thread_0 ends.
'Thread_1 ends.
'
'When a ManualResetEvent is signaled, threads that call WaitOne()
'do not block. Press Enter to show this.
'
'
'Thread_3 starts and calls mre.WaitOne()
'Thread_3 ends.
'Thread_4 starts and calls mre.WaitOne()
'Thread_4 ends.
'
'Press Enter to call Reset(), so that threads once again block
'when they call WaitOne().
'
'
'Thread_5 starts and calls mre.WaitOne()
'
'Press Enter to call Set() and conclude the demo.
'
'Thread_5 ends.

Hinweise

Sie verwenden ManualResetEvent, und AutoResetEvent EventWaitHandle für Threadinteraktionen (oder Threadsignaling). Weitere Informationen finden Sie im Abschnitt " Threadinteraktion" oder "Signaling " des Artikels " Übersicht über Synchronisierungsgrundtypen ".

Wenn ein Thread eine Aktivität beginnt, die abgeschlossen werden muss, bevor andere Threads fortgesetzt werden, ruft es ManualResetEvent.Reset auf, um den nicht signalierten Zustand zu platzieren ManualResetEvent . Dieser Thread kann als Steuerung des ManualResetEventThreads gedacht werden. Threads, die ManualResetEvent.WaitOne block aufrufen, warten auf das Signal. Wenn der Steuerelementthread die Aktivität abgeschlossen hat, ruft er ManualResetEvent.Set auf, um zu signalisieren, dass die wartenden Threads fortfahren können. Alle wartenden Threads werden veröffentlicht.

Sobald es signalisiert wurde, bleibt es signalisiert, bis er manuell zurückgesetzt wird, ManualResetEvent indem die Methode aufgerufen Reset() wird. Das heißt, Anrufe, die sofort zurückgegeben werden WaitOne sollen.

Sie können den anfänglichen Zustand eines ManualResetEvent Typs steuern, indem Sie einen booleschen Wert an den Konstruktor übergeben: true wenn der anfängliche Zustand signalisiert ist und false andernfalls.

ManualResetEvent kann auch mit den static WaitAll Methoden und WaitAny Methoden verwendet werden.

Beginnend mit der .NET Framework Version 2.0 wird ManualResetEvent von der EventWaitHandle Klasse abgeleitet. Eine ManualResetEvent Funktion entspricht einem EventWaitHandle erstellten mit EventResetMode.ManualReset.

Hinweis

ManualResetEvent Im Gegensatz zur Klasse bietet die EventWaitHandle Klasse Zugriff auf benannte Systemsynchronisierungsereignisse.

Beginnend mit der .NET Framework Version 4.0 ist die System.Threading.ManualResetEventSlim Klasse eine leichte Alternative zu ManualResetEvent.

Konstruktoren

ManualResetEvent(Boolean)

Initialisiert eine neue Instanz der ManualResetEvent-Klasse mit einem booleschen Wert, der angibt, ob der anfängliche Zustand auf signalisiert festgelegt werden soll.

Felder

WaitTimeout

Gibt an, dass ein Timeout für einen WaitAny(WaitHandle[], Int32, Boolean)-Vorgang überschritten wurde, bevor ein Signal an eines der WaitHandles gesendet wurde. Dieses Feld ist konstant.

(Geerbt von WaitHandle)

Eigenschaften

Handle	Veraltet. Veraltet. Ruft das systemeigene Betriebssystemhandle auf oder legt dieses fest. (Geerbt von WaitHandle)
SafeWaitHandle	Ruft das systemeigene Betriebssystemhandle auf oder legt dieses fest. (Geerbt von WaitHandle)

Methoden

Close()	Gibt alle von der aktuellen WaitHandle-Klasse reservierten Ressourcen frei. (Geerbt von WaitHandle)
CreateObjRef(Type)	Erstellt ein Objekt mit allen relevanten Informationen, die zum Generieren eines Proxys für die Kommunikation mit einem Remoteobjekt erforderlich sind. (Geerbt von MarshalByRefObject)
Dispose()	Gibt alle von der aktuellen Instanz der WaitHandle-Klasse verwendeten Ressourcen frei. (Geerbt von WaitHandle)
Dispose(Boolean)	Gibt beim Überschreiben in einer abgeleiteten Klasse die von WaitHandle verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei. (Geerbt von WaitHandle)
Equals(Object)	Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist. (Geerbt von Object)
GetAccessControl()	Ruft ein EventWaitHandleSecurity-Objekt ab, das die Zugriffssteuerungssicherheit für das benannte Systemereignis darstellt, das durch das aktuelle EventWaitHandle-Objekt dargestellt wird. (Geerbt von EventWaitHandle)
GetHashCode()	Fungiert als Standardhashfunktion. (Geerbt von Object)
GetLifetimeService()	Veraltet. Ruft das aktuelle Lebensdauerdienstobjekt ab, das die Lebensdauerrichtlinien für diese Instanz steuert. (Geerbt von MarshalByRefObject)
GetType()	Ruft den Type der aktuellen Instanz ab. (Geerbt von Object)
InitializeLifetimeService()	Veraltet. Ruft ein Lebensdauerdienstobjekt zur Steuerung der Lebensdauerrichtlinie für diese Instanz ab. (Geerbt von MarshalByRefObject)
MemberwiseClone()	Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object)
MemberwiseClone(Boolean)	Erstellt eine flache Kopie des aktuellen MarshalByRefObject-Objekts. (Geerbt von MarshalByRefObject)
Reset()	Legt den Zustand des Ereignisses auf „nicht signalisiert“ fest, sodass Threads blockiert werden.
Reset()	Legt den Zustand des Ereignisses auf nicht signalisiert fest, sodass Threads blockiert werden. (Geerbt von EventWaitHandle)
Set()	Legt den Zustand des Ereignisses auf signalisiert fest und ermöglicht so einem oder mehreren wartenden Threads fortzufahren.
Set()	Legt den Zustand des Ereignisses auf signalisiert fest und ermöglicht so einem oder mehreren wartenden Threads fortzufahren. (Geerbt von EventWaitHandle)
SetAccessControl(EventWaitHandleSecurity)	Legt die Zugriffssteuerungssicherheit für ein benanntes Systemereignis fest. (Geerbt von EventWaitHandle)
ToString()	Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object)
WaitOne()	Blockiert den aktuellen Thread, bis das aktuelle WaitHandle ein Signal empfängt. (Geerbt von WaitHandle)
WaitOne(Int32)	Blockiert den aktuellen Thread, bis das aktuelle WaitHandle ein Signal empfängt, wobei eine 32-Bit-Ganzzahl mit Vorzeichen zum Angeben des Zeitintervalls in Millisekunden verwendet wird. (Geerbt von WaitHandle)
WaitOne(Int32, Boolean)	Blockiert den aktuellen Thread, bis das aktuelle WaitHandle ein Signal empfängt, wobei eine 32-Bit-Ganzzahl mit Vorzeichen zum Angeben des Zeitintervalls verwendet und angegeben wird, ob die Synchronisierungsdomäne vor dem Wartevorgang verlassen werden soll. (Geerbt von WaitHandle)
WaitOne(TimeSpan)	Blockiert den aktuellen Thread, bis die aktuelle Instanz ein Signal empfängt, wobei eine TimeSpan zum Angeben des Zeitintervalls verwendet wird. (Geerbt von WaitHandle)
WaitOne(TimeSpan, Boolean)	Blockiert den aktuellen Thread, bis die aktuelle Instanz ein Signal empfängt, wobei eine TimeSpan zum Angeben des Zeitintervalls verwendet und angegeben wird, ob die Synchronisierungsdomäne vor dem Wartevorgang verlassen werden soll. (Geerbt von WaitHandle)

Explizite Schnittstellenimplementierungen

IDisposable.Dispose()

Diese API unterstützt die Produktinfrastruktur und ist nicht für die direkte Verwendung aus Ihrem Code gedacht.

Gibt alle vom WaitHandle verwendeten Ressourcen frei.