Cách tốt hơn để viết lại logic mà không cần goto

Question

Có cách nào tốt hơn để viết mã này mà không sử dụng goto không? Nó có vẻ khó xử, nhưng tôi không thể nghĩ ra một cách tốt hơn. Tôi cần để có thể thực hiện một lần thử lại, nhưng tôi không muốn sao chép bất kỳ mã nào.

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

Đây là logic cơ bản mà tôi sẽ sử dụng thay vì một lệnh 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); 

Tôi chỉ cần thêm # của cố gắng logic, mặc dù câu hỏi ban đầu đã không có bất kỳ.

Answer 2

Nếu bạn đặt nó trong vòng lặp thì sao? Một cái gì đó tương tự như thế này, có thể.

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

Answer 3

Hãy thử một cái gì đó như sau: giải pháp

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

Michael không hoàn toàn đáp ứng các yêu cầu, mà là để thử lại một số cố định của thời gian, ném sự thất bại cuối cùng.

Đối với điều này, tôi muốn giới thiệu một vòng lặp đơn giản, đếm ngược. Nếu bạn thành công, thoát ra với break (hoặc, nếu thuận tiện, trả lại). Nếu không, hãy kiểm tra đánh bắt để xem liệu chỉ mục có giảm xuống 0 hay không. Nếu có, hãy thay đổi lại thay vì ghi nhật ký hoặc bỏ qua.

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

Trong ví dụ trên, sự trở lại sẽ ổn nhưng tôi muốn hiển thị trường hợp chung.

Answer 6

@Michael's answer (với khối bắt đầu được triển khai chính xác) có thể dễ sử dụng nhất trong trường hợp của bạn và là đơn giản nhất. Nhưng vì lợi ích của trình bày giải pháp thay thế, đây là một phiên bản mà các yếu tố là "thử" kiểm soát dòng chảy vào một phương pháp riêng biệt:

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

Bạn có thể, tất nhiên, cải thiện điều này với những thứ như đếm thử lại, tuyên truyền lỗi tốt hơn, và vân vân.

Answer 7

với một boolean

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