Introducere în distrugător în C #
În articolul Destructor în C # așa cum sugerează și numele, distrugătoarele sunt metodele din C # care distrug obiectele. Dacă obiectele nu mai sunt necesare, atunci distrugătorul este chemat să distrugă acele obiecte din clasă. Distrugătorul va invoca automat colectorul de gunoi și distruge obiecte.
Sintaxă:
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();
)
)
Distrugătorul este reprezentat de ~ (tilde).
Proprietățile distrugătorului în C #
Următoarele sunt proprietățile distrugătorului:
- Distrugătorii nu pot avea parametri și modificatori de acces.
- Fiecare clasă trebuie să constea dintr-un singur distrugător.
- Distrugătorii nu pot fi supraîncărcați sau moșteniți.
- Numele distrugătorului este întotdeauna același cu numele clasei și nu are un tip de întoarcere.
- Distrugătorul utilizează metoda Finalize și invocată de Garbage Collector atunci când obiectele nu mai sunt necesare.
- Distrugătorul urmează modelul invers. În distrugător, clasa derivată se numește mai întâi și apoi clasa de bază.
Cum funcționează distrugătorul în C #?
Iată câteva exemple care arată cum funcționează în C #.
Exemplul # 1
Cod:
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());
)
)
)
În exemplul de mai sus, constructorul parametrizat este inițializat cu numele și vârsta parametrilor în care acesta este un cuvânt cheie care se referă la variabilele clasei. După ce distrugătorul este creat cu același nume cu numele clasei și simbolul ~. În metoda principală, există un obiect al clasei. După ce obțineți numele și vârsta unei persoane, obiectele nu mai sunt necesare. Așadar, se numește distrugător care distruge obiectele și le alocă amintirile.
ieşire:
Exemplul # 2
Cod:
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());
)
)
)
Acest exemplu este aproape același cu exemplul anterior, dar în acest exemplu, există două obiecte în metoda principală. După cum știm, constructorul rulează pentru fiecare obiect și același lucru este aplicat și pentru distrugător. În acest caz, distrugătorul este apelat de două ori și de-alocă memoria fiecărui obiect.
ieşire:
Exemplul # 3
Cod:
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();
)
)
)
În exemplul de mai sus, clasa părinte este definită care are un distrugător. Apoi, clasa copil moștenește clasa părintească și constă dintr-un distrugător. Deci, copilul distrugător numește automat distrugătorul de bază.
La constructori, constructorul de bază este numit primul. De exemplu, dacă avem clasa de bază A, care este moștenită de clasa B, atunci în cazul constructorului clasa A se numește mai întâi și apoi clasa B. Cu toate acestea, în cazul clasei distrugătoare B (clasa derivată) se numește mai întâi înaintea clasei A ( clasa de bază).
Un alt exemplu de executare a comenzii: -
Cod:
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();
)
)
)
ieşire:
După cum puteți vedea, al treilea constructor este numit inițial urmat de al doilea și primul.
Exemplul # 4
Cod:
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();
)
)
)
ieşire:
Distribuitorul alocă memoria obiectului dacă nu sunt necesare la sfârșitul programului. Dar uneori, dacă folosim GC.Collect () în mijlocul execuției programului, acesta va distruge obiectele din mijloc și va aloca memoria acelor obiecte. Distrugătorul poate fi numit implicit sau explicit. Dar nu este necesară distrugerea obiectelor în mod explicit, deoarece C # asigură colectarea gunoiului. Cu toate acestea, când ați terminat cu resursele neadministrate, va trebui să le eliberați explicit. Nu este necesară apelarea sau cazul resurselor gestionate. Utilizați distrugătorul pentru gestionarea resurselor neadministrate. Colectorul de gunoi va numi distrugător, deoarece constă dintr-o listă de obiecte care au un distrugător. Deci, ori de câte ori un obiect este creat sau distrus, acea listă este actualizată. Dacă există un obiect în coadă, acesta este colectat de colectorul de gunoi după executarea distrugătorului.
Concluzie
Scopul principal al distrugătorului este eliberarea memoriei obiectelor după executarea lor. Deci, există diferite acțiuni executate în distrugător, cum ar fi recuperarea spațiului, eliberarea resurselor de rețea și a blocărilor de resurse, etc. Distrugătorii ar trebui să fie folosiți pentru a elibera resurse neadministrate, mai degrabă decât resurse gestionate.
Articol recomandat
Acesta a fost un ghid pentru Distrugătorul din C #. Aici discutăm introducerea, proprietățile, precum și exemple de distrugător în C #. Puteți parcurge și alte articole sugerate pentru a afla mai multe -
- Introducere în distrugător în Java
- Moștenire în C # | Top 4 tipuri
- Copiați constructorul în C # (exemple)
- Ce este Multithreading în C #? | avantaje
- Distrugător în Python (Avantaje cu exemplu)
- Modificatori de acces în PHP
- Tipuri de constructor în C # cu implementarea codului
- Crearea și metodele de multitratare în C #