lanzar - propiedad tag c#

Cogiendo la excepción dentro de la declaración

Question

Sé que el Using sentencia elimina el objeto que se está creando. Como si quisiera 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 mostrar a los usuarios si conn no se abre o genera algún tipo de error?

Answer 1

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

Sin embargo, agregaría que este es el lugar equivocado para poner ese try / catch, especialmente si su objetivo es "mostrar a los usuarios" un mensaje. Deje que ocurra la excepción en este nivel, y permita que la pila se acumule para codificar que está en una mejor posición para saber cómo responder a ella.

En otras palabras, deje su código de muestra 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 ... de la base de datos.

Answer 2

Cuando incrusta el bloque using () dentro de un try / catch, el bloque using () garantizará que se llame Dispose. Sin embargo, si el código no administrado en cualquier lugar dentro de su bloque de uso lanza una excepción, el uso de () simplemente se lo comerá y no alcanzará su alcance. Use try / catch dentro del bloque using (), salte usando () y haga un try / catch / finally, o use la sintaxis impar "using () try" con un bloque catch (que lo deja con un número impar de corchetes y es probable que se confunda a los programadores de nivel medio que luego lo encuentran.

Answer 3

Es de la misma manera que lo harías sin él.

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

Answer 4

Es una buena práctica usar try {} catch () {} dentro de la declaración de uso si desea detectar una excepción lanzada por el código dentro del bloque de uso. Ahora, considere los siguientes dos ejemplos: eso explica por qué el bloque try-catch dentro de la declaración de uso 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 al realizar algunas tareas dentro de la instrucción using, ambos ejemplos tendrán los mismos resultados. La respuesta simple es no, ¿por qué?

Cuando ocurre una excepción en el ejemplo 1, es atrapada por el bloque catch, sin llegar al final del bloque de uso. Por lo tanto, el objeto de algunos en el ejemplo 1 no se eliminará correctamente. Incluso si CLR es generoso (con lo que no debería contar), la memoria utilizada por someObject en el ejemplo 1 no se recuperará (o el máximo terminará en la colección GC de la Generación 2).

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

Answer 5

No hay nada especial en el código escrito dentro de un bloque de using , solo use try.catch para manejar las 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 de using(...) { ... } sí está diseñado solo para garantizar que el recurso / objeto que "encapsula" se elimine correctamente cuando ya no sea necesario. No hay nada que puedas hacer con la instrucción en sí para hacer que maneje los errores.

Entonces, si espera que solo crear el objeto podría fallar, entonces tendría que colocar todo el bloque de using dentro del bloque try ... catch , o volver a try ... catch ... finally bloquear y garantizar desecharse (como Adam sugirió en su respuesta).

Answer 6

No lo haces dentro 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 7

Solo en la forma normal:

Ya sea

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 8

using no ofrece ninguna puerta trasera en la catch .

Simplemente expándalo manualmente (no tiene sentido tener el try / catch dentro de la IMO usando):

SqlConnection conn = null;

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

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

Yo prefiero esto sobre envolver el using en un try-catch o incrustar un try-catch en el using mayor parte del tiempo para evitar que el código termine con un try-catch anidado una vez compilado. Sin embargo, si solo necesita cubrir un subconjunto muy pequeño de un gran fragmento de código dentro de un using , sería más granular e incrustarlo.

Answer 9

class SqlConnection
{
   using(sqlConnection)
   {

   }
}

class Consumer
{
   try
  {

  }
  catch(SqlException)
  {

  }

}

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