Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch

EventWaitHandle-Klasse

 

Stellt ein Threadsynchronisierungsereignis dar.

Namespace:   System.Threading
Assembly:  mscorlib (in mscorlib.dll)

System.Object
  System.MarshalByRefObject
    System.Threading.WaitHandle
      System.Threading.EventWaitHandle
        System.Threading.AutoResetEvent
        System.Threading.ManualResetEvent

[ComVisibleAttribute(true)]
[HostProtectionAttribute(SecurityAction.LinkDemand, Synchronization = true, 
	ExternalThreading = true)]
public class EventWaitHandle : WaitHandle

NameBeschreibung
System_CAPS_pubmethodEventWaitHandle(Boolean, EventResetMode)

Initialisiert eine neue Instanz der EventWaitHandle -Klasse und gibt an, ob zunächst das Wait-Handle signalisiert wird, und ob es automatisch oder manuell zurückgesetzt.

System_CAPS_pubmethodEventWaitHandle(Boolean, EventResetMode, String)

Initialisiert eine neue Instanz der der EventWaitHandle Klasse, die angibt, ob das Wait-Handle anfänglich signalisiert wird, wenn als Ergebnis dieses Aufrufs erstellt haben und ob es automatisch oder manuell zurückgesetzt und der Name des Systems die Synchronisation.

System_CAPS_pubmethodEventWaitHandle(Boolean, EventResetMode, String, Boolean)

Initialisiert eine neue Instanz der EventWaitHandle-Klasse, die Folgendes angibt: ob das Wait-Handle anfänglich signalisiert wird, wenn es als Ergebnis dieses Aufrufs erstellt wird; ob es automatisch oder manuell zurückgesetzt wird; den Namen eines Systemsynchronisierungsereignisses und eine boolesche Variable, deren Wert nach dem Aufruf angibt, ob das benannte Systemereignis erstellt wurde.

System_CAPS_pubmethodEventWaitHandle(Boolean, EventResetMode, String, Boolean, EventWaitHandleSecurity)

Initialisiert eine neue Instanz der EventWaitHandle-Klasse, die Folgendes angibt: ob das Wait-Handle anfänglich signalisiert wird, wenn es als Ergebnis dieses Aufrufs erstellt wird; ob es automatisch oder manuell zurückgesetzt wird; den Namen eines Systemsynchronisierungsereignisses, eine boolesche Variable, deren Wert nach dem Aufruf angibt, ob das benannte Systemereignis erstellt wurde, und die Zugriffssteuerungssicherheit, die auf das benannte Ereignis angewandt werden soll, falls es erstellt wird.

NameBeschreibung
System_CAPS_pubpropertyHandle

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

System_CAPS_pubpropertySafeWaitHandle

Ruft das systemeigene Betriebssystemhandle auf oder legt dieses fest.(Geerbt von „WaitHandle“.)

NameBeschreibung
System_CAPS_pubmethodClose()

Gibt alle von der aktuellen WaitHandle-Klasse reservierten Ressourcen frei.(Geerbt von „WaitHandle“.)

System_CAPS_pubmethodCreateObjRef(Type)

Erstellt ein Objekt, das alle relevanten Informationen, die zum Generieren eines Proxys für die Kommunikation mit einem Remoteobjekt verwendet die enthält.(Geerbt von „MarshalByRefObject“.)

System_CAPS_pubmethodDispose()

Gibt alle von der aktuellen Instanz der WaitHandle-Klasse verwendeten Ressourcen frei.(Geerbt von „WaitHandle“.)

System_CAPS_protmethodDispose(Boolean)

Gibt beim Überschreiben in einer abgeleiteten Klasse die von WaitHandle verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei.(Geerbt von „WaitHandle“.)

System_CAPS_pubmethodEquals(Object)

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist.(Geerbt von „Object“.)

System_CAPS_protmethodFinalize()

Gibt einem Objekt Gelegenheit, Ressourcen freizugeben und andere Bereinigungen durchzuführen, bevor es von der Garbage Collection freigegeben wird. (Geerbt von „Object“.)

System_CAPS_pubmethodGetAccessControl()

Ruft ein EventWaitHandleSecurity-Objekt ab, das die Zugriffssteuerungssicherheit für das benannte Systemereignis darstellt, das durch das aktuelle EventWaitHandle-Objekt dargestellt wird.

System_CAPS_pubmethodGetHashCode()

Fungiert als die Standardhashfunktion.(Geerbt von „Object“.)

System_CAPS_pubmethodGetLifetimeService()

Ruft das Dienstobjekt für aktuellen Lebensdauer, das steuert, die lebensdauerrichtlinie für diese Instanz ab.(Geerbt von „MarshalByRefObject“.)

System_CAPS_pubmethodGetType()

Ruft den Type der aktuellen Instanz ab.(Geerbt von „Object“.)

System_CAPS_pubmethodInitializeLifetimeService()

Ruft ein Lebensdauerdienstobjekt zur Steuerung der Lebensdauerrichtlinie für diese Instanz ab.(Geerbt von „MarshalByRefObject“.)

System_CAPS_protmethodMemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.(Geerbt von „Object“.)

System_CAPS_protmethodMemberwiseClone(Boolean)

Erstellt eine flache Kopie des aktuellen MarshalByRefObject Objekt.(Geerbt von „MarshalByRefObject“.)

System_CAPS_pubmethodSystem_CAPS_staticOpenExisting(String)

Angegebene benanntes Synchronisierungsereignis öffnet, wenn es bereits vorhanden ist.

System_CAPS_pubmethodSystem_CAPS_staticOpenExisting(String, EventWaitHandleRights)

Öffnet das angegebene Synchronisierungsereignis, wenn sie bereits mit dem gewünschten Sicherheitszugriff vorhanden ist, mit der Bezeichnung.

System_CAPS_pubmethodReset()

Legt den Zustand des Ereignisses auf „nicht signalisiert“ fest, sodass Threads blockiert werden.

System_CAPS_pubmethodSet()

Legt den Zustand des Ereignisses auf „signalisiert“ fest und ermöglicht so einem oder mehreren wartenden Threads das Fortfahren.

System_CAPS_pubmethodSetAccessControl(EventWaitHandleSecurity)

Legt die Zugriffssteuerungssicherheit für ein benanntes Systemereignis fest.

System_CAPS_pubmethodToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.(Geerbt von „Object“.)

System_CAPS_pubmethodSystem_CAPS_staticTryOpenExisting(String, EventWaitHandle)

Öffnet das angegebene benannte Synchronisierungsereignis, wenn es bereits vorhanden ist, und gibt einen Wert zurück, der angibt, ob der Vorgang erfolgreich war.

System_CAPS_pubmethodSystem_CAPS_staticTryOpenExisting(String, EventWaitHandleRights, EventWaitHandle)

Öffnet das angegebene benannte Synchronisierungsereignis, wenn es bereits mit dem gewünschten Sicherheitszugriff vorhanden ist, und gibt einen Wert zurück, der angibt, ob der Vorgang erfolgreich war.

System_CAPS_pubmethodWaitOne()

Blockiert den aktuellen Thread, bis das aktuelle WaitHandle ein Signal empfängt.(Geerbt von „WaitHandle“.)

System_CAPS_pubmethodWaitOne(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“.)

System_CAPS_pubmethodWaitOne(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“.)

System_CAPS_pubmethodWaitOne(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“.)

System_CAPS_pubmethodWaitOne(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“.)

NameBeschreibung
System_CAPS_pubmethodGetSafeWaitHandle()

Ruft das sichere Handle für ein systemeigenes Betriebssystem-Wait-Handle ab.(Definiert durch WaitHandleExtensions.)

System_CAPS_pubmethodSetSafeWaitHandle(SafeWaitHandle)

Stellt ein sicheres Handle für ein systemeigenes Betriebssystem-Wait-Handle ein.(Definiert durch WaitHandleExtensions.)

The T:System.Threading.EventWaitHandle class allows threads to communicate with each other by signaling. Typically, one or more threads block on an T:System.Threading.EventWaitHandle until an unblocked thread calls the M:System.Threading.EventWaitHandle.Set method, releasing one or more of the blocked threads. A thread can signal an T:System.Threading.EventWaitHandle and then block on it, by calling the static (Shared in Visual Basic) Overload:System.Threading.WaitHandle.SignalAndWait method.

System_CAPS_noteHinweis

The T:System.Threading.EventWaitHandle class provides access to named system synchronization events.

The behavior of an T:System.Threading.EventWaitHandle that has been signaled depends on its reset mode. An T:System.Threading.EventWaitHandle created with the F:System.Threading.EventResetMode.AutoReset flag resets automatically when signaled, after releasing a single waiting thread. An T:System.Threading.EventWaitHandle created with the F:System.Threading.EventResetMode.ManualReset flag remains signaled until its M:System.Threading.EventWaitHandle.Reset method is called.

Automatic reset events provide exclusive access to a resource. If an automatic reset event is signaled when no threads are waiting, it remains signaled until a thread attempts to wait on it. The event releases the thread and immediately resets, blocking subsequent threads.

Manual reset events are like gates. When the event is not signaled, threads that wait on it will block. When the event is signaled, all waiting threads are released, and the event remains signaled (that is, subsequent waits do not block) until its M:System.Threading.EventWaitHandle.Reset method is called. Manual reset events are useful when one thread must complete an activity before other threads can proceed.

EventWaitHandle objects can be used with the static(Shared in Visual Basic) WaitHandle.WaitAll and WaitHandle.WaitAny methods.

For more information about thread synchronization mechanisms, see EventWaitHandle, AutoResetEvent, and ManualResetEvent.

The following code example uses the M:System.Threading.WaitHandle.SignalAndWait(System.Threading.WaitHandle,System.Threading.WaitHandle) method overload to allow the main thread to signal a blocked thread and then wait until the thread finishes a task.

The example starts five threads and allows them to block on an T:System.Threading.EventWaitHandle created with the F:System.Threading.EventResetMode.AutoReset flag, then releases one thread each time the user presses the ENTER key. The example then queues another five threads and releases them all using an T:System.Threading.EventWaitHandle created with the F:System.Threading.EventResetMode.ManualReset flag.

using System;
using System.Threading;

public class Example
{
    // The EventWaitHandle used to demonstrate the difference
    // between AutoReset and ManualReset synchronization events.
    //
    private static EventWaitHandle ewh;

    // A counter to make sure all threads are started and
    // blocked before any are released. A Long is used to show
    // the use of the 64-bit Interlocked methods.
    //
    private static long threadCount = 0;

    // An AutoReset event that allows the main thread to block
    // until an exiting thread has decremented the count.
    //
    private static EventWaitHandle clearCount = 
        new EventWaitHandle(false, EventResetMode.AutoReset);

    [MTAThread]
    public static void Main()
    {
        // Create an AutoReset EventWaitHandle.
        //
        ewh = new EventWaitHandle(false, EventResetMode.AutoReset);

        // Create and start five numbered threads. Use the
        // ParameterizedThreadStart delegate, so the thread
        // number can be passed as an argument to the Start 
        // method.
        for (int i = 0; i <= 4; i++)
        {
            Thread t = new Thread(
                new ParameterizedThreadStart(ThreadProc)
            );
            t.Start(i);
        }

        // Wait until all the threads have started and blocked.
        // When multiple threads use a 64-bit value on a 32-bit
        // system, you must access the value through the
        // Interlocked class to guarantee thread safety.
        //
        while (Interlocked.Read(ref threadCount) < 5)
        {
            Thread.Sleep(500);
        }

        // Release one thread each time the user presses ENTER,
        // until all threads have been released.
        //
        while (Interlocked.Read(ref threadCount) > 0)
        {
            Console.WriteLine("Press ENTER to release a waiting thread.");
            Console.ReadLine();

            // SignalAndWait signals the EventWaitHandle, which
            // releases exactly one thread before resetting, 
            // because it was created with AutoReset mode. 
            // SignalAndWait then blocks on clearCount, to 
            // allow the signaled thread to decrement the count
            // before looping again.
            //
            WaitHandle.SignalAndWait(ewh, clearCount);
        }
        Console.WriteLine();

        // Create a ManualReset EventWaitHandle.
        //
        ewh = new EventWaitHandle(false, EventResetMode.ManualReset);

        // Create and start five more numbered threads.
        //
        for(int i=0; i<=4; i++)
        {
            Thread t = new Thread(
                new ParameterizedThreadStart(ThreadProc)
            );
            t.Start(i);
        }

        // Wait until all the threads have started and blocked.
        //
        while (Interlocked.Read(ref threadCount) < 5)
        {
            Thread.Sleep(500);
        }

        // Because the EventWaitHandle was created with
        // ManualReset mode, signaling it releases all the
        // waiting threads.
        //
        Console.WriteLine("Press ENTER to release the waiting threads.");
        Console.ReadLine();
        ewh.Set();

    }

    public static void ThreadProc(object data)
    {
        int index = (int) data;

        Console.WriteLine("Thread {0} blocks.", data);
        // Increment the count of blocked threads.
        Interlocked.Increment(ref threadCount);

        // Wait on the EventWaitHandle.
        ewh.WaitOne();

        Console.WriteLine("Thread {0} exits.", data);
        // Decrement the count of blocked threads.
        Interlocked.Decrement(ref threadCount);

        // After signaling ewh, the main thread blocks on
        // clearCount until the signaled thread has 
        // decremented the count. Signal it now.
        //
        clearCount.Set();
    }
}

Universelle Windows-Plattform
Verfügbar seit 8
.NET Framework
Verfügbar seit 2.0
Portierbare Klassenbibliothek
Unterstützt in: portierbare .NET-Plattformen
Silverlight
Verfügbar seit 2.0
Windows Phone Silverlight
Verfügbar seit 7.0
Windows Phone
Verfügbar seit 8.1

This type is thread safe.

Zurück zum Anfang
Anzeigen: