Excepción de captura dentro Uso de la instrucción

Question

Sé que la declaración Using elimina el objeto que se está creando. Al igual que si lo que quería hacer algo como esto:

Using(SqlConnection conn = new SqlConnection(connString)) 
    { 
     //some code 
     //How to show the users if conn is not opened up or generated some kind of error? 
    } 

Cómo los usuarios si conn no se abre o se generan algún tipo de error mostrar?

Answer 1

using no ofrece ninguna puerta trasera en el catch.

Simplemente se expanden de forma manual (hay razón para tener el try/catch dentro del uso de la OMI):

SqlConnection conn = null; 

try 
{ 
    conn = new SqlConnection(""); 
} 
catch ... 
{ 

} 
finally 
{ 
    if (conn != null) 
     conn.Dispose(); 
} 

estoy a favor de esto una envolviendo el using en un try-catch e incorporación de un try-catch en el using la mayor parte del Es hora de evitar que el código termine con un try-catch anidado una vez compilado. Sin embargo, si solo necesitas cubrir un subconjunto muy pequeño de un código grande dentro de un using, sería más granular y lo insertaré.

Answer 2

No hay nada especial sobre el código escrito dentro de un bloque using - sólo tiene que utilizar un try.catch para manejar excepciones:

using(SqlConnection conn = new SqlConnection(connString)) 
{ 
    try 
    { 
     conn.Open(); 
     // do more stuff here...... 

    } 
    catch(SqlException sqlEx) 
    { 
     // log error and possibly show to user in a MessageBox or something else 
    } 
} 

El bloque using(...) { ... } en sí está diseñado única para asegurar que el recurso/objeto que "encapsulados" se desecha adecuadamente cuando ya no se necesita. No hay nada que pueda hacer con la declaración using para que se encargue de los errores.

así que si esperas que se acaba de crear el objeto podría fallar, entonces usted tendría que poner todo el bloque using dentro del bloque try ... catch, o caer de nuevo a un bloque try ... catch ... finally y eliminación adecuada a sí mismo (como Adam sugirió en su responder).

Answer 3

Eso es exactamente lo que haría sin él.

using(SqlConnection conn = new SqlConnection(connString)) 
{ 
    try{ 
    //some code 
    } 
    catch(SqlException e) 
    MessageBox.Show(e.Message); 
} 

Answer 4

sólo de la forma habitual:

De cualquier

try 
{ 
    using(SqlConnection conn = new SqlConnection(connString)) 
    { 
     //some code   
    } 
} 
catch (Exception exc) 
{ 
    //handle error 
} 

o

using(SqlConnection conn = new SqlConnection(connString)) 
{ 
    try 
    { 
     //some code 
    } 
    catch (Exception exc) 
    { 
     //handle error 
    }     
} 

Answer 5

Usted no lo hacen en el interior del using

try 
{ 
    using(SqlConnection conn = new SqlConnection(connString)) 
    { 
     // Some code for when "conn" is succesfully instantiated 
    } 
} 
catch (SomeSpecificConnectionInstantiationException ex) 
{ 
    // Use ex to handle a bizarre instantiation exception? 
}  

Answer 6

class SqlConnection 
{ 
    using(sqlConnection) 
    { 

    } 
} 

class Consumer 
{ 
    try 
    { 

    } 
    catch(SqlException) 
    { 

    } 

} 

Depende del consumidor de la clase decidir qué hacer con la excepción.

Answer 7

Como han indicado otras respuestas, solo agregue un try/catch normal.

Sin embargo, me gustaría añadir que este es el mal lugar para poner ese try/catch, especialmente si su objetivo es un mensaje "a los usuarios mostrar". Deje que la excepción ocurra en este nivel y permita que suba la pila al código que está en una mejor posición para saber cómo responder.

En otras palabras, deje su muestra de código tal como está. No agregue nada nuevo ... a ese método. Pero quizás el código que llama a este método debería estar pensando en cómo manejar una excepción ... cualquier excepción ... desde la base de datos.

Answer 8

Es una buena práctica usar try {} catch() {} dentro de la sentencia using si desea capturar una excepción lanzada por el código dentro del bloque using. Ahora, considere los siguientes dos ejemplos: eso explica por qué try-catch block dentro de la sentencia using es una buena práctica.

Ejemplo 1

 try{ 
      using(SomeObject so = new SomeObject){ 
       // Perform some tasks 
      } 
     }catch(SomeException objSomeException){ 
      // Perform some actions, if exception occurs 
     } 

Ejemplo 2

 using(SomeObject so = new SomeObject){ 
      try{  
       // Perform some tasks 
       }catch(SomeException objSomeException){ 
        // Perform some actions, if exception occurs 
       } 
     } 

Ahora, si se produce una excepción en el desempeño de algunas tareas dentro de la instrucción using, será tanto ejemplo tener la mismos resultados. La respuesta simple es no, ¿razón?

Cuando se produce una excepción en el ejemplo 1, es atrapada por el bloque de captura, sin llegar al final del bloque de uso. Por lo tanto, el someObject en el ejemplo 1 no se eliminará correctamente. Incluso si CLR es generoso (con lo que no debe contar), la memoria utilizada por someObject en el ejemplo 1 no se recuperará (o como máximo, terminará en la recolección de GC de la Generación 2).

Donde en el caso del ejemplo 2, el bloque catch está dentro de la sentencia using. Eso significa que la ejecución llegará al final del bloque de uso. Por lo tanto, su objeto será eliminado y no tendrá que preocuparse por la fuga de memoria (deterioro,

Answer 9

Cuando incrusta el bloque using() dentro de un try/catch, el bloque using() garantizará que Dispose se llama. Sin embargo, si el código no administrado en cualquier lugar dentro de su bloque de uso arroja una excepción, el uso de() se lo comerá y no alcanzará su captura. Use try/catch dentro del bloque using(), omita el uso de() y haz una prueba/captura/finalmente, o usa la extraña sintaxis "using() try" con un catch block (que te deja con un número impar de corchetes y es probable que confunda a los programadores de nivel medio que luego se encontrarán