orden de ejecución de try catch y finalmente bloque

Question

estoy teniendo una gran confusión con el orden de intentar, atrapar y finalmente bloquear la ejecución.

También quiero saber cuándo debo usar try catch block y qué debo poner en el bloque try catch, también quiero saber si alguna excepción viene en try block, entonces si se toma una acción correspondiente a try block, entonces cuál se ejecuta primero catch o finally (que es siempre para ser ejecutado), y después de la ejecución de estas dos does controla control return to try block o lo abandona para siempre.

Answer 1

Si usted tiene (nota: esto no es válida C#, a continuación encontrará un ejemplo válido):

try { 
    // ... some code: A 
} catch(...) { 
    // ... exception code: B 
} finally { 
    // finally code: C 
} 

Código A va a ser ejecutado. Si todo va bien (es decir, no se lanzan excepciones mientras A se está ejecutando), irá a finalmente, por lo que se ejecutará el código C. Si se produce una excepción mientras que A es ejecutado, entonces irá a B y luego, finalmente, a C.

A modo de ejemplo, aquí hay un bloque C# código válido de http://msdn.microsoft.com/en-us/library/dszsf989.aspx:

public class EHClass 
{ 
    void ReadFile(int index) 
    { 
     // To run this code, substitute a valid path from your local machine 
     string path = @"c:\users\public\test.txt"; 
     System.IO.StreamReader file = new System.IO.StreamReader(path); 
     char[] buffer = new char[10]; 
     try 
     { 
      file.ReadBlock(buffer, index, buffer.Length); 
     } 
     catch (System.IO.IOException e) 
     { 
      Console.WriteLine("Error reading from {0}. Message = {1}", path, e.Message); 
     } 
     finally 
     { 
      if (file != null) 
      { 
       file.Close(); 
      } 
     } 
     // Do something with buffer... 
    } 
} 

La razón para utilizar try/catch/finally es evitar que su programa falle si hay algún error en algún código (A en el ejemplo anterior). Si hay un problema, puede usar la parte catch para detectar el problema y hacer algo útil, como informar al usuario, registrar la excepción en un archivo de registro, intentarlo de nuevo o probar algo diferente que suponga que podría funcionar en lugar de intentarlo originalmente.

finally se utiliza para garantizar que se realice una limpieza. P.ej. en A puede tratar de abrir un archivo y leerlo. Si la apertura tiene éxito, pero la lectura falla, tendrá un archivo abierto colgando. Lo que desea en ese caso es cerrarlo, lo que haría en el bloque finally - este bloque siempre se ejecuta, lo que garantiza el cierre del archivo.

Echa un vistazo aquí para obtener más información:

• http://msdn.microsoft.com/en-us/library/0yd65esw.aspx
• http://www.c-sharpcorner.com/UploadFile/puranindia/75/Default.aspx

Answer 2

Casi nunca debe usar try/catch.

Solo debe hacer catch excepciones que puede corregir, y solo cuando las está esperando. De lo contrario, permita que la persona que llama maneje la excepción, o no.

Si se usa, cualquier cláusula catch se ejecuta primero, solo una de ellas.

Luego, se ejecuta "finalmente" finally.

---

Esto se ha expresado mejor en muchos lugares, pero lo intentaré. El siguiente código:

try 
{ 
    // Do something here 
} 
catch (Exception ex) 
{ 
    MessageBox.Show("Friendly error message"); 
} 

no repara la excepción. Oculta la excepción para que el problema nunca se solucione. Ese código no tiene idea de qué excepción fue lanzada, porque las detectará todas, y no hace nada para corregir el problema, simplemente le dice al usuario una ficción educada.

El quid de la cuestión es que el código anterior debe ser sustituido por el siguiente:

// Do something here 

esta manera, si la persona que llama de este método sabe cómo solucionar problemas particulares, entonces la persona que llama puede solucionarlos . No habrá eliminado esa opción de la persona que llama.

Si la persona que llama no sabe cómo solucionar el problema, la persona que llama tampoco debería detectar la excepción.

---

Aquí hay un ejemplo (de MSDN) sobre el uso razonable de excepciones. Es una forma modificada del ejemplo en la documentación del SmtpFailedRecipientsException Class.

public static void RetryIfBusy(string server) 
{ 
    MailAddress from = new MailAddress("ben@contoso.com"); 
    MailAddress to = new MailAddress("jane@contoso.com"); 
    using (
     MailMessage message = new MailMessage(from, to) 
            { 
             Subject = "Using the SmtpClient class.", 
             Body = 
              @"Using this feature, you can send an e-mail message from an application very easily." 
            }) 
    { 
     message.CC.Add(new MailAddress("Notifications@contoso.com")); 
     using (SmtpClient client = new SmtpClient(server) {Credentials = CredentialCache.DefaultNetworkCredentials}) 
     { 
      Console.WriteLine("Sending an e-mail message to {0} using the SMTP host {1}.", to.Address, client.Host); 
      try 
      { 
       client.Send(message); 
      } 
      catch (SmtpFailedRecipientsException ex) 
      { 
       foreach (var t in ex.InnerExceptions) 
       { 
        var status = t.StatusCode; 
        if (status == SmtpStatusCode.MailboxBusy || status == SmtpStatusCode.MailboxUnavailable) 
        { 
         Console.WriteLine("Delivery failed - retrying in 5 seconds."); 
         System.Threading.Thread.Sleep(5000); // Use better retry logic than this! 
         client.Send(message); 
        } 
        else 
        { 
         Console.WriteLine("Failed to deliver message to {0}", t.FailedRecipient); 
          // Do something better to log the exception 
        } 
       } 
      } 
      catch (SmtpException ex) 
      { 
       // Here, if you know what to do about particular SMTP status codes, 
       // you can look in ex.StatusCode to decide how to handle this exception 
       // Otherwise, in here, you at least know there was an email problem 
      } 
      // Note that no other, less specific exceptions are caught here, since we don't know 
      // what do do about them 
     } 
    } 
} 

Tenga en cuenta que este código utiliza try/catch para rodear un pequeño fragmento de código. Dentro de ese bloque try/catch, si se lanza una excepción SmtpException o SmtpFailedRecipientsException, sabemos qué hacer al respecto. Si, por ejemplo, tuviéramos que atrapar IOException, no sabríamos lo que significaba o qué hacer al respecto. Cualquier excepción que no sepas cómo corregir no se debe capturar, excepto tal vez para agregar información a la excepción, registrarla y volver a lanzar.

Answer 3

Un bloque try ... catch se usa para detectar excepciones. En el bloque try, coloque el código que espera que pueda generar una excepción.

Si no se produce una excepción, el código en el bloque try finaliza como se esperaba. Si hay un bloque finally, se ejecutará a continuación.

Si se produce una excepción, la ejecución salta al inicio del primer bloque coincidente catch. Una vez que se completa ese código, se ejecuta el bloque finally (si existe). La ejecución no vuelve al bloque try.

Answer 4

Aquí se muestra un ejemplo:

try 
{ 
    someFunctionThatWorks(); 

    functionThatThrowsAnException(); // As soon as this function throws an exception we are taken to the catch block 

    anotherFunction(); // <-- This line will never get executed 
} 
catch(Exception e) 
{ 
    // Here you can handle the exception, if you don't know how to handle it you should not be catching it 
    // After this you will not be taken back to the try block, you will go right to the finally block 
} 
finally 
{ 
    // Code here is always executed at the very end, regardless of whether an exception was thrown or not 
}