C# Academy · Lektion

Grundlæggende robusthed: retry og backoff

Implementér enkle retries med eksponentiel backoff og jitter, skeln mellem midlertidige og fatale fejl, begræns forsinkelser, og stop ved annullering.

Lektion 3 af 38 trin

Grundlæggende robusthed: retry og backoff er en gratis C# Academy-lektion på CoddyKit. Dette er lektion 3 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.

Hvorfor genforsøg med stigende ventetid

Mål: Gør kald robuste.

Gentag ved forbigående fejl
Brug eksponentielt stigende ventetid + tilfældig variation
Angiv et maksimalt antal forsøg og en maksimal ventetid
Stop ved alvorlige fejl eller annullering

Klassificér fejl

Forbigående: tidsgrænser, 429/5xx og midlertidige netværksproblemer.

Alvorlige: ugyldig anmodning, manglende autorisation og valideringsfejl—gentag ikke.

Regel: Gentag kun det, der kan lykkes senere.

Hjælpefunktion til stigende ventetid

En lille hjælpefunktion øger ventetiden for hvert forsøg og tilføjer en lille tilfældig variation; sæt også et loft over den maksimale ventetid.

using System;
using System.Threading;
using System.Threading.Tasks;

public static class Backoff
{
  // Compute delay = min(base * 2^attempt, cap) + jitter
  public static int ComputeDelayMs(int attempt, int baseMs, int capMs, int jitterMs, Random rng)
  {
    long exp = (long)baseMs << attempt; // base * 2^attempt
    if (exp > capMs) exp = capMs;
    int jitter = rng.Next(0, jitterMs + 1); // [0..jitterMs]
    return (int)exp + jitter;
  }
}

public class Program
{
  public static void Main(string[] args)
  {
    Random rng = new Random(123);
    for (int i = 0; i < 5; i++)
    {
      int d = Backoff.ComputeDelayMs(i, 100, 2000, 50, rng);
      Console.WriteLine("Attempt " + i + " -> " + d + " ms");
    }
  }
}

Genforsøg omkring kaldet

Omslut kaldet: gentag kun ved forbigående undtagelser, og stop ved andre. Hvert genforsøg venter længere med tilfældig variation.

using System;
using System.Threading;
using System.Threading.Tasks;

public class Program
{
  static readonly Random Rng = new Random();

  // Simulate an operation that sometimes fails transiently.
  static async Task<string> FlakyAsync()
  {
    await Task.Delay(60);
    // 50% chance of transient failure
    if (DateTime.UtcNow.Ticks % 2 == 0) throw new TimeoutException("Transient");
    return "OK";
  }

  static async Task<T> RetryAsync<T>(Func<Task<T>> action, int maxAttempts)
  {
    int baseMs = 100, capMs = 2000, jitterMs = 50;
    for (int attempt = 0; attempt < maxAttempts; attempt++)
    {
      try
      {
        return await action();
      }
      catch (TimeoutException)
      {
        if (attempt == maxAttempts - 1) throw; // out of retries
        int delay = Backoff.ComputeDelayMs(attempt, baseMs, capMs, jitterMs, Rng);
        await Task.Delay(delay);
      }
      catch (Exception)
      {
        // Non-transient (unknown) -> do not retry
        throw;
      }
    }
    throw new InvalidOperationException("Unreachable");
  }

  public static void Main(string[] args)
  {
    try
    {
      string s = RetryAsync(FlakyAsync, 5).GetAwaiter().GetResult();
      Console.WriteLine("Result: " + s);
    }
    catch (Exception ex)
    {
      Console.WriteLine("Failed: " + ex.GetType().Name);
    }
  }
}

Genforsøg med budget

Tilføj et globalt budget via annullering: videregiv tokens både til operationen og til ventetiderne mellem forsøg.

using System;
using System.Threading;
using System.Threading.Tasks;

public static class RetryUtil
{
  static readonly Random Rng = new Random();

  public static async Task<T> RetryAsync<T>(Func<CancellationToken, Task<T>> action, int maxAttempts, CancellationToken ct)
  {
    int baseMs = 100, capMs = 1500, jitterMs = 50;
    for (int attempt = 0; attempt < maxAttempts; attempt++)
    {
      ct.ThrowIfCancellationRequested();
      try
      {
        return await action(ct);
      }
      catch (TimeoutException)
      {
        if (attempt == maxAttempts - 1) throw;
        int delay = Backoff.ComputeDelayMs(attempt, baseMs, capMs, jitterMs, Rng);
        await Task.Delay(delay, ct); // pass token so we can abort waiting
      }
    }
    throw new InvalidOperationException("Unreachable");
  }
}

public class Program
{
  static async Task<string> SometimesSlowAsync(CancellationToken ct)
  {
    await Task.Delay(200, ct);
    if (DateTime.UtcNow.Millisecond % 3 != 0) throw new TimeoutException("Transient");
    return "OK";
  }

  public static void Main(string[] args)
  {
    var cts = new CancellationTokenSource();
    cts.CancelAfter(800); // overall budget

    try
    {
      string s = RetryUtil.RetryAsync(SometimesSlowAsync, 5, cts.Token).GetAwaiter().GetResult();
      Console.WriteLine("Done: " + s);
    }
    catch (OperationCanceledException) { Console.WriteLine("Canceled"); }
    catch (Exception ex) { Console.WriteLine("Failed: " + ex.Message); }
  }
}

Retningslinjer

Tip:

Gentag kun idempotente kald.
Brug lofter over antal forsøg og ventetid.
Tilføj en lille tilfældig variation for at undgå en storm af samtidige kald.
Registrér den endelige fejl med årsag og antal forsøg.

Definition af stigende ventetid

Hurtigt tjek: Hvad beskriver bedst eksponentielt stigende ventetid med tilfældig variation?

Besvar den i den interaktive lektion

Opsummering

Opsummering: Gentag kun ved forbigående fejl, øg ventetiderne eksponentielt med et loft, tilføj tilfældig variation, og stop ved annullering eller alvorlige fejl.

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 “Grundlæggende robusthed: retry og backoff” gratis?

Ja — hele teksten til “Grundlæggende robusthed: retry og backoff” 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 “Grundlæggende robusthed: retry og backoff”?

Implementér enkle retries med eksponentiel backoff og jitter, skeln mellem midlertidige og fatale fejl, begræns forsinkelser, og stop ved annullering. 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 3 af 3.

Hvor lang tid tager lektionen “Grundlæggende robusthed: retry og backoff”?

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