SqlCommand.Dispose ferme-t-il la connexion ?

Question

Puis-je utiliser cette approche efficacement ?

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

Ma crainte est :La méthode Dispose de SqlCommand (qui est appelée lors de la sortie du bloc using) fermera-t-elle ou non l'objet SqlConnection sous-jacent ?

Answer 1

Non, l'élimination du SqlCommand n'affectera pas la connexion.Une meilleure approche serait d'envelopper également le SqlConnection dans un bloc using également :

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

Sinon, la connexion reste inchangée du fait qu'une commande qui l'utilisait a été supprimée (c'est peut-être ce que vous voulez ?).Mais gardez à l'esprit qu'une connexion doit également être éliminée, et probablement plus importante à éliminer qu'un commandement.

MODIFIER:

Je viens de tester ceci :

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

La première commande a été supprimée à la sortie du bloc using.La connexion était toujours ouverte et bonne pour la deuxième commande.

Ainsi, la suppression de la commande ne supprime définitivement pas la connexion qu’elle utilisait.

Answer 2

SqlCommand.Dispose ne sera pas suffisant car de nombreux SqlCommand(s) peuvent (ré)utiliser le même SqlConnection.Centrez votre attention sur SqlConnection.

Answer 3

J'utilise ce modèle.J'ai cette méthode privée quelque part dans mon application :

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
}

Ensuite, je crée toujours des commandes et des connexions SQL dans un bloc try (mais sans être enveloppé dans un bloc using) et j'ai toujours un bloc final comme :

    finally
    {
        DisposeCommand(cmd);
    }

L'objet de connexion étant une propriété de l'objet de commande rend un bloc d'utilisation gênant dans cette situation - mais ce modèle fait le travail sans encombrer votre code.