CountdownEvent Osztály

Definíció

Névtér:
System.Threading
Szerelvények:
mscorlib.dll, System.Threading.dll
Szerelvény:
mscorlib.dll
Szerelvény:
System.Threading.dll
Szerelvény:
netstandard.dll

Egy olyan szinkronizálási primitívet jelöl, amely akkor lesz jelezve, ha a száma eléri a nullát.

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
Öröklődés
Object
CountdownEvent
Attribútumok
ComVisibleAttribute
Megvalósítás
IDisposable

Példák

Az alábbi példa bemutatja, hogyan használhatja a következőt 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

Konstruktorok

Name Description
CountdownEvent(Int32)

Inicializál egy új osztálypéldányt CountdownEvent a megadott számmal.

Tulajdonságok

Name Description
CurrentCount

Lekéri az esemény beállításához szükséges fennmaradó jelek számát.
InitialCount

Lekéri az esemény beállításához kezdetben szükséges jelek számát.
IsSet

Azt jelzi, hogy az CountdownEvent objektum aktuális száma elérte-e a nullát.
WaitHandle

WaitHandle Lekéri az esemény beállítására szolgáló parancsot.

Metódusok

Name Description
AddCount()

CountdownEventAz aktuális szám eggyel növekszik.
AddCount(Int32)

A megadott érték alapján növeli az CountdownEventaktuális számot.
Dispose()

Az osztály aktuális példánya által használt összes erőforrást felszabadítja CountdownEvent .
Dispose(Boolean)

Felszabadítja a felügyelt erőforrások által CountdownEventhasznált nem felügyelt erőforrásokat, és opcionálisan felszabadítja a felügyelt erőforrásokat.
Equals(Object)

Meghatározza, hogy a megadott objektum egyenlő-e az aktuális objektummal.

(Öröklődés forrása Object)
GetHashCode()

Ez az alapértelmezett kivonatoló függvény.

(Öröklődés forrása Object)
GetType()

Lekéri az Type aktuális példányt.

(Öröklődés forrása Object)
MemberwiseClone()

Az aktuális Objectpéldány sekély másolatát hozza létre.

(Öröklődés forrása Object)
Reset()

Alaphelyzetbe állítja a CurrentCount következő értékre InitialCount: .
Reset(Int32)

Visszaállítja a InitialCount tulajdonságot egy megadott értékre.
Signal()

Egy jelet regisztrál az CountdownEventérték csökkenésével CurrentCount.
Signal(Int32)

Több jelet regisztrál a CountdownEventmegadott összeggel csökkenő értékkel CurrentCount .
ToString()

Az aktuális objektumot jelképező sztringet ad vissza.

(Öröklődés forrása Object)
TryAddCount()

Kísérletek egyenkénti növekményre CurrentCount .
TryAddCount(Int32)

Adott érték szerinti növekményes CurrentCount kísérlet.
Wait()

Letiltja az aktuális szálat a CountdownEvent beállításig.
Wait(CancellationToken)

Blokkolja az aktuális szálat, amíg be CountdownEvent nem állítja, miközben megfigyeli a CancellationToken.
Wait(Int32, CancellationToken)

Letiltja az aktuális szálat a CountdownEvent beállításig, egy 32 bites aláírt egész szám használatával méri az időtúllépést, miközben megfigyel egy CancellationToken.
Wait(Int32)

Letiltja az aktuális szálat a CountdownEvent beállításig, egy 32 bites aláírt egész szám használatával méri az időtúllépést.
Wait(TimeSpan, CancellationToken)

Letiltja az aktuális szálat, amíg be nem áll a CountdownEvent beállítás, az időtúllépés mérésére használva TimeSpan , miközben megfigyel egy CancellationToken.
Wait(TimeSpan)

Letiltja az aktuális szálat, amíg be nem állítja az CountdownEventTimeSpan időtúllépést.

A következőre érvényes:

Szálbiztonság

Az összes nyilvános és védett tagja CountdownEvent szálbiztos, és egyidejűleg több szálból is használható, kivéve Dispose()azt, amelyet csak akkor szabad használni, ha az CountdownEvent összes többi művelet befejeződött, és Reset()amelyet csak akkor szabad használni, ha más szálak nem férnek hozzá az eseményhez.

Lásd még