Recolección de basura, ¿debemos confiar en ella?

Question

En el código, digamos que tenemos:

using (SqlConnection cn = new SqlConnection(ConfigurationManager.ConnectionStrings["LocalSqlServer"].ToString())) 
{ 
    cn.Open(); 

    // Set all previous settings to inactive 
    using (SqlCommand cmd = new SqlCommand("UPDATE tblSiteSettings SET isActive = 0", cn)) 
    {        
     cmd.ExecuteNonQuery(); 
    } 

    cn.Close(); 
} 

El cn.close no se requiere técnicamente como la recolección de basura se hará cargo de la conexión para nosotros.

Sin embargo, siempre me gusta cerrarlo de todos modos y no confiar en la recolección de basura. ¿Es esto malo? ¿Una pérdida de tiempo? ¿O se considera una buena práctica no confiar en la automatización?

Gracias por su opinión y opiniones con anticipación. Lo marcaré como wiki de la comunidad, ya que probablemente sea subjetivo.

Answer 1

Nunca debe confiar en el GC para esto. Raymond Chen's blog article about this es un buen punto de partida. Esencialmente, si no lo hace de forma manual Close/Dispose de su conexión, entonces no hay garantía de que va a suceder, porque de lo contrario sólo ocurriría nunca cuando Dispose fue llamado desde el Finalizer la que jamás podría no suceder:

Un programa escrito correctamente no puede suponer que los finalizadores ejecutarán alguna vez en cualquier momento antes de la terminación del programa .

Sí, en la práctica, el finalizador para su conexión probablemente ocurrirá con el tiempo, pero incluso así, tendrá una conexión en vivo por más tiempo del que realmente necesita. Esto puede crear problemas si la base de datos solo permite un número limitado de conexiones activas en cualquier momento.

Lo que está haciendo se considera una buena práctica: cuando haya terminado con los recursos, libérelos. Si un objeto es IDisposable, Dispose, cuando pueda.

Answer 2

Antes que nada: en su ejemplo, está utilizando la interfaz IDisposable, que no tiene nada que ver con GC. En esencia, el código se compila a esto:

SqlConnection cn = null; 
try 
{ 
    cn = new SqlConnection(ConfigurationManager.ConnectionStrings["LocalSqlServer"].ToString()); 
    cn.Open(); 

    // Set all previous settings to inactive 
    using (SqlCommand cmd = new SqlCommand("UPDATE tblSiteSettings SET isActive = 0", cn)) 
    { 
     cmd.ExecuteNonQuery(); 
    } 
    cn.Close(); 
} 
finally 
{ 
    if (cn != null) 
     cn.Dispose(); 
} 

Desde cn.Dispose() y cn.Close() son los mismos que en este caso - sí, este último es redundante.

Ahora, si usted quiere hablar de GC, entonces lo escribe así:

SqlCOnnection cn = new SqlConnection(ConfigurationManager.ConnectionStrings["LocalSqlServer"].ToString()); 
    cn.Open(); 

    // Set all previous settings to inactive 
    using (SqlCommand cmd = new SqlCommand("UPDATE tblSiteSettings SET isActive = 0", cn)) 
    { 
     cmd.ExecuteNonQuery(); 
    } 
    cn = null; // Or just leave scope without doing anything else with cn. 

En este caso, sería tomar la GC para cerrar la conexión abierta y devolverlo a la piscina. Y en este caso, significaría que no podrías predecir cuándo sucedió eso. En la práctica, este código (con alta probabilidad) daría lugar a SqlConnections y pronto se quedaría sin ellos (obtendría una TimeoutException porque no habría conexiones disponibles en el grupo).

Así que, sí, su ejemplo anterior es la forma correcta de hacerlo. Siempre que use algún objeto que implemente IDisposable, envuélvalo en un bloque using. Y no necesita molestarse con el .Close(), aunque tampoco duele. Yo personalmente no lo escribo. Menos código, menos desorden.