CountdownEvent Klasse

Definition

Stellt einen Synchronisierungsprimitiven dar, dem signalisiert wird, wenn sein Zähler 0 (null) erreicht.

public ref class CountdownEvent : IDisposable
public class CountdownEvent : IDisposable
[System.Runtime.InteropServices.ComVisible(false)]
public class CountdownEvent : IDisposable
type CountdownEvent = class
    interface IDisposable
[<System.Runtime.InteropServices.ComVisible(false)>]
type CountdownEvent = class
    interface IDisposable
Public Class CountdownEvent
Implements IDisposable
Vererbung
CountdownEvent
Attribute
Implementiert

Beispiele

Im folgenden Beispiel wird die Verwendung eines CountdownEvent veranschaulicht:

using System;
using System.Collections.Concurrent;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

class Example
{
    static async Task Main()
    {
        // Initialize a queue and a CountdownEvent
        ConcurrentQueue<int> queue = new ConcurrentQueue<int>(Enumerable.Range(0, 10000));
        CountdownEvent cde = new CountdownEvent(10000); // initial count = 10000

        // This is the logic for all queue consumers
        Action consumer = () =>
        {
            int local;
            // decrement CDE count once for each element consumed from queue
            while (queue.TryDequeue(out local)) cde.Signal();
        };

        // Now empty the queue with a couple of asynchronous tasks
        Task t1 = Task.Factory.StartNew(consumer);
        Task t2 = Task.Factory.StartNew(consumer);

        // And wait for queue to empty by waiting on cde
        cde.Wait(); // will return when cde count reaches 0

        Console.WriteLine("Done emptying queue.  InitialCount={0}, CurrentCount={1}, IsSet={2}",
            cde.InitialCount, cde.CurrentCount, cde.IsSet);

        // Proper form is to wait for the tasks to complete, even if you that their work
        // is done already.
        await Task.WhenAll(t1, t2);

        // Resetting will cause the CountdownEvent to un-set, and resets InitialCount/CurrentCount
        // to the specified value
        cde.Reset(10);

        // AddCount will affect the CurrentCount, but not the InitialCount
        cde.AddCount(2);

        Console.WriteLine("After Reset(10), AddCount(2): InitialCount={0}, CurrentCount={1}, IsSet={2}",
            cde.InitialCount, cde.CurrentCount, cde.IsSet);

        // Now try waiting with cancellation
        CancellationTokenSource cts = new CancellationTokenSource();
        cts.Cancel(); // cancels the CancellationTokenSource
        try
        {
            cde.Wait(cts.Token);
        }
        catch (OperationCanceledException)
        {
            Console.WriteLine("cde.Wait(preCanceledToken) threw OCE, as expected");
        }
        finally
        {
           cts.Dispose();
        }
        // It's good to release a CountdownEvent when you're done with it.
        cde.Dispose();
    }
}
// The example displays the following output:
//    Done emptying queue.  InitialCount=10000, CurrentCount=0, IsSet=True
//    After Reset(10), AddCount(2): InitialCount=10, CurrentCount=12, IsSet=False
//    cde.Wait(preCanceledToken) threw OCE, as expected
Imports System.Collections.Concurrent
Imports System.Linq
Imports System.Threading
Imports System.Threading.Tasks

Module Example
    Sub Main()
        ' Initialize a queue and a CountdownEvent
        Dim queue As New ConcurrentQueue(Of Integer)(Enumerable.Range(0, 10000))
        Dim cde As New CountdownEvent(10000)
        ' initial count = 10000
        ' This is the logic for all queue consumers
        Dim consumer As Action =
            Sub()
                Dim local As Integer
                ' decrement CDE count once for each element consumed from queue
                While queue.TryDequeue(local)
                    cde.Signal()
                End While
            End Sub

        ' Now empty the queue with a couple of asynchronous tasks
        Dim t1 As Task = Task.Factory.StartNew(consumer)
        Dim t2 As Task = Task.Factory.StartNew(consumer)

        ' And wait for queue to empty by waiting on cde
        cde.Wait()
        ' will return when cde count reaches 0
        Console.WriteLine("Done emptying queue. InitialCount={0}, CurrentCount={1}, IsSet={2}", cde.InitialCount, cde.CurrentCount, cde.IsSet)

        ' Proper form is to wait for the tasks to complete, even if you know that their work
        ' is done already.
        Task.WaitAll(t1, t2)

        ' Resetting will cause the CountdownEvent to un-set, and resets InitialCount/CurrentCount
        ' to the specified value
        cde.Reset(10)

        ' AddCount will affect the CurrentCount, but not the InitialCount
        cde.AddCount(2)

        Console.WriteLine("After Reset(10), AddCount(2): InitialCount={0}, CurrentCount={1}, IsSet={2}", cde.InitialCount, cde.CurrentCount, cde.IsSet)

        ' Now try waiting with cancellation
        Dim cts As New CancellationTokenSource()
        cts.Cancel()
        ' cancels the CancellationTokenSource
        Try
            cde.Wait(cts.Token)
        Catch generatedExceptionName As OperationCanceledException
            Console.WriteLine("cde.Wait(preCanceledToken) threw OCE, as expected")
        Finally
           cts.Dispose()
        End Try

        ' It's good to release a CountdownEvent when you're done with it.
        cde.Dispose()
    End Sub
End Module
' The example displays the following output:
'    Done emptying queue.  InitialCount=10000, CurrentCount=0, IsSet=True
'    After Reset(10), AddCount(2): InitialCount=10, CurrentCount=12, IsSet=False
'    cde.Wait(preCanceledToken) threw OCE, as expected

Konstruktoren

CountdownEvent(Int32)

Initialisiert eine neue Instanz der CountdownEvent-Klasse mit der angegebenen Anzahl.

Eigenschaften

CurrentCount

Ruft die Anzahl verbleibender Signale ab, die zum Festlegen des Ereignisses erforderlich sind.

InitialCount

Ruft die Anzahl von Signalen ab, die ursprünglich zum Festlegen des Ereignisses erforderlich waren.

IsSet

Gibt an, ob die aktuelle Anzahl des CountdownEvent-Objekts 0 (null) erreicht hat.

WaitHandle

Ruft ein WaitHandle ab, das verwendet wird, um auf das festzulegende Ereignis zu warten.

Methoden

AddCount()

Erhöht die aktuelle Anzahl von CountdownEvent um 1.

AddCount(Int32)

Erhöht die aktuelle Anzahl von CountdownEvent um einen angegebenen Wert.

Dispose()

Gibt alle von der aktuellen Instanz der CountdownEvent-Klasse verwendeten Ressourcen frei.

Dispose(Boolean)

Gibt die von CountdownEvent verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei.

Equals(Object)

Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist.

(Geerbt von Object)
GetHashCode()

Fungiert als Standardhashfunktion.

(Geerbt von Object)
GetType()

Ruft den Type der aktuellen Instanz ab.

(Geerbt von Object)
MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.

(Geerbt von Object)
Reset()

Setzt CurrentCount auf den Wert von InitialCount zurück.

Reset(Int32)

Setzt die InitialCount-Eigenschaft auf einen angegebenen Wert zurück.

Signal()

Registriert ein Signal beim CountdownEvent und dekrementiert den Wert von CurrentCount.

Signal(Int32)

Registriert mehrere Signale bei CountdownEvent und verringert den Wert von CurrentCount um den angegebenen Wert.

ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.

(Geerbt von Object)
TryAddCount()

Versucht, CurrentCount um eins zu inkrementieren.

TryAddCount(Int32)

Versucht, CurrentCount durch einen angegebenen Wert zu inkrementieren.

Wait()

Blockiert den aktuellen Thread, bis CountdownEvent festgelegt wird.

Wait(CancellationToken)

Blockiert den aktuellen Thread, bis CountdownEvent festgelegt wird, wobei ein CancellationToken überwacht wird.

Wait(Int32)

Blockiert den aktuellen Thread, bis CountdownEvent festgelegt wird, wobei eine 32-Bit-Ganzzahl mit Vorzeichen zum Messen des Timeouts verwendet wird.

Wait(Int32, CancellationToken)

Blockiert den aktuellen Thread, bis CountdownEvent festgelegt wird, wobei eine 32-Bit-Ganzzahl mit Vorzeichen zum Messen des Timeouts verwendet und ein CancellationToken überwacht wird.

Wait(TimeSpan)

Blockiert den aktuellen Thread, bis CountdownEvent festgelegt wird, wobei ein TimeSpan zum Messen des Timeouts verwendet wird.

Wait(TimeSpan, CancellationToken)

Blockiert den aktuellen Thread, bis CountdownEvent festgelegt wird, wobei ein TimeSpan zum Messen des Zeitintervalls verwendet und ein CancellationToken überwacht wird.

Gilt für

Threadsicherheit

Alle öffentlichen und geschützten Member von sind threadsicher und können gleichzeitig von mehreren Threads verwendet werden, mit Ausnahme von , das nur verwendet werden darf, wenn alle anderen Vorgänge auf dem abgeschlossen wurden, und , die nur verwendet werden sollten, wenn keine anderen Threads auf das Ereignis CountdownEvent Dispose() CountdownEvent Reset() zugreifen.

Siehe auch