Ist SqlCommand.Dispose die Verbindung schließen?

Question

Kann ich diesen Ansatz effizient?

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, der SqlCommand Entsorgung wird die Verbindung nicht bewirken. Ein besserer Ansatz wäre auch die SqlConnection in einem mit Block wickelt auch:

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

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

EDIT:

ich das 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, auf jeden Fall des Befehls Entsorgung nicht entsorgen Sie die Verbindung wurde mit.

Answer 2

SqlCommand.Dispose wird nicht ausreichen, weil viele SqlCommand (n) kann (wieder) die gleiche SqlConnection verwenden. Zentrieren Sie Ihren Fokus auf der 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 erstelle ich SQL-Befehle und Verbindungen in einem Try-Block (aber ohne in einem mit Block gewickelt ist) und hat immer eine finally-Block wie:

    finally
    {
        DisposeCommand(cmd);
    }

Das Verbindungsobjekt eine Eigenschaft des Befehlsobjekts sein, macht eine Verwendung von Block in dieser Situation peinlich - aber dieses Muster bekommt den Job zu erledigen, ohne den Code unübersichtlich

.