Come gestire le operazioni asincrone in applicazioni UI e web: un'analisi del pattern Task-Based Asynchronous Pattern (TAP)

Nel contesto delle applicazioni, l'approccio asincrono è diventato un paradigma fondamentale per gestire le operazioni che richiedono tempo, come il ridimensionamento delle immagini, le operazioni di rete o qualsiasi altra attività che blocca il flusso di esecuzione se non trattata correttamente. Un caso tipico potrebbe essere quello di ridimensionare un'immagine in un'applicazione. L'uso del pattern Task-Based Asynchronous Pattern (TAP) in un'applicazione può sembrare semplice, ma le differenze tra le applicazioni UI e quelle web possono generare delle sorprese.

Immagina di avere una funzione che ridimensiona un'immagine in un'applicazione. Se questa funzione è eseguita sincrona nel contesto di un'applicazione web, i benefici che il TAP intende portare vengono completamente vanificati. Invece di ottimizzare l'interfaccia utente (UI) con un comportamento non bloccante, si rischia di rallentare l'intero sistema. Quando si utilizza TAP, la metodologia prevede che una Task venga restituita rapidamente. Tuttavia, se il codice è scritto per un'applicazione web e si utilizza un metodo sincrono per il ridimensionamento di immagini, chiunque sposti il codice in un'applicazione UI si troverà di fronte a un comportamento inaspettato: il blocco dell'interfaccia utente.

Questo è un chiaro esempio di come il TAP, pur essendo progettato per ottimizzare l'uso delle risorse, possa fallire se non implementato correttamente nel giusto contesto. L'obiettivo del TAP è infatti rendere facili le operazioni asincrone, ma le operazioni lente e bloccanti, come quelle che si svolgono sincronicamente, non traggono vantaggio da questa metodologia.

Il TAP è progettato per semplificare la creazione di utility che lavorano con le Task, con il vantaggio che i metodi TAP restituiscono sempre una Task. Ciò significa che ogni comportamento speciale scritto per una Task può essere riutilizzato per altre Task, facilitando la gestione delle operazioni asincrone.

Nel corso di questa discussione, esamineremo alcune utilità utili per lavorare con le Task, tra cui metodi che, pur sembrando appartenere al TAP, in realtà eseguono operazioni con comportamenti speciali, combinatori che creano nuove Task processando quelle esistenti e strumenti per la gestione dell'annullamento e del progresso nelle operazioni asincrone.

Ad esempio, un'operazione comune e semplice potrebbe essere quella di "ritardare" l'esecuzione di un'operazione per un periodo di tempo definito. In un contesto sincrono, potremmo usare Thread.Sleep per ottenere lo stesso risultato. Tuttavia, questa operazione è inefficiente, poiché blocca un thread solo per attendere un periodo di tempo, il che rappresenta uno spreco di risorse.

Una soluzione più efficiente consiste nell'utilizzare una classe già esistente in .NET: la System.Threading.Timer. Invece di consumare un thread, possiamo creare una Task che si completa al termine del periodo di attesa, senza bloccare il flusso di esecuzione. In questo modo, l'operazione di ritardo diventa asincrona ed evita l'uso di risorse inutili. Un esempio di implementazione potrebbe essere:

csharp
Copy code
private static Task Delay(int millis)
{
    TaskCompletionSource tcs = new TaskCompletionSource();
    Timer timer = new Timer(_ => tcs.SetResult(), null, millis, Timeout.Infinite);
    return tcs.Task;
}

Questa soluzione è un chiaro esempio di come il TAP consenta di implementare in modo semplice e efficiente operazioni asincrone che sarebbero altrimenti complesse o inefficienti utilizzando un approccio sincrono.

Oltre a ciò, ci sono altre tecniche che possono essere utili quando si lavora con operazioni asincrone. La gestione dell'annullamento di una Task è fondamentale, soprattutto in scenari dove un'operazione lunga possa essere interrotta prima del suo completamento. Utilizzando un CancellationToken, possiamo permettere all'utente o al sistema di annullare un'operazione in corso senza dover attendere il suo termine. Anche il monitoraggio del progresso di un'operazione asincrona è importante, in quanto permette all'utente di avere un feedback visivo o testuale riguardo all'avanzamento dell'operazione stessa.

Un altro aspetto interessante riguarda i combinatori, che sono metodi che permettono di creare nuove Task a partire da quelle esistenti, combinando i risultati di più operazioni asincrone. Questi strumenti sono particolarmente utili quando si devono gestire più Task contemporaneamente, come nel caso di operazioni che dipendono l'una dall'altra o che devono essere eseguite in parallelo.

In conclusione, l'adozione del TAP permette di semplificare la gestione delle operazioni asincrone, ma è fondamentale comprendere come sfruttarlo nel giusto contesto. Un'applicazione UI ha esigenze molto diverse rispetto a un'applicazione web, e la gestione delle risorse e delle operazioni deve essere attentamente calibrata. La comprensione di come il TAP si integra con altre utility, come la gestione del ritardo, dell'annullamento o del progresso, è essenziale per creare applicazioni efficienti e responsive.

Come creare i propri combinatori asincroni

QuandoAll e QuandoAny sono combinatori asincroni. Sebbene restituiscano dei Task, non sono metodi asincroni a sé stanti, ma piuttosto combinano altri Task in modi utili. È possibile scrivere anche i propri combinatori, se necessario, in modo da disporre di una tavolozza di comportamenti paralleli riutilizzabili da applicare dove si desidera. Vediamo come scrivere un combinatore come esempio. Supponiamo che vogliamo aggiungere un timeout a un Task. Sebbene sia possibile scrivere questa funzionalità da zero in modo abbastanza semplice, è utile come esempio per usare sia Delay che WhenAny. In generale, i combinatori sono spesso più facili da implementare usando async, come in questo caso, ma a volte non sarà necessario farlo.

csharp
Copy code
private static async Task WithTimeout(Task task, int time) 
{
    Task delayTask = Task.Delay(time); 
    Task firstToFinish = await Task.WhenAny(task, delayTask); 
    
    if (firstToFinish == delayTask) 
    {
        // Il delay è scaduto prima - gestire l'eccezione
        task.ContinueWith(HandleException);
        throw new TimeoutException(); 
    }
    return await task; // Se arriviamo qui, il task originale è già terminato
}

La mia tecnica è quella di creare un Task utilizzando Delay che si completerà dopo il timeout. Poi utilizzo WhenAny su entrambi, il Task originale e il Delay, in modo che la continuazione avvenga quando uno dei due termina prima, che sia l'operazione originale o la scadenza del timeout. Successivamente, è una questione di determinare quale delle due operazioni sia terminata e, in caso di timeout, generare una TimeoutException o restituire il risultato del Task. Va notato che ho prestato attenzione alle eccezioni nel caso in cui scada il timeout. Ho allegato una continuazione al Task originale usando ContinueWith, che gestisce eventuali eccezioni se ce ne sono. So che il Task di Delay non genererà mai eccezioni, quindi non c'è bisogno di gestirlo. L'implementazione del metodo HandleException potrebbe assomigliare a questa:

csharp
Copy code
private static void HandleException(Task task) 
{
    if (task.Exception != null) 
    {
        logging.LogException(task.Exception); 
    }
}

Ovviamente, ciò che fare qui dipende dalla strategia di gestione delle eccezioni. Allegando questa gestione usando ContinueWith, mi assicuro che, ogni volta che il Task originale termina, indipendentemente da quanto tempo ci vorrà, venga eseguito il codice per verificare le eccezioni. È importante notare che questo non blocca l'esecuzione principale del programma, che ha già completato ciò che doveva fare quando il timeout è scaduto.

Cancellare le operazioni asincrone

Invece di essere vincolato al tipo Task, la cancellazione nell'approccio TAP (Task Asynchronous Programming) è abilitata dal tipo CancellationToken. Per convenzione, qualsiasi metodo TAP che supporti la cancellazione dovrebbe avere un sovraccarico che prende un CancellationToken dopo i parametri normali. Un esempio nel framework è il tipo DbCommand e i suoi metodi asincroni che interpellano un database. Il sovraccarico più semplice di ExecuteNonQueryAsync non ha parametri.

csharp
Copy code
Task ExecuteNonQueryAsync(CancellationToken cancellationToken)

Iniziamo a vedere come cancellare un metodo asincrono che abbiamo chiamato. Per fare ciò, dobbiamo usare CancellationTokenSource, che è uno strumento per creare e controllare i CancellationToken, simile a come TaskCompletionSource crea e controlla un Task. Il seguente codice è incompleto, ma mostra la tecnica di base necessaria:

csharp
Copy code
CancellationTokenSource cts = new CancellationTokenSource();
cancelButton.Click += delegate { cts.Cancel(); }; 
int result = await dbCommand.ExecuteNonQueryAsync(cts.Token);

Quando si chiama Cancel su CancellationTokenSource, il CancellationToken entra nello stato di cancellato. È possibile registrare un delegato da chiamare quando ciò accade, ma in pratica, un approccio di polling molto più semplice per rilevare se il chiamante vuole che l'operazione venga cancellata è più efficace. Se stai scrivendo un ciclo in un metodo asincrono e un CancellationToken è disponibile, dovresti semplicemente chiamare ThrowIfCancellationRequested in ogni iterazione del ciclo.

csharp
Copy code
foreach (var x in thingsToProcess) 
{
    cancellationToken.ThrowIfCancellationRequested();
    // Elaborare x ...
}

Quando chiami ThrowIfCancellationRequested su un CancellationToken che è stato annullato, viene generata un'eccezione OperationCanceledException. La Task Parallel Library sa che questo tipo di eccezione rappresenta la cancellazione e lo tratterà in modo diverso. Ad esempio, Task ha una proprietà chiamata IsCanceled che diventa automaticamente vera quando viene lanciata un'OperationCanceledException durante l'esecuzione di un metodo asincrono. Una caratteristica interessante dell'approccio basato sul token di cancellazione è che lo stesso CancellationToken può essere distribuito a più parti dell'operazione asincrona, semplicemente passandolo a loro. Che queste parti vengano eseguite in parallelo o in sequenza, e che si tratti di operazioni che coinvolgono cicli o operazioni remote, lo stesso token può annullarle tutte.

Restituire il progresso durante un'operazione asincrona

Oltre a mantenere l'interfaccia utente reattiva e a dare all'utente la possibilità di cancellare, un altro buon modo per migliorare l'esperienza durante un'operazione inevitabilmente lenta è indicare quanto tempo ancora l'utente dovrà aspettare. Per fare ciò, un'altra coppia di tipi per indicare il progresso è fornita e raccomandata come parte del TAP. In questo caso, si passa ai metodi asincroni un'interfaccia, IProgress, che può essere chiamata per fornire un'indicazione di come stanno andando le cose. Il parametro IProgress, per convenzione, viene posto alla fine dei parametri del metodo, dopo eventuali CancellationToken.

csharp
Copy code
Task DownloadDataTaskAsync(Uri address, CancellationToken cancellationToken, IProgress progress)

Per utilizzare un metodo come questo, è necessario creare un'implementazione di IProgress. Fortunatamente, ne esiste una che fornisce esattamente ciò di cui si ha bisogno nella maggior parte delle situazioni: Progress. Si costruisce uno di questi, passando un'espressione lambda nel suo costruttore o iscrivendosi a un evento, per ricevere notifiche sui nuovi dati di progresso, che possono essere utilizzati per aggiornare l'interfaccia utente.

csharp
Copy code
new Progress(percentage => progressBar.Value = percentage);

La caratteristica intelligente di Progress è che cattura il SynchronizationContext durante la costruzione e lo utilizza per chiamare il codice di aggiornamento del progresso nel thread giusto. Questo comportamento è molto simile a quello di un Task che continua dopo un await, quindi non c'è bisogno di preoccuparsi del fatto che IProgress possa essere chiamato da un thread diverso. Se vuoi restituire il progresso quando scrivi un metodo TAP, è sufficiente chiamare il metodo Report su IProgress.

csharp
Copy code
progress.Report(percent);

La parte difficile è scegliere il parametro di tipo T. Questo è il tipo dell'oggetto che passi a Report, che è lo stesso oggetto che la lambda del chiamante riceve. Un int è una buona scelta per le percentuali semplici, come nel caso sopra, ma a volte potrebbero servire più dettagli. Fai attenzione, perché quell'oggetto sarà solitamente consumato da un thread diverso rispetto a quello che l'ha creato. Usa un tipo immutabile per evitare problemi.

Cos'è la programmazione asincrona in C# e come può migliorare le tue applicazioni?

La programmazione asincrona è una tecnica che consente a un'applicazione di continuare a funzionare mentre sta aspettando che vengano completate operazioni lunghe, come richieste di rete, accessi a disco o altre operazioni che richiedono tempo. Questo tipo di programmazione è fondamentale quando si desidera evitare il blocco dell'intero thread durante l'esecuzione di attività che potrebbero richiedere un tempo significativo.

In C#, la programmazione asincrona è stata semplificata con l'introduzione della parola chiave async nella versione 5.0. In un sistema tradizionale, il codice viene eseguito in un thread che, se non c'è altro da fare, resta inattivo in attesa di completare una lunga operazione. Questo comportamento è definito "bloccante", poiché il thread è completamente dedicato all'operazione in corso, senza poter eseguire altre attività. Al contrario, la programmazione asincrona consente di eseguire altre operazioni mentre si aspetta che un'attività finisca, rendendo l'applicazione più reattiva e performante.

Il vantaggio principale della programmazione asincrona risiede nel miglioramento della gestione delle risorse di sistema, soprattutto in applicazioni che effettuano operazioni di I/O, come il recupero di dati da un database, il caricamento di file o la comunicazione tramite rete. Quando si utilizzano metodi asincroni, il thread non resta bloccato in attesa della risposta, ma può essere riutilizzato per altre operazioni, ottimizzando il flusso complessivo dell'applicazione.

Un esempio pratico è quello delle applicazioni web. Quando un server web riceve una richiesta da un client, normalmente non si aspetta che un thread rimanga attivo in attesa che venga completato un processo di backend, come l'accesso a un database. Utilizzando la programmazione asincrona, il server può continuare a gestire altre richieste mentre si aspetta la risposta dal database, migliorando così la capacità di gestire più client contemporaneamente.

Tuttavia, la programmazione asincrona non è priva di difficoltà. Sebbene l'uso di async e await possa semplificare il codice, la gestione di operazioni asincrone complesse, come la sincronizzazione di più operazioni o la gestione degli errori, può essere insidiosa. È fondamentale capire i principi base dell'esecuzione asincrona, ma anche conoscere le sue insidie e le best practices per evitare i problemi comuni, come il deadlock o la gestione errata dei thread.

Un aspetto critico da comprendere è che non tutte le operazioni giustificano l'uso dell'asincrono. Le operazioni brevi, come una semplice scrittura su un file o un accesso a memoria locale, possono essere più efficienti se gestite in modo sincrono. L'asincrono è ideale quando si hanno operazioni lunghe o che richiedono tempo, ma non sempre è vantaggioso applicarlo indiscriminatamente.

La gestione del flusso di controllo in un'applicazione asincrona può sembrare complessa, specialmente quando si tratta di errori. L'errore in un metodo asincrono non viene sollevato immediatamente; piuttosto, viene "incapsulato" fino a quando il metodo non viene effettivamente completato. Questo può comportare una gestione degli errori diversa da quella a cui un programmatore è abituato nelle applicazioni sincrone. È essenziale tenere presente che, quando si scrive codice asincrono, bisogna gestire correttamente gli errori sia all'interno dei metodi asincroni che quando questi metodi vengono invocati.

Un altro punto importante riguarda l'uso del modello Task. In C#, le operazioni asincrone sono comunemente gestite attraverso oggetti di tipo Task, che rappresentano un'operazione che verrà eseguita in un secondo momento. Un Task può essere atteso con await, che permette di ottenere il risultato dell'operazione senza bloccare il thread. Tuttavia, l'uso dei task deve essere ben pianificato, poiché un numero eccessivo di task simultanei può causare un sovraccarico delle risorse di sistema e rallentare l'applicazione.

L'adozione della programmazione asincrona comporta anche una nuova modalità di pensiero e progettazione delle applicazioni. Si deve imparare a progettare il flusso del programma in modo che le operazioni asincrone vengano gestite in modo logico, mantenendo il controllo sulla sequenza delle operazioni e sulla gestione dei risultati. L'approccio asincrono non si limita solo a migliorare le performance, ma consente anche una gestione più fluida dell'esperienza utente, specialmente in contesti come le applicazioni web o quelle mobili, dove la reattività è un elemento cruciale.

In sintesi, la programmazione asincrona rappresenta un potente strumento nelle mani dei programmatori C#. Tuttavia, richiede un'attenta gestione, sia a livello di codice che di architettura, per evitare complicazioni legate a sincronizzazione, gestione degli errori e sovraccarico delle risorse. Una comprensione approfondita della programmazione asincrona, unita alla consapevolezza dei suoi limiti, è essenziale per sfruttare appieno il suo potenziale e ottenere applicazioni più reattive e performanti.