Tipos de Constructores y destructores

Constructores de clases.

Aquí se incluyen tres tipos de constructores:

a).- De instancia .- Para crear e inicializar instancias de una clase.

b).- Privado.- Un tipo especial de constructor de instancia que no es accesible desde fuera de la clase. Una clase con un constructor privado no puede ser instanciada (No se pueden crear objetos de esa clase).

c).- Estático.- Invocado automáticamente para inicializar la clase antes de que sea creada la primera instancia o que sea referenciado cualquier campo estático. El constructor no puede ser invocado directamente.

Constructores de instancia.

Los constructores de instancia fueron manejados con cierta amplitud en los subtemas previos de esta unidad.

Constructores privados.

Un constructor privado es comunmente utilizado en clases que contienen sólo campos y/o métodos estáticos. En tal caso, a otras clases (excepto a clases anidadas) no se les permite crear instancias de esta clase.

Ejemplo de constructores privados

class LogN
{

//Constructor privado.
private LogN( ) { }

public static double e = 2.71828 ;

}

La declaración del constructor vacío previene la generación automática de un constructor predeterminado.

Aunque no se utilice el modificador private, el constructor será privado por predeterminación. Sin embargo, el modificador private se utiliza para enfatizar el hecho de que la clase no puede ser instanciada.

Los constructores privados son útiles para prevenir la creación de una clase cuando no hay campos o métodos de instancia, o cuando un método es invocado para obtener una instacia de una clase.

Constructores estáticos.

Un constructor estático se utiliza para inicializar una clase. Es invocado automáticamente para inicializar la clase antes de que sea creada la primera instancia o que sea referenciado cualquier miembro estático.

La sintaxis para declarar un constructor estático es:

[atributos] static ( ) { cuerpo del constructor }

Un constructor estático no toma modificadores de acceso ni tiene parámetros.

Un constructor estático es invocado automáticamente para inicializar a la clase antes de que sea creada la primera instancia o que sea referenciado cualquier miembro estático.

Un constructor estático no puede ser invocado directamente.

Ejemplo de constructor estatico

//constructorEstat.cs

using System;
using C = System.Console;

class Estática
{

//Constructor estático.
static Estática( )
{

C.WriteLine("Se invocó al constructor estático...");

}

public static void otroMétodo( )
{

C.WriteLine("Se invocó a otroMétodo( )...");

}

}

class Principal
{

public static void Main( )
{

Estática.otroMétodo( );

}

}

Constructores de estructuras.

Los constructores de estructuras son semejantes a los constructores de clases, excepto porque:

Las estructuras no pueden contener constructores desparametrizados explícitos. Los miembros de estructuras son inicializados automáticamente a sus valores predeterminados.

Una estructura no puede tener un inicializador de la forma:

base(listaDeArgumentos)

Ejemplo de constructor de estructuras

//constrEstruct.cs : Ejemplo de un constructor que usa dos argumentos para la

//estructura Punto.

using System;
using C = System.Console;

public struct Punto
{

public int x, y ;

//Constructor.
public Punto(int a, int b)
{

x = a ;
y = b ;

}

//Sobreescribe el método ToString ( ).

public override string ToString( )
{

return(String.Format("({0} , {1})", x,y));

}

}

class Principal
{

static void Main( )
{

//Inicializa dos puntos.

Punto pA = new Punto( );
Punto pB = new Punto(10, 20);

//Despliega utilizando el método sobreescrito ToString

C.WriteLine("Punto A : {0}", pA) ;
C.WriteLine("Punto B : {0}", pB) ;

}

}

Destructores

Al igual que es posible definir métodos constructores que incluyan código que gestione la creación de objetos de un tipo de dato, también es posible definir un destructor que gestione cómo se destruyen los objetos de ese tipo de dato. Este método suele ser útil para liberar recursos tales como los ficheros o las conexiones de redes abiertas que el objeto a destruir estuviese acaparando en el momento en que se fuese a destruir.

La destrucción de un objeto es realizada por el recolector de basura cuando realiza una recolección de basura y detecta que no existen referencias a ese objeto ni en pila, ni en registros ni desde otros objetos sí referenciados. Las recolecciones se inician automáticamente cuando el recolector detecta que queda poca memoria libre o que se va a finalizar la ejecución de la aplicación, aunque también puede forzarse llamando al método Collect() de la clase System.GC

La sintaxis que se usa para definir un destructor es la siguiente:

~()

{

 

} 

Tras la ejecución del destructor de un objeto de un determinado tipo siempre se llama al destructor de su tipo padre, formándose así una cadena de llamadas a destructores que acaba al llegarse al destructor de object. Éste último destructor no contiene código alguno, y dado que object no tiene padre, tampoco llama a ningún otro destructor.

Ejemplo de un destructor en un programa

using System;

public class Base

{

 public virtual void F()

 {

  Console.WriteLine("Base.F");               

 }



 ~Base()

 {

  Console.WriteLine("Destructor de Base");

  this.F();

 }

}

public class Derivada:Base

{

 ~Derivada()

 {

  Console.WriteLine("Destructor de Derivada");

 }



 public override void F()

 {

  Console.WriteLine("Derivada.F()");

 }



 public static void Main()

 {

  Base b = new Derivada();                      

 }

}