Un modo migliore per scrivere la logica riprova senza goto

Question

C'è un modo migliore per scrivere questo codice senza utilizzare goto? Sembra imbarazzante, ma non riesco a pensare a un modo migliore. Devo essere in grado di eseguire un tentativo, ma non voglio duplicare alcun codice.

public void Write(string body) 
{ 
    bool retry = false; 
RetryPoint: 
    try 
    { 
     m_Outputfile.Write(body); 
     m_Outputfile.Flush(); 
    } 
    catch (Exception) 
    { 
     if(retry) 
      throw; 
     // try to re-open the file... 
     m_Outputfile = new StreamWriter(m_Filepath, true); 
     retry = true; 
     goto RetryPoint; 
    } 
} 

Answer 1

Ecco la logica di base che avrei usato al posto di un goto:

bool succeeded = false; 
int tries = 2; 

do 
{ 
    try 
    { 
     m_Outputfile = new StreamWriter(m_Filepath, true); 
     m_Outputfile.Write(body); 
     m_Outputfile.Flush(); 
     succeeded = true; 
    } 
    catch(Exception) 
    { 
     tries--; 
    } 
} 
while (!succeeded && tries > 0); 

Ho appena # aggiunto della logica tentativi, anche se la domanda iniziale non ha avuto alcun.

Answer 2

Cosa succede se lo metti in loop? Qualcosa di simile a questo, forse.

while(tryToOpenFile) 
{ 
    try 
    { 
     //some code 
    } 
    catch 
    { 
    } 
    finally 
    { 
     //set tryToOpenFile to false when you need to break 
    } 
} 

Answer 3

provare qualcosa di simile al seguente: Soluzione

int tryCount = 0; 
bool succeeded = false; 

while(!succeeded && tryCount<2){ 
    tryCount++; 
    try{ 
     //interesting stuff here that may fail. 

     succeeded=true; 
    } catch { 
    } 
} 

Answer 4

public void Write(string body, bool retryOnError) 
{ 
    try 
    { 
     m_Outputfile.Write(body); 
     m_Outputfile.Flush(); 
    } 
    catch (Exception) 
    { 
     if(!retryOnError) 
      throw; 
     // try to re-open the file... 
     m_Outputfile = new StreamWriter(m_Filepath, true); 
     Write(body, false); 
    } 
} 

Answer 5

di Michael non abbastanza soddisfano i requisiti, che sono per ritentare un numero fisso di volte, gettando l'ultimo fallimento.

Per questo, vorrei raccomandare un ciclo semplice per il conto alla rovescia. Se ci riesci, esci con pausa (o, se conveniente, ritorna). Altrimenti, lasciare il controllo catch per vedere se l'indice è inferiore a 0. In tal caso, rilancia invece di registrare o ignorare.

public void Write(string body, bool retryOnError) 
{ 
    for (int tries = MaxRetries; tries >= 0; tries--) 
    { 
     try 
     { 
      _outputfile.Write(body); 
      _outputfile.Flush(); 
      break; 
     } 
     catch (Exception) 
     { 
      if (tries == 0) 
       throw; 

      _outputfile.Close(); 
      _outputfile = new StreamWriter(_filepath, true); 
     } 
    } 
} 

Nell'esempio sopra, un reso sarebbe andato bene, ma volevo mostrare il caso generale.

Answer 6

@Michael's answer (con un blocco catch correttamente implementato) è probabilmente il più semplice da utilizzare nel tuo caso ed è il più semplice. Ma nell'interesse di presentare alternative, qui è una versione che i fattori di controllo di flusso "riprovare" in un metodo separato:

// define a flow control method that performs an action, with an optional retry 
public static void WithRetry(Action action, Action recovery) 
{ 
    try { 
     action(); 
    } 
    catch (Exception) { 
     recovery(); 
     action(); 
    } 
} 

public void Send(string body) 
{ 
    WithRetry(() => 
    // action logic: 
    { 
     m_Outputfile.Write(body); 
     m_Outputfile.Flush(); 
    }, 
    // retry logic: 
    () => 
    { 
     m_Outputfile = new StreamWriter(m_Filepath, true); 
    }); 
} 

Si potrebbe, naturalmente, migliorare questo con le cose come i conteggi tentativi, una migliore propagazione degli errori, e così via.

Answer 7

con un valore booleano

public void Write(string body) 
{ 
     bool NotFailedOnce = true;    
     while (true) 
     { 
      try 
      { 
       _outputfile.Write(body); 
       _outputfile.Flush();   
       return;      
      } 
      catch (Exception) 
      { 
       NotFailedOnce = !NotFailedOnce; 
       if (NotFailedOnce) 
       { 
        throw; 
       } 
       else 
       { 
        m_Outputfile = new StreamWriter(m_Filepath, true); 
       } 
      } 
     }   
}