Bevezetés a pusztítóhoz a C # -ben
A C # Destructor cikkben, ahogy a neve is sugallja, a destruktúrák azok a C # módszerek, amelyek elpusztítják az objektumokat. Ha az objektumokra már nincs szükség, akkor a pusztítót fel kell hívni, hogy elpusztítsa ezeket az objektumokat az osztályból. A pusztító automatikusan meghívja a szemetesgyűjtőt, és elpusztítja az objektumokat.
Szintaxis:
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();
)
)
A pusztítót ~ (tilde) jelöli.
A pusztító tulajdonságai a C # -ben
A pusztító tulajdonságai a következők:
- A pusztítóknak nem lehetnek paraméterei és hozzáférési módosítóik.
- Minden osztálynak csak egy pusztítóból kell állnia.
- A pusztítók nem terhelhetők túl és nem örökölhetők.
- A pusztító neve mindig ugyanaz, mint az osztály neve, és nincs visszatérési típusa.
- A pusztító a Véglegesítés módszert használja, és a Szemétgyűjtő hívja be, amikor az objektumokra már nincs szükség.
- A pusztító a fordított mintát követi. A pusztítóban a származtatott osztályt először, majd az alap osztályt nevezzük.
Hogyan működik a pusztító a C # -ben?
Íme néhány példa, amely megmutatja, hogyan működik a C #.
1. példa
Kód:
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());
)
)
)
A fenti példában a paraméterezett konstruktor paraméter nevével és életkorával inicializálva van, ahol ez egy osztályváltozókra utaló kulcsszó. Ezután létrejön a pusztító ugyanazzal a névvel, mint az osztály neve és ~ szimbóluma. A fő módszerben van egy osztálytárs tárgya. A személy nevének és életkorának megszerzése után tárgyakra nincs szükség. Tehát pusztítót hívnak, aki elpusztítja a tárgyakat és elosztja az emlékeiket.
Kimenet:
2. példa
Kód:
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());
)
)
)
Ez a példa szinte megegyezik az előző példával, de ebben a példában a fő módszer két objektumot tartalmaz. Mint tudjuk, a konstruktor minden tárgynál fut, és ugyanezt alkalmazzák a pusztítókra is. Ebben az esetben a pusztítót kétszer hívják, és az egyes objektumok memóriáját kiosztják.
Kimenet:
3. példa
Kód:
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();
)
)
)
A fenti példában a szülőosztályt definiáljuk, amelynek destruktora van. Ezután a gyermekosztály örökli a szülőosztályt, és egy pusztítóból is áll. Tehát a gyermekpusztító automatikusan felhívja az alappusztítót.
A konstruktorokban az alapkonstruktort először hívják. Például, ha van olyan A bázisosztály, amelyet a B osztály örököl, úgy a konstruktor esetében az A osztályt elsőnek, majd a B osztálynak nevezzük. Azonban a pusztító esetén a B osztályt (származtatott osztály) először az A osztály előtt nevezzük ( alap osztály).
Egy másik példa a megrendelés végrehajtására: -
Kód:
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();
)
)
)
Kimenet:
Mint láthatja, a harmadik konstruktort először a második és az első hívja.
4. példa
Kód:
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();
)
)
)
Kimenet:
A Destructor lefoglalja az objektum memóriáját, ha erre nincs szükség a program végén. De néha, ha a GC.Collect () programot a program végrehajtásának közepén használjuk, akkor az elpusztítja a közepén lévő tárgyakat, és elosztja az objektumok memóriáját. A pusztítót implicit vagy explicit módon lehet megnevezni. De nem kell kifejezetten elpusztítani az objektumokat, mivel a C # szemétgyűjtést biztosít. Ha azonban nem a kezelt erőforrásokkal rendelkezik, akkor azokat kifejezetten fel kell szabadítania. Nincs szükség hívásra vagy kezelt erőforrások esetére. Használjon pusztítót a nem kezelt erőforrások kezelésére. A szemétgyűjtő felhívja a pusztítót, mivel az egy objektumlistából áll, amelyekben pusztító található. Tehát minden olyan objektum létrehozásakor vagy megsemmisítésekor, amelyet a lista frissít. Ha van egy objektum a sorban, akkor a szemetesgyűjtő összegyűjti azt a pusztító végrehajtása után.
Következtetés
A pusztító fő célja az objektumok memóriájának felszabadítása végrehajtásuk után. Tehát különféle műveleteket hajtanak végre a pusztítóban, például a hely helyreállítása, a hálózati erőforrások és az erőforrások zárolásainak felszabadítása stb. A pusztítókat a nem kezelt erőforrások helyett a nem kezelt erőforrások szabadon bocsátására kell használni.
Ajánlott cikk
Ez egy útmutató a Destructor számára a C # -ben. Itt tárgyaljuk a C # bevezetését, tulajdonságait, valamint a Destructor példáit. A további javasolt cikkeken keresztül további információkat is megtudhat -
- Bevezetés a Java detructorba
- Öröklődés a C # | A 4 legnépszerűbb típus
- Másoló konstruktor a C # -ben (példák)
- Mi a többszálú C # -ben? | Előnyök
- Pusztító a Pythonban (Előnyök a példával)
- Hozzáférés-módosítók a PHP-ben
- A konstruktor típusai a C # kód bevezetésével
- A többszálú létrehozás és módszerek a C # -ben