Introductie tot Destructor in C #
In het artikel Destructor in C #, zoals de naam al doet vermoeden, zijn destructors de methoden in C # die de objecten vernietigen. Als de objecten niet langer nodig zijn, wordt de vernietiger opgeroepen om die objecten uit de klasse te vernietigen. De vernietiger zal automatisch door de vuilnisman worden opgeroepen en vernietigt objecten.
Syntaxis:
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 wordt vertegenwoordigd door ~ (tilde).
Eigenschappen van Destructor in C #
Dit zijn de eigenschappen van destructor:
- Destructors kunnen geen parameters en toegangsmodificatoren hebben.
- Elke klasse zou uit slechts één destructor moeten bestaan.
- Destructors kunnen niet worden overbelast of geërfd.
- De naam van de destructor is altijd hetzelfde als de klassennaam en heeft geen retourtype.
- Destructor gebruikt de methode Voltooien en aangeroepen door Garbage Collector wanneer objecten niet langer nodig zijn.
- Destructor volgt het omgekeerde patroon. In destructor wordt de afgeleide klasse eerst en vervolgens de basisklasse genoemd.
Hoe Destructor werkt in C #?
Hier zijn enkele voorbeelden die laten zien hoe het werkt in C #.
Voorbeeld 1
Code:
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());
)
)
)
In het bovenstaande voorbeeld wordt de geparametriseerde constructor geïnitialiseerd met parameternaam en leeftijd, waarbij dit een trefwoord is dat verwijst naar klassenvariabelen. Daarna wordt de destructor gemaakt met dezelfde naam als de klassennaam en het symbool ~. In de hoofdmethode is er een object van de klaspersoon. Na het verkrijgen van de naam en leeftijd van een persoon, zijn objecten niet langer vereist. Dus destructor wordt genoemd die de objecten vernietigt en hun herinneringen de-alloceert.
Output:
Voorbeeld 2
Code:
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());
)
)
)
Dit voorbeeld is bijna hetzelfde als het vorige voorbeeld, maar in dit voorbeeld zijn er twee objecten in de hoofdmethode. Zoals we weten, wordt de constructor uitgevoerd voor elk object en hetzelfde geldt ook voor de destructor. In dit geval wordt de destructor twee keer aangeroepen en wordt het geheugen van elk object toegewezen.
Output:
Voorbeeld 3
Code:
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();
)
)
)
In het bovenstaande voorbeeld is de bovenliggende klasse gedefinieerd die een destructor heeft. Dan erft de kindklasse de ouderklasse en bestaat ook uit een destructor. Dus kindvernietiger roept automatisch de basisvernietiger op.
In constructors wordt de basisconstructor eerst genoemd. Als we bijvoorbeeld basisklasse A hebben die wordt overgeërfd door klasse B, wordt in het geval van constructeur klasse A eerst en vervolgens klasse B genoemd. In het geval van destructor wordt klasse B (afgeleide klasse) echter eerst genoemd vóór klasse A ( basisklasse).
Een ander voorbeeld van orderuitvoering: -
Code:
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();
)
)
)
Output:
Zoals u kunt zien, wordt de derde constructor aanvankelijk genoemd, gevolgd door de tweede en de eerste.
Voorbeeld 4
Code:
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();
)
)
)
Output:
Destructor wijst het geheugen van het object toe als ze niet nodig zijn aan het einde van het programma. Maar soms als we GC.Collect () gebruiken tijdens de uitvoering van het programma, vernietigt het objecten in het midden en wijst het geheugen van die objecten toe. Destructor kan impliciet of expliciet worden genoemd. Maar het is niet nodig om de objecten expliciet te vernietigen, omdat C # garbage collection biedt. Als u echter klaar bent met de onbeheerde bronnen, moet u deze expliciet bevrijden. Het is niet nodig om beheerde bronnen te bellen of te gebruiken. Gebruik destructor voor het omgaan met onbeheerde bronnen. Garbage Collector zal destructor aanroepen omdat het bestaat uit een lijst met objecten die een destructor hebben. Dus wanneer een object wordt gemaakt of vernietigd, wordt die lijst bijgewerkt. Als er een object in de wachtrij staat, wordt dit verzameld door de vuilnisman nadat de destructor is uitgevoerd.
Conclusie
Het belangrijkste doel van de vernietiger is om de herinnering aan objecten vrij te maken na hun uitvoering. Er worden dus verschillende acties uitgevoerd in de destructor, zoals het herstellen van de ruimte, het vrijgeven van netwerkbronnen en resource locks, etc. Destructors moeten worden gebruikt om onbeheerde bronnen vrij te geven in plaats van beheerde bronnen.
Aanbevolen artikel
Dit is een gids voor Destructor in C # geweest. Hier bespreken we de introductie, eigenschappen en voorbeelden van Destructor in C #. U kunt ook onze andere voorgestelde artikelen doornemen voor meer informatie -
- Introductie tot Destructor in Java
- Overerving in C # | Top 4 soorten
- Kopieer Constructor in C # (voorbeelden)
- Wat is multithreading in C #? | voordelen
- Destructor in Python (voordelen met voorbeeld)
- Toegang tot modificaties in PHP
- Soorten constructor in C # met code-implementatie
- Creatie en methoden van multithreading in C #