c# - tipo - client found response content type of text html charset utf 8 but expected text xml

¿Cómo atrapa las excepciones con "usar" en C#

Question

Dado este código:

using (var conn = new SqlConnection("..."))
{
    conn.Open();
    using (var cmd = conn.CreateCommand())
    {
        cmd.CommandText = "...";
        using (var reader = cmd.ExecuteReader())
        {
            while (reader.Read())
            {
                // ...
            }
        }
    }
}

Estoy acostumbrado a escribir bloqueos try / catch / finally para acceder a mis datos, sin embargo, estoy expuesto a "usar", que parece ser un método mucho más simple de hacer esto. Sin embargo, estoy tratando de descubrir cómo detectar las excepciones que puedan ocurrir.

¿Podría darme un ejemplo de cómo detectar excepciones?

Editado para agregar:

Me están haciendo creer que "usar" es un reemplazo para mis bloques try / catch / finally. Entiendo que el uso no detecta excepciones. Entonces, ¿cómo es esto un reemplazo?

Answer 1

Ajustar todas las instrucciones de uso en try / catch. Como todos los demás han dicho, el uso es para limpiar las clases que implementan la interfaz IDisposable

try
{

 using (var conn = new SqlConnection("..."))
 {
    conn.Open();
    using (var cmd = conn.CreateCommand())
    {
        cmd.CommandText = "...";
        using (var reader = cmd.ExecuteReader())
        {
            while (reader.Read())
            {
                // ...
            }
        }
    }
 }
}
catch(Exception ex)
{
//Handle, log, rethrow exception
}

Answer 2

Si quiere detectar excepciones allí, probablemente debería volver a usar try / catch / finally. Simplemente ponga las llamadas .Dispose () en el bloque finally.

Answer 3

Todavía puede capturar (o ignorar) las excepciones exactamente como lo hubiera hecho anteriormente. El punto es que ya no tendrá que preocuparse por deshacerse de la conexión de la base de datos.

es decir, si su aplicación requiere que atrape excepciones por algún otro motivo (por ejemplo, registro), continúe, pero ya no tendrá que hacerlo si solo desea deshacerse de la conexión de la base de datos:

using (SqlConnection conn = new SqlConnection(...))
{
    // do your db work here
    // whatever happens the connection will be safely disposed
}

Si desea detectar la excepción por algún otro motivo, aún puede hacerlo:

try
{
    using (SqlConnection conn = new SqlConnection(...))
    {
        // do your db work here
        // whatever happens the connection will be safely disposed
    }
}
catch (Exception ex)
{
    // do your stuff here (eg, logging)
    // nb: the connection will already have been disposed at this point
}
finally
{
    // if you need it
}

Answer 4

Usar declaraciones no tiene nada que ver con Excepciones. El uso de bloques solo asegura que se invoca a Dispose en el objeto en el bloque de uso, cuando sale de ese bloque. ES DECIR:

using(SqlConnection conn = new SqlConnection(conStr))
{
   //use conn
}//Dispose is called here on conn.

Si abrir la conexión genera una excepción (o cualquier otra cosa en ese bloque), seguirá burbujeando hasta la cima y será como cualquier otra excepción sin manos.

Answer 5

using no está diseñado para detectar excepciones; está diseñado para darle una manera fácil de envolver / try un objeto que necesita ser eliminado. Si necesita capturar y manejar excepciones, deberá expandirlo a un try / catch / finally completo o poner un try / catch alrededor de todo.

Para responder a su edición (¿está using un reemplazo para try / catch / finally ?), Entonces no, no lo está. La mayoría de las veces, cuando utiliza un recurso desechable, no va a manejar la excepción en ese momento porque normalmente no hay nada útil que pueda hacer. Por lo tanto, proporciona una manera conveniente de garantizar que el recurso se limpie independientemente de lo que intente hacer o no.

Normalmente, el código que trata con recursos desechables funciona a un nivel demasiado bajo para decidir cuál es la acción correcta en la falla, por lo que la excepción se deja propagar a la persona que llama para decidir qué acción tomar (por ejemplo, reintento, error, registro, etc. .). El único lugar donde tenderías a utilizar un bloque catch con un recurso desechable es si vas a traducir la excepción (que, supongo, es lo que está haciendo tu capa de acceso a datos).

Answer 6

using (var cmd = new SqlCommand("SELECT * FROM Customers"))
{
    cmd.CommandTimeout = 60000;
    ...
}

es azúcar sintáctico para

var cmd = new SqlCommand("SELECT * FROM Customers");
try
{
    cmd.CommandTimeout = 60000;
    ...
}
finally
{
    if (cmd != null)
        cmd.Dispose();
}

Entonces, cuando las personas te dicen que "usar" es un reemplazo para try / catch / finally, implican que debes usar el formulario long-hand, pero agrega el bloque catch:

var cmd = new SqlCommand("SELECT * FROM Customers");
try
{
    cmd.CommandTimeout = 60000;
    ...
}
catch (Exception ex)
{
    ...//your stuff here
}
finally
{
    if (cmd != null)
        cmd.Dispose();
}