Introducción a Destructor en C #
En el artículo Destructor en C # como su nombre indica, los destructores son los métodos en C # que destruyen los objetos. Si los objetos ya no son necesarios, se llama al destructor para destruir esos objetos de la clase. El destructor invocará automáticamente el recolector de basura y destruirá los objetos.
Sintaxis:
class Demo
(
// other methods
~Demo() // destructor
(
// your code
)
)
C# destructor is a shortcut of Finalize( ) method. So when you declare destructor
~Demo() // destructor
(
// your code
)
C# compiler will translate it to:
protected override void Finalize()
(
try
(
// your code
)
finally
(
base.Finalize();
)
)
Destructor está representado por ~ (tilde).
Propiedades del Destructor en C #
Las siguientes son las propiedades de destructor:
- Los destructores no pueden tener parámetros ni modificadores de acceso.
- Cada clase debe constar de un solo destructor.
- Los destructores no se pueden sobrecargar o heredar.
- El nombre del destructor es siempre el mismo que el nombre de la clase y no tiene ningún tipo de retorno.
- Destructor utiliza el método Finalizar e invocado por Garbage Collector cuando los objetos ya no son necesarios.
- Destructor sigue el patrón inverso. En destructor, la clase derivada se llama primero y luego clase base.
¿Cómo funciona Destructor en C #?
Aquí hay algunos ejemplos que muestran cómo funciona en C #.
Ejemplo 1
Código:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Destructor
(
class person
(
//variables
public string name;
public int age;
public person(string name, int age) //parametrized constructor
(
this.name = name;
this.age = age;
)
public string getName()
(
return this.name;
)
public int getAge()
(
return this.age;
)
~person() // destructor
(
Console.WriteLine("Destructor has been invoked");
)
)
class Program
(
// main method
static void Main(string() args)
(
person Details = new person("Joe", 28);
Console.WriteLine(Details.getName());
Console.WriteLine(Details.getAge());
)
)
)
En el ejemplo anterior, el constructor parametrizado se inicializa con el nombre y la edad del parámetro, donde se trata de una palabra clave que se refiere a variables de clase. Después de que se crea ese destructor con el mismo nombre que el nombre de clase y el símbolo ~. En el método principal, hay un objeto de la persona de clase. Después de obtener el nombre y la edad de una persona, ya no se requieren objetos. Entonces se llama destructor que destruye los objetos y desasigna sus recuerdos.
Salida:
Ejemplo # 2
Código:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
anmespace Destructor
(
class person
(
// variables
public string name;
public int age;
public person(string name, int age) // parameterized constructor
(
this.name = name;
this.age = age;
)
public string getName()
(
return this.name;
)
public int getAge()
(
return this.age;
)
~person() //destructor
(
Console.WriteLine("Descructor has been invoked");
)
)
class Program
(
// Main method
static void Main(string() args)
(
person Details = new person("Joe", 28); // first object
person Details1 = new person("John", 20);
Console.WriteLine(Details.getName());
Console.WriteLine(Details.getAge());
Console.WriteLine(Details1.getName());
Console.WriteLine(Details1.getAge());
)
)
)
Este ejemplo es casi igual que el ejemplo anterior, pero en este ejemplo, hay dos objetos en el método principal. Como sabemos, el constructor se ejecuta para cada objeto y esta misma cosa se aplica también para el destructor. En este caso, el destructor se llama dos veces y desasigna la memoria de cada objeto.
Salida:
Ejemplo # 3
Código:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Destructor
(
public class Parent
(
~Parent() // base destructor
(
Console.WriteLine("Parent.~Parent()");
)
)
public class Child : Parent
(
~Child() // derived destructor
(
Console.WriteLine("Child.~Child()");
)
)
public class MainClass
(
static void Main()
(
Child child = new Child();
)
)
)
En el ejemplo anterior, se define la clase padre que tiene un destructor. Entonces la clase hija hereda la clase padre y también consiste en un destructor. Entonces el destructor secundario llama automáticamente al destructor base.
En constructores, el constructor base se llama primero. Por ejemplo, si tenemos la clase base A que es heredada por la clase B, en el caso del constructor, la clase A se llama primero y luego la clase B. Sin embargo, en el caso del destructor, la clase B (clase derivada) se llama primero antes de la clase A ( clase base).
Otro ejemplo de ejecución de órdenes: -
Código:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Destructor
(
class Tree
(
~Tree()
(
System.Console.WriteLine("This is the first destructor");
)
)
class Branch: Tree
(
~Branch()
(
System.Console.WriteLine("This is the second destructor");
)
)
class Flower: Branch
(
~Flower()
(
System.Console.WriteLine("This is the third destructor");
)
)
class Test
(
static void Main()
(
Flower f= new Flower();
)
)
)
Salida:
Como puede ver, el tercer constructor se llama inicialmente seguido por el segundo y el primero.
Ejemplo # 4
Código:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Destructor
(
class Example
(
public Example()
(
// constructor
Console.WriteLine("Object Created");
)
// Destructor
~Example()
(
Console.WriteLine("Object Destroyed");
)
)
class Program
(
public static void Sample()
(
Example ex = new Example();
)
static void Main(string() args)
(
Sample();
GC.Collect();
Console.ReadLine();
)
)
)
Salida:
Destructor desasigna la memoria del objeto si no son necesarios al final del programa. Pero a veces si usamos GC.Collect () en el medio de la ejecución del programa, destruirá los objetos en el medio y desasignará la memoria de esos objetos. Se puede llamar al destructor implícita o explícitamente. Pero no hay necesidad de destruir los objetos explícitamente ya que C # proporciona recolección de basura. Sin embargo, cuando haya terminado con los recursos no administrados, deberá liberarlos explícitamente. No hay necesidad de llamar o caso de recursos gestionados. Use destructor para manejar recursos no administrados. Garbage Collector llamará al destructor ya que consiste en una lista de objetos que tienen un destructor. Entonces, cada vez que se crea o destruye un objeto, esa lista se actualiza. Si hay un objeto en la cola, el recolector de basura lo recoge después de que se ejecuta el destructor.
Conclusión
El objetivo principal del destructor es liberar la memoria de los objetos después de su ejecución. Entonces, hay diferentes acciones ejecutadas en el destructor, como recuperar el espacio, liberar recursos de red y bloqueos de recursos, etc. Los destructores deben usarse para liberar recursos no administrados en lugar de recursos administrados.
Artículo recomendado
Esta ha sido una guía para Destructor en C #. Aquí discutimos la introducción, las propiedades y los ejemplos de Destructor en C #. También puede consultar nuestros otros artículos sugeridos para obtener más información:
- Introducción a Destructor en Java
- Herencia en C # | Los 4 tipos principales
- Copiar constructor en C # (ejemplos)
- ¿Qué es Multithreading en C #? El | Ventajas
- Destructor en Python (Ventajas con el ejemplo)
- Modificadores de acceso en PHP
- Tipos de constructor en C # con implementación de código
- Creación y métodos de subprocesamiento múltiple en C #