Moet ik een SQL-verbinding sluiten() voordat deze wordt verwijderd?

Volgens mijn andere vraag hier over wegwerpobjecten, moeten we Close() aanroepen voor het einde van een gebruiksblok?

using (SqlConnection connection = new SqlConnection())
using (SqlCommand command = new SqlCommand())
{
    command.CommandText = "INSERT INTO YourMom (Amount) VALUES (1)";
    command.CommandType = System.Data.CommandType.Text;
    connection.Open();
    command.ExecuteNonQuery();
    // Is this call necessary?
    connection.Close();
}

Antwoord 1, autoriteit 100%

Omdat je een gebruiksblok hebt, wordt de Dispose-methode van de SQLCommand aangeroepen en wordt de verbinding gesloten:

// System.Data.SqlClient.SqlConnection.Dispose disassemble
protected override void Dispose(bool disposing)
{
    if (disposing)
    {
        this._userConnectionOptions = null;
        this._poolGroup = null;
        this.Close();
    }
    this.DisposeMe(disposing);
    base.Dispose(disposing);
}

Antwoord 2, autoriteit 23%

Demontage van SqlConnection door gebruik van .NET Reflector:

protected override void Dispose(bool disposing)
{
    if (disposing)
    {
        this._userConnectionOptions = null;
        this._poolGroup = null;
        this.Close();
    }
    this.DisposeMe(disposing);
    base.Dispose(disposing);
}

Het roept Close() aan binnen Dispose()

Antwoord 3, autoriteit 20%

Het gebruik trefwoord zal de verbinding correct sluiten, zodat de extra oproep om te sluiten niet nodig is.

Uit het MSDN-artikel over SQL Server Connection Pooling:

“We raden u ten zeerste aan om altijd
sluit de verbinding als je bent
klaar met het gebruik ervan, zodat de
verbinding wordt teruggestuurd naar de
zwembad. U kunt dit doen met behulp van de
Sluit of verwijder methoden van de
Verbindingsobject, of door alles te openen
verbindingen binnen een gebruiksinstructie
in C#”

De daadwerkelijke implementatie van SqlConnection.Dispose met behulp van .NET Reflectoris als volgt:

// System.Data.SqlClient.SqlConnection.Dispose disassemble
protected override void Dispose(bool disposing)
{
    if (disposing)
    {
        this._userConnectionOptions = null;
        this._poolGroup = null;
        this.Close();
    }
    this.DisposeMe(disposing);
    base.Dispose(disposing);
}

Antwoord 4, autoriteit 4%

Als u Reflectorgebruikt, kunt u zien dat de Disposemethode van SqlConnectionroept daadwerkelijk Close()aan;

protected override void Dispose(bool disposing)
{
    if (disposing)
    {
        this._userConnectionOptions = null;
        this._poolGroup = null;
        this.Close();
    }
    this.DisposeMe(disposing);
    base.Dispose(disposing);
}

Antwoord 5, autoriteit 4%

Nee, het aanroepen van Dispose() op SqlConnection roept ook Close() aan.

MSDN – SqlConnection.Dispose()

Antwoord 6, autoriteit 3%

Nee, met het gebruik van block roept u toch Dispose()op, dus u hoeft Close()niet aan te roepen.

Antwoord 7, autoriteit 2%

Nee, het is niet nodig om een ​​verbinding te verbreken voordat u Dispose aanroept.

Sommige objecten (zoals SQLConnections) kunnen opnieuw worden gebruikt na het aanroepen van Close, maar niet na het aanroepen van Dispose. Voor andere objecten is het aanroepen van Sluiten hetzelfde als het aanroepen van Dispose. (ManualResetEvent en streams gedragen zich volgens mij zo)

Antwoord 8

Nee, de SqlConnection-klasse erft van IDisposable, en wanneer het einde van het gebruik (voor het verbindingsobject) wordt aangetroffen, wordt automatisch de Dispose op de SqlConnection-klasse aangeroepen.