Come implementare di nuovo n volte in caso di eccezione in C#?

Question

Sto sviluppando un'applicazione WPF 4.0 in cui otteniamo i dati da un servizio Web remoto. Il servizio web espone circa 120 metodi ai suoi clienti. Se una chiamata al servizio web dalla mia applicazione WPF fallisce, ho bisogno di riprovare n volte che è configurabile tramite App.Config. Come implementarlo? Ci sono schemi di progettazione che affrontano questo problema?

Answer 1

static T TryNTimes<T>(Func<T> func, int times) 
{ 
    while (times>0) 
    { 
    try 
    { 
     return func(); 
    } 
    catch(Exception e) 
    { 
     if (--times <= 0) 
      throw; 
    } 

    } 
} 

Answer 2

Ho scritto questo codice non molto tempo fa per fare qualcosa di simile a quello che vuoi. Può essere modificato per adattarsi alle tue esigenze. È un metodo di attesa generico. Passare una funzione e se il risultato atteso non viene restituito, attendere quindi riprovare e uscire dopo il numero X di tentativi.

/// <summary> 
    /// Wait for the result of func to return the expeceted result 
    /// </summary> 
    /// <param name="func">Function to execute each cycle</param> 
    /// <param name="result">Desired result returned by func</param> 
    /// <param name="waitInterval">How long to wait (ms) per cycle </param> 
    /// <param name="cycles">How many times to execute func before failing</param> 
    /// <returns>True if desired result was attained. False if specified time runs out before desired result is returned by func</returns> 
    protected static bool WaitForEvent(Func<bool> func, bool result, int waitInterval, int cycles) 
    { 
     int waitCount = 0; 
     while (func() != result) 
     { 
      if (waitCount++ < cycles) 
      { 
       Thread.Sleep(waitInterval); 
      } 
      else 
      { 
       return false; 
      } 
     } 

     return true; 

    } 

Answer 3

while(retries < maxTries) 
    try 
    { 
     //retryable code here 
     break; 
    } 
    catch(Exception ex) 
    { 
     if(++retries == maxTries) 
     throw; 
     continue; 
    } 

Certamente niente di particolare, ma sarà ottenere il lavoro fatto. Il modello principale, che sarebbe comune a quasi tutte le implementazioni, è un costrutto di loop che contiene e in qualche modo controllato da un try-catch; che può essere una chiamata ricorsiva o un loop iterativo come il ciclo while sopra. Assicurati di uscire correttamente dal ciclo dopo un tentativo riuscito e tieni traccia dei tentativi; l'incapacità di fare causa causerà un ciclo infinito.

Answer 4

while(true) 
{ 

try 
{ 
Method(); 
break; 
} 
catch(Exception ex) 
{ 
i++; 
if(i == n) throw ex; 
} 

} 

Answer 5

Ecco un codice simile che avvolge IO violazione di condivisione. E 'la stessa idea: abbiamo un delegato e un metodo statico involucro:

/// <summary> 
/// Defines a sharing violation wrapper delegate. 
/// </summary> 
public delegate void WrapSharingViolationsCallback(); 

/// <summary> 
/// Wraps sharing violations that could occur on a file IO operation. 
/// </summary> 
/// <param name="action">The action to execute. May not be null.</param> 
/// <param name="exceptionsCallback">The exceptions callback. May be null.</param> 
/// <param name="retryCount">The retry count.</param> 
/// <param name="waitTime">The wait time in milliseconds.</param> 
public static void WrapSharingViolations(WrapSharingViolationsCallback action, WrapSharingViolationsExceptionsCallback exceptionsCallback, int retryCount, int waitTime) 
{ 
    if (action == null) 
     throw new ArgumentNullException("action"); 

    for (int i = 0; i < retryCount; i++) 
    { 
     try 
     { 
      action(); 
      return; 
     } 
     catch (IOException ioe) 
     { 
      if ((IsSharingViolation(ioe)) && (i < (retryCount - 1))) 
      { 
       bool wait = true; 
       if (exceptionsCallback != null) 
       { 
        wait = exceptionsCallback(ioe, i, retryCount, waitTime); 
       } 
       if (wait) 
       { 
        Thread.Sleep(waitTime); 
       } 
      } 
      else 
      { 
       throw; 
      } 
     } 
    } 
} 

E poi, noi lo chiamiamo in questo modo (si adatta espressione lambda perfettamente qui):

WrapSharingViolations(() => DoWhatever(...)); 

Answer 6

è possibile utilizzare una funzionalità approccio a questo:

class Program 
{ 
    static T Retry<T, TException>(Func<T> thingToTry, int timesToRetry) 
     where TException : Exception 
    { 
     // Start at 1 instead of 0 to allow for final attempt 
     for (int i = 1; i < timesToRetry; i++) 
     { 
      try 
      { 
       return thingToTry(); 
      } 
      catch (TException) 
      { 
       // Maybe: Trace.WriteLine("Failed attempt..."); 
      } 
     } 

     return thingToTry(); // Final attempt, let exception bubble up 
    } 

    static int ServiceCall() 
    { 
     if (DateTime.Now.Ticks % 2 == 0) 
     { 
      throw new InvalidOperationException("Randomly not working"); 
     } 

     return DateTime.Now.Second; 
    } 

    static void Main() 
    { 
     int s = Retry<int, InvalidOperationException>(ServiceCall, 10); 
    } 
} 

È possibile utilizzarlo per rilevare eccezioni specifiche (aggiungere ulteriori parametri generici TException se necessario).

Answer 7

Potreste essere in grado di fare questo con un GOTO(gasp)

int count = 0; 
try 
{ 
    TryAgain: 
    // Do something with your web service 
} 
catch(Exception e) 
{ 
    if(count < numberOfAttemptsAllowed) 
    { 
     count++; 
     goto TryAgain; 
    } 
} 

Sono sicuro che ci potrebbe essere un modo migliore, ma questo potrebbe fare quello che ti serve.