SqlCommand.Dispose schließt die Verbindung?

Question

Kann ich diesen Ansatz effizient nutzen?

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

Meine Sorge ist: Wird die Dispose-Methode des SqlCommand (die aufgerufen wird, wenn die Verwendung von Block Verlassen) schließt das darunter liegende Objekt SqlConnection oder nicht?

Answer 1

Nein, die Entsorgung der SqlCommand wird die Verbindung nicht beeinflussen. Ein besserer Ansatz wäre es, auch als auch die SqlConnection in einem mit Block zu wickeln:

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

Andernfalls wird die Verbindung ist unverändert durch die Tatsache, dass ein Befehl, der benutzt es wurde angeordnet (vielleicht ist das, was Sie wollen?). Aber bedenken Sie, dass auch eine Verbindung entsorgt werden sollte, und wahrscheinlich wichtiger als ein Befehl zu entsorgen.

EDIT:

I dieses gerade getestet:

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

Der erste Befehl angeordnet wurde, wenn die Verwendung von Block verlassen wurde. Die Verbindung war noch offen und gut für den zweiten Befehl.

Also entsorgt der Befehl definitiv nicht die Verbindung, die er benutzte.

Answer 2

SqlCommand.Dispose wird nicht ausreichen, da viele SqlCommand (s) dieselbe SqlConnection (re) verwenden können. Zentriere deinen Fokus auf die SqlConnection.

Answer 3

Ich benutze dieses Muster. Ich habe diese private Methode irgendwo in meiner 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 
} 

Dann immer SQL-Befehle und Verbindungen in einem try-Block erstellen I (aber ohne in einem mit Block gewickelt ist) und hat immer eine finally-Block als:

Das Verbindungsobjekt, das eine Eigenschaft des Befehlsobjekts ist, macht einen Benutzungsblock in dieser Situation unpassend - aber dieses Muster erledigt die Aufgabe, ohne den Code zu überladen.