Timeout, IProgress<T>, disposable asincroni (emulazione)
Applicate timeout con CancelAfter o basati su Task.WhenAny, collegate IProgress per aggiornamenti adatti all’interfaccia e usate try/finally per emulare la pulizia asincrona in C# 6.
Timeout, IProgress<T>, disposable asincroni (emulazione) è una lezione C# Academy gratuita su CoddyKit. Questa è la lezione 2 di 3. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento C# Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso C# Academy include 3 lezioni in totale.
Piano
Obiettivo:
- Gestire il timeout con CancelAfter
- Gestire il timeout tramite Task.WhenAny
- Segnalare l'avanzamento con IProgress<T>
- Usare il pattern di pulizia asincrona in C# 6 (try/finally)
Timeout con CancelAfter
Usi CancelAfter e passi il token all'API asincrona; il metodo chiamato si interrompe cooperativamente allo scadere del timeout.
using System;
using System.Threading;
using System.Threading.Tasks;
public class Program
{
static async Task<string> SlowOpAsync(CancellationToken ct)
{
// Simulate slow I/O that honors cancellation
await Task.Delay(500, ct);
return "OK";
}
public static void Main(string[] args)
{
var cts = new CancellationTokenSource();
cts.CancelAfter(150); // timeout after 150 ms
Task<string> t = SlowOpAsync(cts.Token);
try
{
string result = t.GetAwaiter().GetResult(); // demo only
Console.WriteLine(result);
}
catch (OperationCanceledException)
{
Console.WriteLine("Timed out");
}
}
}
Timeout tramite WhenAny
Task.WhenAny mette in gara il lavoro con Task.Delay; se vince il ritardo, lanci una TimeoutException.
using System;
using System.Threading.Tasks;
public class Program
{
// Wrap any Task<T> with a timeout using WhenAny
static async Task<T> WithTimeoutAsync<T>(Task<T> work, int milliseconds)
{
Task delay = Task.Delay(milliseconds);
Task first = await Task.WhenAny(work, delay);
if (first == work) return await work; // completed in time
throw new TimeoutException("Operation timed out");
}
static async Task<int> ComputeAsync()
{
await Task.Delay(300); // pretend work
return 7;
}
public static void Main(string[] args)
{
try
{
int v = WithTimeoutAsync(ComputeAsync(), 100).GetAwaiter().GetResult();
Console.WriteLine("Value " + v);
}
catch (TimeoutException ex)
{
Console.WriteLine(ex.Message);
}
}
}
Dimostrazione di IProgress<T>
IProgress<T> separa il lavoro dall'interfaccia utente; i produttori chiamano Report, mentre i consumatori aggiornano l'interfaccia utente nel thread appropriato in modo sicuro.
using System;
using System.Threading.Tasks;
public class Program
{
static async Task DownloadAsync(IProgress<int> progress)
{
// Report 0..100 in steps; UI would receive ProgressChanged on its context
for (int p = 0; p <= 100; p += 25)
{
await Task.Delay(60);
if (progress != null) progress.Report(p);
}
}
public static void Main(string[] args)
{
Progress<int> prog = new Progress<int>(percent =>
{
Console.WriteLine("Progress: " + percent + "%");
});
DownloadAsync(prog).GetAwaiter().GetResult();
}
}
Pattern di pulizia asincrona
C# 6 non dispone di IAsyncDisposable; usi try/finally ed esegua il dispose in finally dopo il completamento del lavoro atteso.
using System;
using System.IO;
using System.Threading.Tasks;
public class Program
{
static async Task WriteThenCloseAsync(string path)
{
// C# 6 has no IAsyncDisposable; emulate with try/finally.
FileStream fs = null;
StreamWriter sw = null;
try
{
fs = new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.None);
sw = new StreamWriter(fs);
await sw.WriteAsync("hello"); // do async work
await sw.FlushAsync(); // ensure data is flushed
}
finally
{
// Dispose synchronously in finally
if (sw != null) sw.Dispose();
else if (fs != null) fs.Dispose();
}
}
public static void Main(string[] args)
{
WriteThenCloseAsync("out.txt").GetAwaiter().GetResult();
Console.WriteLine("Written");
}
}
Buone pratiche
Suggerimenti:
- Preferisca CancelAfter per i timeout semplici delle operazioni.
- Usi WhenAny per flussi di timeout personalizzati.
- Mantenga semplici i tipi usati per l'avanzamento (ad es. un intero per la percentuale o una struct semplice).
- Completi sempre gli await prima di rilasciare le risorse; inserisca il rilascio in finally.
Pattern per i timeout
Riepilogo
Riepilogo: implementi i timeout con CancelAfter o WhenAny, segnali l'avanzamento tramite IProgress<T> ed emuli il rilascio asincrono con try/finally in C# 6.
Domande Frequenti
La lezione «Timeout, IProgress<T>, disposable asincroni (emulazione)» è gratuita?
Sì — il testo completo di «Timeout, IProgress<T>, disposable asincroni (emulazione)» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso C# Academy, passa a CoddyKit PRO. Il corso C# Academy include 3 lezioni in totale.
Cosa imparerò in «Timeout, IProgress<T>, disposable asincroni (emulazione)»?
Applicate timeout con CancelAfter o basati su Task.WhenAny, collegate IProgress per aggiornamenti adatti all’interfaccia e usate try/finally per emulare la pulizia asincrona in C# 6. Eserciti C# Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare C# Academy?
Non è richiesta alcuna esperienza precedente. C# Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 3.
Quanto tempo richiede la lezione «Timeout, IProgress<T>, disposable asincroni (emulazione)»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione C# Academy?
Sì. Ogni lezione C# Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Pattern CancellationToken; annullamento cooperativo
- Timeout, IProgress , disposable asincroni (emulazione)
- Fondamenti di resilienza: retry e backoff