CountdownEvent Clase

  • Referencia

Definición

Espacio de nombres:
System.Threading
Ensamblado:
System.Threading.dll
Ensamblado:
mscorlib.dll
Ensamblado:
netstandard.dll

Representa una primitiva de sincronización que está señalada cuando su recuento alcanza el valor cero.

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
Herencia
Object
CountdownEvent
Atributos
ComVisibleAttribute
Implementaciones
IDisposable

Ejemplos

En el ejemplo siguiente se muestra cómo usar :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

Constructores

CountdownEvent(Int32)

Inicializa una nueva instancia de la clase CountdownEvent con el recuento especificado.

Propiedades

CurrentCount

Obtiene el número de señales restantes necesario para establecer el evento.
InitialCount

Obtiene los números de señales que se necesitan inicialmente para establecer el evento.
IsSet

Indica si el recuento actual del objeto CountdownEvent ha llegado a cero.
WaitHandle

Obtiene un objeto WaitHandle que se usa para esperar a que se establezca el evento.

Métodos

AddCount()

Incrementa en uno el recuento actual de CountdownEvent.
AddCount(Int32)

Incrementa en un valor especificado el recuento actual de CountdownEvent.
Dispose()

Libera todos los recursos usados por la instancia actual de la clase CountdownEvent.
Dispose(Boolean)

Libera los recursos no administrados utilizados por el objeto CountdownEvent y, de forma opcional, libera los recursos administrados.
Equals(Object)

Determina si el objeto especificado es igual que el objeto actual.

(Heredado de Object)
GetHashCode()

Sirve como la función hash predeterminada.

(Heredado de Object)
GetType()

Obtiene el Type de la instancia actual.

(Heredado de Object)
MemberwiseClone()

Crea una copia superficial del Object actual.

(Heredado de Object)
Reset()

Restablece CurrentCount en el valor de InitialCount.
Reset(Int32)

Restablece la propiedad InitialCount según un valor especificado.
Signal()

Registra una señal con CountdownEvent y disminuye el valor de CurrentCount.
Signal(Int32)

Registra varias señales con CountdownEvent reduciendo el valor de CurrentCount según la cantidad especificada.
ToString()

Devuelve una cadena que representa el objeto actual.

(Heredado de Object)
TryAddCount()

Intenta incrementar CurrentCount en uno.
TryAddCount(Int32)

Intenta incrementar CurrentCount en un valor especificado.
Wait()

Bloquea el subproceso actual hasta que se establezca el objeto CountdownEvent.
Wait(CancellationToken)

Bloquea el subproceso actual hasta que se establezca el objeto CountdownEvent, mientras se observa un token CancellationToken.
Wait(Int32)

Bloquea el subproceso actual hasta que se establezca el objeto CountdownEvent, usando un entero de 32 bits con signo para medir el tiempo de espera.
Wait(Int32, CancellationToken)

Bloquea el subproceso actual hasta que se establezca el objeto CountdownEvent, usando un entero de 32 bits con signo para medir el tiempo de espera, mientras se observa un token CancellationToken.
Wait(TimeSpan)

Bloquea el subproceso actual hasta que se establezca el objeto CountdownEvent, usando un objeto TimeSpan para medir el tiempo de espera.
Wait(TimeSpan, CancellationToken)

Bloquea el subproceso actual hasta que se establezca el objeto CountdownEvent, usando un objeto TimeSpan para medir el tiempo de espera, mientras se observa un token CancellationToken.

Se aplica a

Seguridad para subprocesos

Todos los miembros públicos y protegidos de CountdownEvent son seguros para subprocesos y se pueden usar simultáneamente desde varios subprocesos, con la excepción de Dispose(), que solo se debe usar cuando todas las demás operaciones CountdownEvent de han finalizado, y Reset(), que solo se deben usar cuando ningún otro subproceso tiene acceso al evento.

Consulte también