C# Academy · Lektion

Timeouts, IProgress<T> og asynkrone disposables (emulering)

Brug CancelAfter eller timeouts baseret på Task.WhenAny, forbind IProgress til UI-venlige opdateringer, og brug try/finally til at emulere asynkron oprydning i C# 6.

Lektion 2 af 38 trin

Timeouts, IProgress<T> og asynkrone disposables (emulering) er en gratis C# Academy-lektion på CoddyKit. Dette er lektion 2 af 3. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i C# Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. C# Academy-kurset indeholder 3 lektioner i alt.

Plan

Formål:

Sæt en tidsgrænse med CancelAfter
Sæt en tidsgrænse via Task.WhenAny
Rapportér fremskridt med IProgress<T>
Asynkront oprydningsmønster i C# 6 (try/finally)

Tidsgrænse med CancelAfter

Brug CancelAfter, og videregiv tokenet til det asynkrone API; den kaldte metode stopper samarbejdende, når tidsgrænsen nås.

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");
    }
  }
}

Tidsgrænse via WhenAny

Task.WhenAny lader arbejdet konkurrere mod Task.Delay; hvis forsinkelsen vinder, kastes en 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);
    }
  }
}

IProgress<T>-demonstration

IProgress<T> adskiller arbejdet fra brugergrænsefladen; producenter kalder Report, og forbrugere opdaterer brugergrænsefladen og tråden sikkert.

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();
  }
}

Asynkront oprydningsmønster

C# 6 mangler IAsyncDisposable; brug try/finally, og ryd op i finally, når det ventede arbejde er fuldført.

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");
  }
}

Bedste praksis

Tip:

Foretræk CancelAfter til simple tidsgrænser for operationer.
Brug WhenAny til brugerdefinerede forløb med tidsgrænser.
Hold typer til fremskridt små (f.eks. et heltal for procent eller en simpel struct).
Afslut altid ventninger, før du frigiver ressourcer; placér frigivelsen i finally.

Mønster for tidsgrænse

Hurtigt tjek: Hvad er en enkel måde at tilføje en tidsgrænse til en asynkron operation i C# 6 uden at blokere?

Besvar den i den interaktive lektion

Opsummering

Opsummering: Implementér tidsgrænser med CancelAfter eller WhenAny, rapportér fremskridt via IProgress<T>, og efterlign asynkron frigivelse med try/finally i C# 6.

Gratis at komme i gang

Lær C# med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 93
Lektioner: 346

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Timeouts, IProgress<T> og asynkrone disposables (emulering)” gratis?

Ja — hele teksten til “Timeouts, IProgress<T> og asynkrone disposables (emulering)” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af C# Academy-kurset, skal du opgradere til CoddyKit PRO. C# Academy-kurset indeholder 3 lektioner i alt.

Hvad lærer jeg i “Timeouts, IProgress<T> og asynkrone disposables (emulering)”?

Brug CancelAfter eller timeouts baseret på Task.WhenAny, forbind IProgress til UI-venlige opdateringer, og brug try/finally til at emulere asynkron oprydning i C# 6. Du øver dig i C# Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på C# Academy?

Der kræves ingen tidligere erfaring. C# Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 2 af 3.

Hvor lang tid tager lektionen “Timeouts, IProgress<T> og asynkrone disposables (emulering)”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne C# Academy-lektion?

Ja. Alle C# Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

CancellationToken-mønstre og kooperativ annullering
Timeouts, IProgress og asynkrone disposables (emulering)
Grundlæggende robusthed: retry og backoff

← Tilbage til C# Academy