.net - ¿SqlCommand.Dispose cerrar la conexión?

garbage-collection sqlconnection

Question

¿Puedo usar este enfoque de manera eficiente?

using(SqlCommand cmd = new SqlCommand("GetSomething", new SqlConnection(Config.ConnectionString))
{
    cmd.Connection.Open();
    // set up parameters and CommandType to StoredProcedure etc. etc.
    cmd.ExecuteNonQuery();
}

Mi preocupación es: ¿el método Dispose del SqlCommand (que se llama al salir del bloque que usa) cierra el objeto SqlConnection subyacente o no?

Answer 1

No, la eliminación de SqlCommand no afectará a la conexión. Un mejor enfoque sería también envolver SqlConnection en un bloque de uso también:

using (SqlConnection conn = new SqlConnection(connstring))
{
    conn.Open();
    using (SqlCommand cmd = new SqlCommand(cmdstring, conn))
    {
        cmd.ExecuteNonQuery();
    }
}

De lo contrario, la conexión no se modifica por el hecho de que un comando que lo estaba utilizando estaba dispuesto (¿quizás eso es lo que quiere?). Pero tenga en cuenta que una Conexión también debe desecharse, y probablemente sea más importante deshacerse de ella que una orden.

EDITAR:

Acabo de probar esto:

SqlConnection conn = new SqlConnection(connstring);
conn.Open();

using (SqlCommand cmd = new SqlCommand("select field from table where fieldid = 1", conn))
{
    Console.WriteLine(cmd.ExecuteScalar().ToString());
}

using (SqlCommand cmd = new SqlCommand("select field from table where fieldid = 2", conn))
{
    Console.WriteLine(cmd.ExecuteScalar().ToString());
}

conn.Dispose();  

El primer comando se eliminó cuando se salió del bloque de uso. La conexión todavía estaba abierta y era buena para el segundo comando.

Por lo tanto, deshacerse del comando definitivamente no elimina la conexión que estaba utilizando.

Answer 2

SqlCommand.Dispose no será suficiente porque muchos SqlCommand (s) pueden (re) usar la misma SqlConnection. Centra tu enfoque en SqlConnection.

Answer 3

Yo uso este patrón Tengo este método privado en alguna parte de mi aplicación:

private void DisposeCommand(SqlCommand cmd)
{
    try
    {
        if (cmd != null)
        {
            if (cmd.Connection != null)
            {
                cmd.Connection.Close();
                cmd.Connection.Dispose();
            }
            cmd.Dispose();
        }
    }
    catch { } //don''t blow up
}

Entonces siempre creo comandos y conexiones SQL en un bloque try (pero sin estar envuelto en un bloque que usa) y siempre tengo un bloque finally como:

    finally
    {
        DisposeCommand(cmd);
    }

El objeto de conexión es una propiedad del objeto de comando y hace que el uso del bloque sea incómodo en esta situación, pero este patrón hace el trabajo sin complicar su código.