Sfondo
Attualmente sto lavorando all'architettura per un futuro design del software. Il design è un compito di lunga durata (ore) con migliaia di chiamate sequenziali a varie librerie. Al momento ho un metodo per mettere in pausa questa attività di lunga durata, che vorrei prima discutere prima di porre la mia domanda.
Il flusso di controllo per la pausa funzionerà come segue:
- L'utente / operatore fa clic su un pulsante pausa .
- A
ManualResetEvent
èSet
. - L'attività in esecuzione (descritta nel primo paragrafo) osserverà
ManualResetEvent
e si fermerà nelle sue tracce.
L'attività potrebbe essere qualcosa di sequenziale come ...
/// <summary>
/// Some task that calls three wrapped library
/// methods.
/// </summary>
public void MyTaskMethod()
{
// perform some library methods...
WrappedLibraryMethodOne();
WrappedLibraryMethodTwo();
WrappedLibraryMethodThree();
}
La metodologia di pausa implica quanto segue, avvolgendo i metodi della libreria per osservare un ManualResetEvent
come segue:
/// <summary>
/// Wraps a library method call, and also checks
/// to see if we're paused.
/// </summary>
public void WrappedLibraryMethodOne()
{
// 1. Check if we should pause here.
this.pause.WaitOne();
// 2. Call the library method.
this.myLibrary.LibraryMethod();
}
Nota che ManualResetEvent
s non aderisce a nessun timeout. Inoltre, tutti i WrappedLibraryMethod
s assomigliano a questo (da qui la cosa DRY).
Il mio problema con l'utilizzo di questo metodo è che ora devo racchiudere tutti i miei metodi di libreria. Questo diventa quasi un problema ASCIUTTO, dove sto avvolgendo ogni singolo metodo che arriva.
Domanda
Questo modo di fare le cose funziona, e io non ho un grosso problema con il fatto che sto solo creando un'illusione di concorrenza. Tuttavia, dovrei provare a eseguire lo streaming in qualche modo?