Wie Sie richtig schließen ODP.net Verbindung : dispose () - oder close()?

Sieht es aus wie jeder andere, ich bemerkte zu spät, dass Sie in der powershell. In diesem Fall ist es eigentlich egal. Alles wird bereinigt, wenn die shell beendet, unabhängig. Ich nehme an, man könnte hinzufügen, ein [fangen] und vielleicht auch schließen/entsorgen Sie die Verbindung da, wenn es ist noch offen, aber ich denke, dass wäre nur nötig, wenn Sie geplant, auf dass dein Skript weiter.

Ich lasse mein langatmig c# Antwort unten. Auch wenn es nicht wirklich für dein Skript, es erklärt die Unterschiede (oder deren fehlen).

Die kurze Antwort (für c#):

using (var conn = new OracleConnection(connectionString))
{
}

"verwenden" stellt sicher, dass .Dispose aufgerufen wird am Ende des Blocks, auch wenn eine exception geworfen wird. So dass Sie nie Gefahr, eine Verbindung zu Waisen werden, bis die garbage collection bekommt endlich um, um es zu reinigen, und das könnte gut sein, nach dem ausführen von Datenbank-verbindungen.

Die lange Antwort:

Mit einem Reflektor, werden Sie sehen, dass die Dispose-Aufrufe in der Nähe:

protected override void Dispose(bool disposing)
{
  if (ProviderConfig.m_bTraceLevelPublic)
    Trace.Write(OracleTraceLevel.Public, OracleTraceTag.Entry);
  this.m_disposed = true;
  this.m_dataSource = string.Empty;
  this.m_serverVersion = string.Empty;
  try
  {
    bool flag = this.m_connectionState == ConnectionState.Closed && this.m_oracleConnectionImpl == null;
    try
    {
      if (!disposing)
      {
        if (!flag)
        {
          if (OraclePool.m_bPerfNumberOfReclaimedConnections)
            OraclePool.PerformanceCounterIncrement(OraclePerfParams.CounterIndex.NumberOfReclaimedConnections, this.m_oracleConnectionImpl, this.m_oracleConnectionImpl.m_cp);
        }
      }
    }
    catch (Exception ex)
    {
      if (ProviderConfig.m_bTraceLevelPublic)
        Trace.Write(OracleTraceLevel.Public, OracleTraceTag.Error, ex.ToString());
    }
    if (!flag)
    {
      try
      {
        this.Close();
      }
      catch (Exception ex)
      {
        if (ProviderConfig.m_bTraceLevelPublic)
          Trace.Write(OracleTraceLevel.Public, OracleTraceTag.Error, ex.ToString());
      }
    }
    try
    {
      base.Dispose(disposing);
    }
    catch (Exception ex)
    {
      if (ProviderConfig.m_bTraceLevelPublic)
        Trace.Write(OracleTraceLevel.Public, OracleTraceTag.Error, ex.ToString());
    }
    try
    {
      GC.SuppressFinalize((object) this);
    }
    catch (Exception ex)
    {
      if (!ProviderConfig.m_bTraceLevelPublic)
        return;
      Trace.Write(OracleTraceLevel.Public, OracleTraceTag.Error, ex.ToString());
    }
  }
  catch (Exception ex)
  {
    if (!ProviderConfig.m_bTraceLevelPublic)
      return;
    Trace.Write(OracleTraceLevel.Public, OracleTraceTag.Error, ex.ToString());
  }
  finally
  {
    if (ProviderConfig.m_bTraceLevelPublic)
      Trace.Write(OracleTraceLevel.Public, OracleTraceTag.Exit);
  }
}

Gibt es tatsächlich einen Unterschied? Nein - die nicht verwaltete Ressource IST die Verbindung, die die Sorge mit .Schließen. Würden Sie sehen keinen funktionalen Unterschied (andere als verzögert tracing), wenn Sie überprüft den status der Verbindung in einem finally-block und rief .Schließen Sie es, wenn es noch offen war.

  OracleConnection conn = null;
  try
  {
    conn = new OracleConnection(connectionString);
  }
  finally
  {
    if(conn.State != ConnectionState.Closed)
      conn.Close();
  }

Sagte, dass die empfohlenen Muster für idisposible Objekte ist die Verwendung von "using" block. Ja, ich nehme an, es ist wahr, dass Sie die option haben, öffnen Sie erneut die Verbindung mit nahe, aber ich sehe nicht, dass eine nützliche Sache zu tun.

Wenn Sie nicht verwenden Sie eine using-oder eine endlich und eine exception geworfen wird und schließen/entsorgen nie aufgerufen wird, dann befreien Sie die Verbindung zu der db wäre nicht deterministisch - Dispose(false) passieren würde, wenn der garbage collector dazu gekommen - und das könnte lange, nachdem Sie verbindungen zu Ihrem db.

    OracleConnection conn = null;
    conn = new OracleConnection(connectionString);
    conn.Open();

    //exception occurs - Close is never called - resource leak!!

    conn.Close();

Mehr standard-Implementierung für die Ressource, die für die Einführung IDisposable ist durch das einwickeln von es von using:

using (OracleConnection connection = new OracleConnection(connectionString)){
    using (OracleCommand command = new OracleCommand(sql, connection))
        using (OracleDataReader reader = cmd.ExecuteReader())
        {
        }
    connection.Close(); //optional
}

Es ist äquivalent zu der Umsetzung .Dispose nach der Ausführung blockieren. Intern Dispose behandelt auch die Schließung. Trotzdem könnte man sich auch an den .Close() nach dem Befehl block.

Einen Beispiel in der oracle-Dokumentation, die verwendet Oracle.DataAccess fördert die Nutzung von Dispose zu.