CountdownEvent Klasa

  • Odwołanie

Definicja

Przestrzeń nazw:
System.Threading
Zestaw:
System.Threading.dll
Zestaw:
mscorlib.dll
Zestaw:
netstandard.dll

Reprezentuje typ pierwotny synchronizacji, który jest sygnalizowany, gdy jego liczba osiągnie zero.

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
Dziedziczenie
Object
CountdownEvent
Atrybuty
ComVisibleAttribute
Implementuje
IDisposable

Przykłady

W poniższym przykładzie pokazano, jak używać elementu CountdownEvent:

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 know 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

Konstruktory

CountdownEvent(Int32)

Inicjuje CountdownEvent nowe wystąpienie klasy z określoną liczbą.

Właściwości

CurrentCount

Pobiera liczbę pozostałych sygnałów wymaganych do ustawienia zdarzenia.
InitialCount

Pobiera liczbę sygnałów, które początkowo są wymagane do ustawienia zdarzenia.
IsSet

Wskazuje, czy CountdownEvent bieżąca liczba obiektów osiągnęła zero.
WaitHandle

Pobiera element WaitHandle służący do oczekiwania na ustawienie zdarzenia.

Metody

AddCount()

Zwiększa bieżącą CountdownEventliczbę o jeden.
AddCount(Int32)

Zwiększa bieżącą liczbę parametrów CountdownEvento określoną wartość.
Dispose()

Zwalnia wszystkie zasoby używane przez bieżące wystąpienie klasy CountdownEvent.
Dispose(Boolean)

Zwalnia niezarządzane zasoby używane przez CountdownEventprogram i opcjonalnie zwalnia zarządzane zasoby.
Equals(Object)

Określa, czy dany obiekt jest taki sam, jak bieżący obiekt.

(Odziedziczone po Object)
GetHashCode()

Służy jako domyślna funkcja skrótu.

(Odziedziczone po Object)
GetType()

Type Pobiera wartość bieżącego wystąpienia.

(Odziedziczone po Object)
MemberwiseClone()

Tworzy płytkią kopię bieżącego Objectelementu .

(Odziedziczone po Object)
Reset()

Resetuje wartość CurrentCount do wartości InitialCount.
Reset(Int32)

Resetuje InitialCount właściwość do określonej wartości.
Signal()

Rejestruje sygnał za CountdownEventpomocą metody , co spowoduje dekrementowanie wartości .CurrentCount
Signal(Int32)

Rejestruje wiele sygnałów za CountdownEventpomocą , dekrementując wartość CurrentCount o określoną kwotę.
ToString()

Zwraca ciąg reprezentujący bieżący obiekt.

(Odziedziczone po Object)
TryAddCount()

Próbuje zwiększać CurrentCount się o jeden.
TryAddCount(Int32)

Próbuje zwiększać CurrentCount się o określoną wartość.
Wait()

Blokuje bieżący wątek do momentu CountdownEvent ustawienia.
Wait(CancellationToken)

Blokuje bieżący wątek do CountdownEvent momentu ustawienia elementu , obserwując element CancellationToken.
Wait(Int32)

Blokuje bieżący wątek do momentu CountdownEvent ustawienia, używając 32-bitowej liczby całkowitej ze znakiem, aby zmierzyć limit czasu.
Wait(Int32, CancellationToken)

Blokuje bieżący wątek do momentu CountdownEvent ustawienia, używając 32-bitowej liczby całkowitej ze znakiem CancellationToken, aby zmierzyć limit czasu, obserwując wartość .
Wait(TimeSpan)

Blokuje bieżący wątek do momentu CountdownEvent ustawienia, używając elementu , TimeSpan aby zmierzyć limit czasu.
Wait(TimeSpan, CancellationToken)

Blokuje bieżący wątek do momentu CountdownEvent ustawienia elementu , używając parametru , TimeSpan aby zmierzyć limit czasu, obserwując CancellationTokenelement .

Dotyczy

Bezpieczeństwo wątkowe

Wszystkie publiczne i chronione elementy członkowskie CountdownEvent są bezpieczne wątkowo i mogą być używane jednocześnie z wielu wątków, z wyjątkiem Dispose(), które muszą być używane tylko wtedy, gdy wszystkie inne operacje na CountdownEvent obiekcie zostały ukończone i Reset(), które powinny być używane tylko wtedy, gdy żadne inne wątki nie uzyskują dostępu do zdarzenia.

Zobacz też