Wiederholen Sie die Anforderung, wenn die erste fehlgeschlagen ist

Question

Ich verwende einen XML-Webdienst in meiner Webanwendung, und manchmal antwortet der Remoteserver nicht rechtzeitig. Ich kam auf die Idee einer erneuten Anfrage, wenn der erste Versuch fehlschlägt. Um eine Schleife zu vermeiden, möchte ich die gleichzeitige Anfrage auf 2 beschränken. Ich möchte eine Meinung erhalten, wenn das, was ich unten getan habe, in Ordnung ist und funktionieren würde, wie ich es erwarte.

public class ScEngine 
{ 
    private int _attemptcount = 0; 
    public int attemptcount 
    { 
     get 
     { 
      return _attemptcount; 
     } 
     set 
     { 
      _attemptcount = value; 
     } 
    } 

    public DataSet GetStat(string q, string job) 
    { 

     try 
     { 
      //snip.... 
      attemptcount += attemptcount; 
      return ds; 

     } 
     catch 
     { 
      if (attemptcount>=2) 
      { 
      return null; 
      } 
      else 
      { 
       return GetStat(q, job); 
      } 

     } 

    } 
} 

Answer 1

public class ScEngine 
{ 
    public DataSet GetStat(string q, string job) 
    { 
     int attemptCount; 
     while(attemptCount < 2) 
     { 
      try 
      { 
       attemptCount++; 
       var ds = ...//web service call 
       return ds; 
      } 
      catch {} 
     } 
     //log the error 
     return null; 
    } 
} 

Answer 2

Sie haben vergessen, die Anzahl der Versuche zu erhöhen. Wenn beim zweiten Durchlauf ein Fehler auftritt, wird dieser nicht abgefangen (wird also zu einer nicht behandelten Ausnahme).

Answer 3

Ich würde nicht rekrutieren, um es erneut zu versuchen. Außerdem würde ich nicht alle Ausnahmen erfassen und ignorieren. Ich würde erfahren, welche Ausnahmen auf einen Fehler hinweisen, der erneut versucht werden sollte, und würde diese abfangen. Sie werden schwerwiegende Fehler ignorieren, wie Ihr Code steht.

Answer 4

Sie wollen es nicht auf diese Weise lösen. Sie werden die Server mehr belasten und mehr Timeouts verursachen.

Sie können das Zeitlimit für den Webdienst erhöhen via httpRuntime. Web-Services geben in der Regel viele Daten in einem Aufruf zurück, daher mache ich das ziemlich häufig. Vergessen Sie nicht zu erhöhen, wie lange der Client auf der Client-Seite wartet.

Answer 5

Hier ist eine Version, die keine Rekursion verwendet, aber das gleiche Ergebnis erzielt. Es enthält auch eine Verzögerung, so dass Sie dem Server Zeit geben können, um sich zu erholen, wenn es schluckt.

/// <summary> 
    /// The maximum amount of attempts to use before giving up on an update, delete or create 
    /// </summary> 
    private const int MAX_ATTEMPTS = 2; 

    /// <summary> 
    /// Attempts to execute the specified delegate with the specified arguments. 
    /// </summary> 
    /// <param name="operation">The operation to attempt.</param> 
    /// <param name="arguments">The arguments to provide to the operation.</param> 
    /// <returns>The result of the operation if there are any.</returns> 
    public static object attemptOperation(Delegate operation, params object[] arguments) 
    { 
     //attempt the operation using the default max attempts 
     return attemptOperation(MAX_ATTEMPTS, operation, arguments); 
    } 

    /// <summary> 
    /// Use for creating a random delay between retry attempts. 
    /// </summary> 
    private static Random random = new Random(); 

    /// <summary> 
    /// Attempts to execute the specified delegate with the specified arguments. 
    /// </summary> 
    /// <param name="operation">The operation to attempt.</param> 
    /// <param name="arguments">The arguments to provide to the operation.</param> 
    /// <param name="maxAttempts">The number of times to attempt the operation before giving up.</param> 
    /// <returns>The result of the operation if there are any.</returns> 
    public static object attemptOperation(int maxAttempts, Delegate operation, params object [] arguments) 
    { 
     //set our initial attempt count 
     int attemptCount = 1; 

     //set the default result 
     object result = null; 

     //we've not succeeded yet 
     bool success = false; 

     //keep trying until we get a result 
     while (success == false) 
     { 
      try 
      { 
       //attempt the operation and get the result 
       result = operation.DynamicInvoke(arguments); 
       //we succeeded if there wasn't an exception 
       success = true; 
      } 
      catch 
      { 
       //if we've got to the max attempts and still have an error, give up an rethrow it 
       if (attemptCount++ == maxAttempts) 
       { 
        //propogate the exception 
        throw; 
       } 
       else 
       { 
        //create a random delay in milliseconds 
        int randomDelayMilliseconds = random.Next(1000, 5000); 
        //sleep for the specified amount of milliseconds 
        System.Threading.Thread.Sleep(randomDelayMilliseconds); 
       } 
      } 
     } 

     //return the result 
     return result; 
    } 

Answer 6

Überprüfen Sie diesen Link. Es ist eine gute Möglichkeit, Wiederholungen und Timeouts zu behandeln. http://timross.wordpress.com/2008/02/10/implementing-the-circuit-breaker-pattern-in-c/