Mejor manera de escribir la lógica de reintento sin ir a

Question

¿Existe alguna forma mejor de escribir este código sin usar goto? Parece incómodo, pero no puedo pensar en una mejor manera. Necesito poder realizar un intento de reintento, pero no quiero duplicar ningún código.

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

Aquí es la lógica básica que iba a utilizar en lugar de una instrucción 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); 

acabo # agregado de la lógica intentos, a pesar de que la pregunta original no tenía ninguna.

Answer 2

¿Qué pasa si lo pones en un bucle? Algo similar a esto, tal vez.

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

Answer 3

intentar algo así como lo siguiente: solución

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

de Michael no acaba de cumplir los requisitos, que son para volver a intentar un número fijo de veces, lanzando el último fracaso.

Para esto, recomendaría un simple bucle, contando hacia abajo. Si tiene éxito, salga con un descanso (o, si es conveniente, regrese). De lo contrario, deje que la captura revise si el índice está abajo a 0. Si es así, vuelva a lanzar en lugar de iniciar sesión o ignorar.

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

En el ejemplo anterior, un retorno habría estado bien, pero quería mostrar el caso general.

Answer 6

@Michael's answer (con un bloque de captura correctamente implementado) es probablemente el más fácil de usar en su caso, y es el más simple. Sin embargo, en el interés de presentar alternativas, aquí es una versión de que factores del control de flujo "reintentar" en un método separado:

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

Se podría, por supuesto, mejorar esto con cosas como el recuento de reintento, una mejor propagación de errores, y así.

Answer 7

con un valor lógico

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