0Pricing
C# Academy · Lektion

Timeouts, IProgress<T> und asynchrone Disposables (Emulation)

Verwenden Sie CancelAfter- oder auf Task.WhenAny basierende Timeouts, binden Sie IProgress für UI-freundliche Aktualisierungen ein und emulieren Sie asynchrone Bereinigung in C# 6 mit try/finally.

Timeouts, IProgress<T> und asynchrone Disposables (Emulation) ist eine kostenlose C# Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 3. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C# Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C# Academy-Kurs umfasst insgesamt 3 Lektionen.

Plan

Ziel:

  • Timeouts mit CancelAfter
  • Timeouts über Task.WhenAny
  • Fortschritt mit IProgress<T>
  • Asynchrones Bereinigungsmuster in C# 6 (try/finally)

Timeout über CancelAfter

Verwenden Sie CancelAfter und reichen Sie das Token an die asynchrone API weiter; die aufgerufene Methode wird bei einem Timeout kooperativ beendet.

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 über WhenAny

Mit Task.WhenAny treten die Arbeit und Task.Delay gegeneinander an; gewinnt die Verzögerung, lösen Sie eine TimeoutException aus.

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>-Demo

IProgress<T> entkoppelt die Arbeit von der Benutzeroberfläche; Produzenten rufen Report auf, Konsumenten aktualisieren die Benutzeroberfläche threadsicher.

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

Asynchrones Bereinigungsmuster

IAsyncDisposable ist in C# 6 nicht verfügbar; verwenden Sie try/finally und geben Sie Ressourcen in finally frei, nachdem die erwartete Arbeit abgeschlossen ist.

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

Bewährte Vorgehensweisen

Tipps:

  • Bevorzugen Sie CancelAfter für einfache Timeouts von Vorgängen.
  • Verwenden Sie WhenAny für benutzerdefinierte Timeout-Abläufe.
  • Halten Sie Fortschrittstypen klein (z. B. eine Prozentzahl vom Typ int oder eine einfache Struktur).
  • Warten Sie immer, bis alle await-Aufrufe abgeschlossen sind, bevor Sie Ressourcen freigeben; führen Sie die Freigabe in finally durch.

Timeout-Muster

Schnelltest: Wie lässt sich in C# 6 auf einfache Weise ein Timeout für einen asynchronen Vorgang hinzufügen, ohne zu blockieren?

Zusammenfassung

Zusammenfassung: Implementieren Sie Timeouts mit CancelAfter oder WhenAny, melden Sie Fortschritt über IProgress<T> und simulieren Sie asynchrone Ressourcenfreigabe mit try/finally in C# 6.

Häufig gestellte Fragen

Ist die Lektion „Timeouts, IProgress<T> und asynchrone Disposables (Emulation)“ kostenlos?

Ja — der vollständige Text von „Timeouts, IProgress<T> und asynchrone Disposables (Emulation)“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C# Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C# Academy-Kurs umfasst insgesamt 3 Lektionen.

Was lerne ich in „Timeouts, IProgress<T> und asynchrone Disposables (Emulation)“?

Verwenden Sie CancelAfter- oder auf Task.WhenAny basierende Timeouts, binden Sie IProgress für UI-freundliche Aktualisierungen ein und emulieren Sie asynchrone Bereinigung in C# 6 mit try/finally. Du übst C# Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um C# Academy zu starten?

Keine Vorkenntnisse erforderlich. C# Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 3.

Wie lange dauert die Lektion „Timeouts, IProgress<T> und asynchrone Disposables (Emulation)“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser C# Academy-Lektion Code schreiben und ausführen?

Ja. Jede C# Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. CancellationToken-Muster und kooperative Abbrüche
  2. Timeouts, IProgress und asynchrone Disposables (Emulation)
  3. Grundlagen der Resilienz: Wiederholungen und Backoff
← Zurück zu C# Academy