(0) exportieren Drucken
Alle erweitern
Dieser Artikel wurde maschinell übersetzt. Bewegen Sie den Mauszeiger über die Sätze im Artikel, um den Originaltext anzuzeigen. Weitere Informationen
Übersetzung
Original

EventWaitHandle-Klasse

Stellt ein Threadsynchronisierungsereignis dar.

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

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

Der EventWaitHandle-Typ macht die folgenden Member verfügbar.

  NameBeschreibung
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsEventWaitHandle(Boolean, EventResetMode)Initialisiert eine neue Instanz der EventWaitHandle-Klasse und gibt an, ob das WaitHandle anfänglich signalisiert ist und ob es automatisch oder manuell zurückgesetzt wird.
Öffentliche MethodeUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsEventWaitHandle(Boolean, EventResetMode, String)Initialisiert eine neue Instanz der EventWaitHandle-Klasse, gibt an, ob das WaitHandle anfänglich signalisiert ist, wenn es als Ergebnis dieses Aufrufs erstellt wurde, ob es automatisch oder manuell zurückgesetzt wird, und gibt den Namen eines Systemsynchronisierungsereignisses an.
Öffentliche MethodeUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsEventWaitHandle(Boolean, EventResetMode, String, Boolean)Initialisiert eine neue Instanz der EventWaitHandle-Klasse, gibt an, ob das WaitHandle anfänglich signalisiert ist, wenn es als Ergebnis dieses Aufrufs erstellt wurde, und ob es automatisch oder manuell zurückgesetzt wird, und gibt den Namen eines Systemsynchronisierungsereignisses und eine boolesche Variable an, deren Wert nach dem Aufruf angibt, ob das benannte Systemereignis erstellt wurde.
Öffentliche MethodeEventWaitHandle(Boolean, EventResetMode, String, Boolean, EventWaitHandleSecurity)Initialisiert eine neue Instanz der EventWaitHandle-Klasse, gibt an, ob das WaitHandle anfänglich signalisiert ist, wenn es als Ergebnis dieses Aufrufs erstellt wurde, und ob es automatisch oder manuell zurückgesetzt wird, und gibt den Namen eines Systemsynchronisierungsereignisses und eine boolesche Variable an, deren Wert nach dem Aufruf angibt, ob das benannte Systemereignis erstellt wurde, und die Zugriffssteuerungssicherheit, die auf das benannte Ereignis angewendet werden soll, falls es erstellt wird.
Zum Seitenanfang

  NameBeschreibung
Öffentliche EigenschaftUnterstützt von XNA FrameworkHandle Veraltet. Ruft das systemeigene Betriebssystemhandle auf oder legt dieses fest. (Von WaitHandle geerbt.)
Öffentliche EigenschaftSafeWaitHandleRuft das systemeigene Betriebssystemhandle auf oder legt dieses fest. (Von WaitHandle geerbt.)
Zum Seitenanfang

  NameBeschreibung
Öffentliche MethodeUnterstützt von XNA FrameworkCloseGibt beim Überschreiben in einer abgeleiteten Klasse alle für das aktuelle WaitHandle reservierten Ressourcen frei. (Von WaitHandle geerbt.)

In XNA Framework wird dieser Member von Close() überschrieben.
Öffentliche MethodeCreateObjRefErstellt ein Objekt mit allen relevanten Informationen, die zum Generieren eines Proxys für die Kommunikation mit einem Remoteobjekt erforderlich sind. (Von MarshalByRefObject geerbt.)
Öffentliche MethodeUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsDispose()Gibt alle von der aktuellen Instanz der WaitHandle-Klasse verwendeten Ressourcen frei. (Von WaitHandle geerbt.)
Geschützte MethodeUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsDispose(Boolean)Gibt beim Überschreiben in einer abgeleiteten Klasse die vom WaitHandle verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei. (Von WaitHandle geerbt.)
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsEquals(Object)Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist. (Von Object geerbt.)
Geschützte MethodeUnterstützt von XNA FrameworkFinalize Gibt einem Objekt Gelegenheit, Ressourcen freizugeben und andere Bereinigungen durchzuführen, bevor es von der Garbage Collection freigegeben wird. (Von Object geerbt.)

In XNA Framework wird dieser Member von Finalize() überschrieben.
Öffentliche MethodeGetAccessControlRuft ein EventWaitHandleSecurity-Objekt ab, das die Zugriffssteuerungssicherheit für das benannte Systemereignis darstellt, das durch das aktuelle EventWaitHandle-Objekt dargestellt wird.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsGetHashCodeFungiert als die Standardhashfunktion. (Von Object geerbt.)
Öffentliche MethodeGetLifetimeServiceRuft das aktuelle Lebensdauerdienstobjekt ab, das die Lebensdauerrichtlinien für diese Instanz steuert. (Von MarshalByRefObject geerbt.)
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsGetTypeRuft den Type der aktuellen Instanz ab. (Von Object geerbt.)
Öffentliche MethodeInitializeLifetimeServiceRuft ein Lebensdauerdienstobjekt ab, mit dem die Lebensdauerrichtlinien für diese Instanz gesteuert werden können. (Von MarshalByRefObject geerbt.)
Geschützte MethodeUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsMemberwiseClone()Erstellt eine flache Kopie des aktuellen Object. (Von Object geerbt.)
Geschützte MethodeMemberwiseClone(Boolean)Erstellt eine flache Kopie des aktuellen MarshalByRefObject-Objekts. (Von MarshalByRefObject geerbt.)
Öffentliche MethodeStatischer MemberUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsOpenExisting(String)Öffnet das bestimmte benannte Synchronisierungsereignis, wenn es bereits vorhanden ist.
Öffentliche MethodeStatischer MemberOpenExisting(String, EventWaitHandleRights)Öffnet das angegebene benannte Synchronisierungsereignis, wenn es bereits vorhanden ist, mit dem gewünschten Sicherheitszugriff.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsResetLegt den Zustand des Ereignisses auf nicht signalisiert fest, sodass Threads blockiert werden.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsSetLegt den Zustand des Ereignisses auf signalisiert fest und ermöglicht so einem oder mehreren wartenden Threads fortzufahren.
Öffentliche MethodeSetAccessControlLegt die Zugriffssteuerungssicherheit für ein benanntes Systemereignis fest.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsToStringGibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Von Object geerbt.)
Öffentliche MethodeStatischer MemberUnterstützt in .NET für Windows Store-AppsTryOpenExisting(String, EventWaitHandle)Öffnet das bestimmte benannte Synchronisierungsereignis, wenn es bereits vorhanden ist, und gibt einen Wert zurück, der angibt, ob der Vorgang erfolgreich war.
Öffentliche MethodeStatischer MemberTryOpenExisting(String, EventWaitHandleRights, EventWaitHandle)Öffnet das bestimmte 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.
Öffentliche MethodeUnterstützt von XNA FrameworkWaitOne()Blockiert den aktuellen Thread, bis das aktuelle WaitHandle ein Signal empfängt. (Von WaitHandle geerbt.)

In XNA Framework wird dieser Member von WaitOne() überschrieben.
Öffentliche MethodeUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsWaitOne(Int32)Blockiert den aktuellen Thread, bis das aktuelle WaitHandle ein Signal empfängt, wobei eine 32-Bit-Ganzzahl mit Vorzeichen zum Angeben des Zeitintervalls verwendet wird. (Von WaitHandle geerbt.)
Öffentliche MethodeUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsWaitOne(TimeSpan)Blockiert den aktuellen Thread, bis die aktuelle Instanz ein Signal empfängt, wobei eine TimeSpan zum Angeben des Zeitintervalls verwendet wird. (Von WaitHandle geerbt.)
Öffentliche MethodeUnterstützt von XNA FrameworkWaitOne(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. (Von WaitHandle geerbt.)

In XNA Framework wird dieser Member von WaitOne(Int32, Boolean) überschrieben.
Öffentliche MethodeWaitOne(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. (Von WaitHandle geerbt.)
Zum Seitenanfang

  NameBeschreibung
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIDisposable.DisposeInfrastruktur. Gibt sämtliche vom WaitHandle verwendeten Ressourcen frei. (Von WaitHandle geerbt.)
Zum Seitenanfang

Mithilfe der EventWaitHandle-Klasse können Threads untereinander durch Signalisieren kommunizieren. Normalerweise werden ein oder mehrere Threads an einem EventWaitHandle blockiert, bis ein nicht blockierter Thread die Set-Methode aufruft und einen oder mehrere blockierte Threads freigibt. Ein Thread kann einen EventWaitHandle signalisieren und diesen dann durch Aufrufen der staticWaitHandle.SignalAndWait-Methode (Shared in Visual Basic) blockieren.

HinweisHinweis

Die EventWaitHandle-Klasse ermöglicht den Zugriff auf benannte Systemsynchronisierungsereignisse.

Das Verhalten eines signalisierten EventWaitHandle ist abhängig von seinem Rücksetzmodus. Ein EventWaitHandle, das mit dem EventResetMode.AutoReset-Flag erstellt wurde, wird automatisch zurückgesetzt, wenn es signalisiert wird, nachdem ein einzelner wartender Thread freigegeben wurde. Ein EventWaitHandle, das mit dem EventResetMode.ManualReset-Flag erstellt wurde, bleibt signalisiert, bis seine Reset-Methode aufgerufen wird.

Automatische Rücksetzungsereignisse bieten exklusiven Zugriff auf eine Ressource. Wird ein automatisches Zurücksetzungsereignis signalisiert, und es sind keine wartenden Threads vorhanden, dann bleibt das Ereignis signalisiert, bis ein wartender Thread vorhanden ist. Das Ereignis gibt den Thread frei und setzt sofort zurück, sodass nachfolgende Threads blockiert werden.

Manuelle Rücksetzungsereignisse können mit Toren verglichen werden. Wenn das Ereignis nicht signalisiert ist, werden Threads, die darauf warten, blockiert. Wenn das Ereignis signalisiert wird, werden alle wartenden Threads freigegeben, und das Ereignis bleibt signalisiert (d. h., nachfolgende Wartevorgänge werden nicht blockiert), bis seine Reset-Methode aufgerufen wird. Manuelle Rücksetzungsereignisse sind nützlich, wenn ein Thread eine Aktivität abschließen muss, bevor andere Threads fortfahren können.

EventWaitHandle -Objekte können mit der static (Shared in Visual Basic) WaitHandle.WaitAll-Methode und der WaitHandle.WaitAny-Methode verwendet werden.

Weitere Informationen zu Threadsynchronisierungsmechanismen finden Sie unter EventWaitHandle, AutoResetEvent, CountdownEvent, ManualResetEvent.

HinweisHinweis

Das HostProtectionAttribute -Attribut, das auf diesen Typ oder Member angewendet wird, besitzt den folgenden Resources Eigenschaftswert: Synchronization | ExternalThreading. Das HostProtectionAttribute hat keine Auswirkungen auf Desktopanwendungen (die normalerweise durch Doppelklicken auf ein Symbol, Eingeben eines Befehls oder einer URL in einem Browser gestartet werden). Weitere Informationen finden Sie unter HostProtectionAttribute -Klasse oder SQL Server-Programmierung und Hostschutzattribute.

Im folgenden Codebeispiel wird die SignalAndWait(WaitHandle, WaitHandle)-Methodenüberladung verwendet, um das Signalisieren eines blockierten Threads durch den Hauptthread zuzulassen und dann zu warten, bis der Thread eine Aufgabe beendet hat.

Im Beispiel werden fünf Threads gestartet, und es wird zugelassen, dass eine EventWaitHandle-Methode blockiert wird, die mit dem EventResetMode.AutoReset-Flag erstellt wurde. Anschließend wird einer dieser Threads immer dann freigegeben, wenn die EINGABETASTE gedrückt wird. Im Beispiel werden dann fünf weitere Threads in die Warteschlange gestellt und mithilfe eines EventWaitHandle freigegeben, der mit dem EventResetMode.ManualReset-Flag erstellt wurde.


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();
    }
}


.NET Framework

Unterstützt in: 4.5, 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Unterstützt in: 4, 3.5 SP1

Portable Klassenbibliothek

Unterstützt in: Portable Klassenbibliothek

.NET für Windows Store-Apps

Unterstützt in: Windows 8

Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (Server Core-Rolle wird nicht unterstützt), Windows Server 2008 R2 (Server Core-Rolle wird mit SP1 oder höher unterstützt; Itanium wird nicht unterstützt)

Es werden nicht alle Versionen sämtlicher Plattformen von .NET Framework unterstützt.. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen für .NET Framework.

Dieser Typ ist threadsicher.

Community-Beiträge

HINZUFÜGEN
Anzeigen:
© 2014 Microsoft