SqlCommand.Dispose chiude la connessione?

Question

Posso utilizzare questo approccio in modo efficiente?

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

La mia preoccupazione è:Il metodo Dispose di SqlCommand (che viene chiamato all'uscita dal blocco using) chiuderà l'oggetto SqlConnection sottostante o no?

Answer 1

No, smaltimento del SqlCommand non influenzerà la Connessione.Un approccio migliore sarebbe avvolgere anche il file SqlConnection anche in un blocco using:

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

Altrimenti la Connessione non è modificata dal fatto che un Comando che la utilizzava è stato eliminato (forse è quello che vuoi?).Ma tieni presente che anche una connessione dovrebbe essere eliminata, e probabilmente più importante da smaltire di un comando.

MODIFICARE:

Ho appena testato questo:

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();  

Il primo comando è stato eliminato all'uscita dal blocco using.La connessione era ancora aperta e buona per il secondo comando.

Pertanto, l'eliminazione del comando non elimina sicuramente la connessione che stava utilizzando.

Answer 2

SqlCommand.Dispose non sarà sufficiente perché molti SqlCommand possono (ri)utilizzare la stessa SqlConnection.Centrare l'attenzione su SqlConnection.

Answer 3

Io uso questo modello.Ho questo metodo privato da qualche parte nella mia app:

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
}

Quindi creo sempre comandi e connessioni SQL in un blocco try (ma senza essere racchiuso in un blocco using) e ho sempre un blocco final come:

    finally
    {
        DisposeCommand(cmd);
    }

Essendo l'oggetto connessione una proprietà dell'oggetto comando, rende scomodo l'utilizzo di un blocco in questa situazione, ma questo modello svolge il lavoro senza ingombrare il codice.