SqlCommand.Dispose est-il suffisant?

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

Mon problème est le suivant: la méthode Dispose de la commande SqlCommand (appelée lors de la sortie du bloc using) ferme-t-elle ou non l'objet SqlConnection sous-jacent?

Answer 1

Non, l'Élimination de la Commande n'aura pas d'effet de la Connexion. Une meilleure approche serait également envelopper le SqlCommand dans un bloc using ainsi

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

Sinon, la Connexion est inchangée par le fait qu'une Commande ait été éliminé (c'est peut-être ce que vous voulez?). Mais gardez à l'esprit que d'une Connexion être éliminés en tant que bien, et probablement plus important de disposer que d'une commande.

EDIT:

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é éliminé lors de l'utilisation de bloc a quitté. La connexion était toujours ouverte et bonne pour la deuxième commande.

Donc, l'élimination de la commande n'a décidément pas de disposer de la connexion, il a été à l'aide.

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 motif. 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 SQL et des connexions dans un bloc try (mais sans être encapsulé dans un bloc using) et j'ai toujours un bloc finally comme:

     finally
    {
        DisposeCommand(cmd);
    }
 

L'objet de connexion étant une propriété de l'objet de commande, le blocage du bloc d'utilisation est difficile dans cette situation - mais ce modèle exécute le travail sans encombrer votre code.