C# sql cosa smaltire

Question

Ho il codice qui sotto per interrogare i record da una procedura memorizzata, ma sono preoccupato che non possa smaltire ciò di cui ho bisogno o mi stia smaltendo quando l'oggetto verrà eliminato dal Garbage Collector poco dopo comunque.

Devo disporre di SqlDataReader poiché si trova nel blocco di prova try?

Devo eseguire entrambi cmd.Dispose e cmd.Connection.Close o si deduce l'altro?

Il garbage collector eliminerà comunque tutti questi oggetti (forse non abbastanza tempestivamente) o questi oggetti implicitamente richiedono di essere eliminati probabilmente a causa dell'uso di codice non gestito?

public void GetData(string studentID) 
    { 
     SqlCommand cmd = new SqlCommand("sp_stored_proc", 
       new SqlConnection(Settings.Default.connectionString)) 
       { CommandType = CommandType.StoredProcedure }; 
     try 
     { 
      cmd.Connection.Open(); 
      cmd.Parameters.AddWithValue("@student_id", studentID); 
      SqlDataReader dr = cmd.ExecuteReader(); 

     //do something with the data 

      if (dr != null) 
       dr.Dispose(); 
     } 
     catch 
     { 
      //error handling 
     } 
     finally 
     { 
      if (cmd != null) 
      { 
       cmd.Dispose(); 
       cmd.Connection.Close(); 
      } 

     } 

    } 

Answer 1

È necessario disporre il lettore di dati e il comando. Non è necessario chiudere separatamente la connessione se si dispone del comando. Si dovrebbe idealmente fare entrambe le cose utilizzando un blocco using:

using (SqlCommand cmd = new...) 
{ 
    // do stuff 
    using (SqlDataReader dr = cmd.ExecuteReader()) 
    { 
     // do stuff 
    } 
} 

Se avete bisogno di fare la gestione delle eccezioni che separatamente all'interno o intorno ai blocchi utilizzando - non c'è bisogno per la fine per le chiamate Dispose però con using.

Answer 2

Devo smaltire la SqlDataReader dal momento che è all'interno del try cattura blocco?

- Sì, poiché all'interno del fermo di prova non viene chiamato il metodo di smaltimento.

Devo eseguire entrambi cmd.Dispose e cmd.Connection.Close o si deduce l'altro?

- Sì, è necessario eseguire entrambi. Chiamare Cmd.dispose non chiude la connessione.

Il metodo dispose è pensato per essere utilizzato dal programmatore per ripulire le risorse che non sono gestite direttamente dal garbage collector, o la necessità di essere cancellate dopo che il programma è stato fatto usandole per liberare spazio. Tecnicamente, si potrebbe configurare il programma in modo che il GC gestisca la sua eliminazione, ma questa è un'ipotesi che non creerei, specialmente dal momento che il programmatore che ha scritto la classe ha esposto il metodo di smaltimento per te. Inserire il comando in un'istruzione using è probabilmente il percorso più semplice, perché sai che verrà eliminato quando il codice lascia lo spazio della dichiarazione.

using (var connection = new Connection()) 
{ 
    using (var cmd = new Command()) 
    { 



    } 
} 

Answer 3

Personalmente, se qualcosa ha un metodo di smaltimento, vale la pena utilizzarlo in ogni caso in quanto impediscono perdite di memoria protettive.

Answer 4

Se si utilizza qualcosa di simile:

public void GetData(string studentID) 
{ 
    using (SqlConnection connection = new SqlConnection(Settings.Default.connectionString)) 
    { 
     connection.Open(); 

     using (SqlCommand command = connection.CreateCommand()) 
     { 
      command.CommandType = CommandType.StoredProcedure; 
      command.CommandText = "sp_stored_proc"; 
      command.Parameters.AddWithValue("@student_id", studentID); 

      using (SqlDataReader dataReader = command.ExecuteReader()) 
      { 
       // do something with the data 
      } 
     } 
    } 
} 

poi tutti gli oggetti usa e getta andranno smaltiti correttamente. Chiamando Dispose() sugli oggetti SqlConnection, SqlCommand e SqlDataReader (che è ciò che fa il blocco using quando esce) li chiude correttamente.

Inoltre, questo approccio mantiene tutte le variabili nell'ambito del punto in cui vengono utilizzate.

Lo svantaggio di questo approccio è che se hai bisogno di una gestione degli errori usando un try/catch, devi avvolgerlo attorno all'intero corpo del metodo, o usarne diversi per gestire gli errori di connessione in modo diverso dagli errori di lettura, ecc. ..

Answer 5

Per farla breve; se implementa IDisposable, è necessario chiamare Dispose.

Anche se si utilizza Reflector per capire che Dispose in un oggetto invoca Dispose su un altro oggetto, io consiglierei comunque di chiamare Dispose su entrambi, dal momento che questo è dettagli interni di implementazione che possono cambiare in qualche versione futura, in modo non dovresti fare affidamento sul fatto che sia sempre vero.

Quindi, Dispose qualsiasi cosa che sia IDisposable.

Answer 6

è necessario aprire Connessione prima tramite Connection.Open(); quindi utilizzare i metodi come SqlDataReader per leggere dopo tutto, chiudere SqlDataReader in primo luogo e poi stretta connessione

è possibile utilizzare parole chiave "utilizzando" di disporre di esso, ma non è una buona idea

infatti la la parola chiave "usare" è disporre l'oggetto automaticamente. in altre parole, l'oggetto dovrebbe raggiungere il metodo di smaltimento