C# es el lenguaje de programación que actualmente se utiliza en el desarrollo de aplicaciones ASP.NET, una de sus principales ventajas es que cuenta con "recolector de basura" o Garbage Collector.
Esto es un proceso que revisa la memoria buscando aquellas asignaciones que los programadores ya no utilizamos.
Por ejemplo: si en alguna parte de la aplicación tenemos algo como
1: public void AlgunMetodo()
2: {
3: AlgunaClase miObjeto = new AlgunaClase();
4: // hacemos lo que tenemos que hacer con el objeto
5: ...
6: }
Cuando la ejecución del metodo finaliza, la memoria utilizada por "miObjeto" pasa a ser inaccesible dado que no tenemos la referencia a esa zona de memoria. En algún momento el Garbage Collector encontrará esa zona de memoria y se dará cuenta que ya no se puede acceder desde la aplicación y la devolvera al sistema de manera que se pueda volver a utilizar.
Antes de la existencia del Garbage Collector, los programadores teníamos que tener mucho cuidado y liberar la memoria antes de perder la referencia correspondiente.
El problema es que el Garbage Collector comienza a funcionar cuando se ha consumido el 90% de la memoria !!!
Esto significa que en ese punto ya estamos hasta las manos, y como si fuera poco se agrega un proceso al pool de ejecución que baja la performance de forma notable.
La solución a esta situación es implementar la interfaz IDisposable.
Esta interfaz obliga a las clases que la implementan a codificar el método
Dispose(), en el ejemplo anterior si en la definición de AlgunaClase se implementa la interfaz, podríamos hacer lo siguiente:
1: public void AlgunMetodo()
2: {
3: AlgunaClase miObjeto = new AlgunaClase();
4: // hacemos lo que tenemos que hacer con el objeto
5: miObjeto.Dispose();
6: }
Con eso ya solucionamos el problema, dado que el metodo Dispose() devuelve la memoria ocupada sin tener que llegar al 90%.
El problema que tenemos ahora es que debemos acordarnos de invocar al metodo para todos los objetos que utilizamos, es para volverse locos.
Entonces veamos cómo hay que implementar IDispose para una clase:
1: public class AlgunaClase : IDisposable
2: {
3: // Este es el constructor de la clase
4: public AlgunaClase()
5: {
6: // se crea un arreglo de 100 elementos
7: // hay que considerar que _Datos es una
8: // referencia a un arreglo creado en el
9: // momento en que se crea una instancia
10: // de esta clase
11: _Datos = new OtraClase[100];
12: }
13: private OtraClase[] _Datos;
14:
15: // Este es el destructor o finalize de
16: // la clase, se invoca automáticamente
17: // cuando un objeto es destruido.
18: // Esto ocurre cuando se sale del ámbito
19: // de existencia del objeto.
20: public ~AlgunaClase()
21: {
22: // Invoca a Dispose, la sobrecarga que
23: // utiliza argumento para liberar los
24: // recursos propios de la instancia
25: // en este ejemplo es _Datos pero no
26: // libera la memoria asignada al arreglo
27: Dispose(false);
28: }
29:
30: // Aquí va lo que esta clase necesita
31: ...
32:
33: // Este es el método que debe implmentarse
34: // para cumplir con la interfaz
35: public void Dispose()
36: {
37: // En este caso se invoca el metodo con
38: // un parametro que obliga a liberar los
39: // recursos consumidos internamente en la
40: // instancia.
41: Dispose(true);
42: // Con esto se le avisa al Garbage Collector
43: // que no debe hacer nada con esta instancia
44: GC.SuppressFinalize(this);
45: }
46:
47: // Este campo se utiliza para indicar que una
48: // instancia de esta clase ya ejecutó el Dispose
49: private bool _IsDisposed = false;
50:
51: // Este metodo es el que realmente libera la
52: // memoria del objeto cuando el argumento es
53: // verdadero, se liberan los recursos consumidos
54: // dentro del objeto, como ser otro objeto creado
55: // con el operador new.
56: // cuando el argumento es falso, solamente se
57: // liberan recursos no administrados.
58: protected virtual void Dispose(bool disposing)
59: {
60: if (!_IsDisposed)
61: {
62: if (disposing)
63: {
64: // Aquí se trabaja con los recursos administrados
65: // se debe liberar cada uno de los elementos de la
66: // otra clase, se asume que OtraClase también
67: // implementa un metodo Dispose.
68: if (_Datos != null)
69: {
70: foreach(OtraClase o in _Datos)
71: {
72: o.Dispose();
73: }
74: // la referencia _Datos se libera cuando la
75: // instancia es destruida.
76: }
77: }
78: // Aquí se trabaja con los recursos no administrados
79: // como ser una handler a un archivo abierto.
80: }
81: // Finalmente indicamos que ya se hizo el Dispose.
82: this._IsDisposed = true;
83: }
84: }
Observesé que cuando una instancia de AlgunaClase se destruye no se libera la memoria asignada en el arreglo de objetos de OtraClase, esto se puede solucionar invocando al metodo protegido con un parámetro true.
Lo que ocurre es que el diseñador de clases debe analizar mediante algún diagrama de secuencias cómo se utilizan las instancias. En este caso, el destructor está pensado para liberar solo los campos internos de la clase y no los recursos creados internamente; esto es así porque se piensa utilizar las instancias en un bloque
using, como se muestra a continuación:
1: using(AlgunaClase miObjeto = new AlgunaClase())
2: {
3: // Hacer lo que se tenga que hacer
4: }
Cuando se codifica de este modo, el compilador genera el siguiente código:
1: AlgunaClase miObjeto = new AlgunaClase();
2: try
3: {
4: // Hacer lo que se tenga que hacer
5: }
6: finally
7: {
8: if (miObjeto != null)
9: miObjeto.Dispose();
10: }
Con lo que se asegura la liberación de los recursos creados internamente en la instancia dado que el método público Dispose invoca al metodo protegido con el argumento true.
Por supuesto es mucho más cómodo utilizar la sentencia
using, dejando que el compilador haga su trabajo.
Finalmente me gustaría comentar que tampoco es cuestión de poner código como este para todas las clases que una aplicación necesita, siempre hace falta un mínimo análisis de que es lo que se va a hacer y cómo se hara.
La información sobre todo estó la encontré en MSDN, incluso pueden ver un ejemplo para clases derivadas.