Un contatore asincrono che può essere attendeva

Question

Ho una classe di connessione che ha diversi metodi asincroni come SendText, SendImage ecc

La classe di collegamento ha un metodo Disconnect, e quando viene chiamato devo fare attenzione non iniziare a modificare lo stato interno della classe prima che tutti i metodi asincroni abbiano completato l'esecuzione.

Credo che un buon modo per ottenere questo è semplicemente mantenere un totale parziale del numero di operazioni in esecuzione, e poi quando voglio Disconnect posso semplicemente impostare Disconnecting = true e poi aspettare che il conteggio raggiunga 0

sto pensando a qualcosa sulla falsariga di questo

class ReferenceCounter 
{ 
    void Increment(); 

    void Decrement(); 

    async Task WaitForCounterToReachZero(); 
} 

Poi, quando un'operazione asincrona inizia potevo fare

refCounter.Increment(); 

quando si le estremità

refCounter.Decrement(); 

e all'interno del metodo Disconnect

disconnecting = true; 
taskCancellationSource.Cancel(); 
await refCounter.WaitForCounterToReachZero(); 
Cleanup(); 

Vi sono costruiti in classi .NET come questo?

O più importante per me, c'è un modo migliore per farlo?

Se fosse codice sincrono sarebbe stato così semplice come

lock (thisLock) 
{ 
    while (counter > 0) 
     Monitor.Wait(thisLock); 
} 

Ho appena trovato il costruito in classe CountdownEvent che fa la stessa cosa, ma non ha alcun metodo asincrono Wait né ha alcun evento, quindi dovrei bloccare.

Answer 1

Beh, partendo dal presupposto che non avrete mai incrementa ancora dopo si rendono 0, si poteva fare qualcosa di simile:

public class Latch 
{ 
    private int count = 0; 
    private readonly TaskCompletionSource<object> tcs = 
     new TaskCompletionSource<object>(); 

    public void Increment() 
    { 
     Interlocked.Increment(ref count); 
    } 

    public void Decrement() 
    { 
     if (Interlocked.Decrement(ref count) == 0) 
     { 
      tcs.TrySetValue(null); 
     } 
    } 

    public Task Task { get { return tcs.Task; } } 
} 

Quindi è possibile attendere someLatch.Task. In alternativa, si potrebbe fare il fermo stesso awaitable:

public TaskAwaiter GetAwaiter() 
{ 
    return tcs.Task.GetAwaiter(); 
} 

probabilmente si dovrebbe considerare come si desidera a guardia contro il "conteggio aumenta dopo scendendo a 0" aspetto thuogh - pensare a quello che ci si vuole che faccia . (Nel codice sopra, una volta impostato il valore del TCS, ulteriori attese si completeranno immediatamente.)