Destruktor in C#

Im Artikel Destruktor in C# sind Destruktoren, wie der Name schon sagt, die Methoden in C#, die die Objekte zerstören. Wenn die Objekte nicht mehr benötigt werden, wird der Destruktor aufgerufen, um diese Objekte aus der Klasse zu zerstören. Der Destruktor wird automatisch vom Garbage Collector aufgerufen und zerstört Objekte.

Syntax:

class Demo
{
// other methods
~Demo()  // destructor
{
// your code
}
}

Der C#-Destruktor ist eine Abkürzung der Finalize( )-Methode. Wenn Sie also den Destruktor deklarieren

~Demo()   // destructor
{
// your code
}

Der C#-Compiler übersetzt es in:

protected override void Finalize()
{
try
{
// your code
}
finally
{
base.Finalize();
}
}

Destruktor wird durch ~ (Tilde) dargestellt.

Eigenschaften des Destruktors in C#

Das Folgende sind die Eigenschaften des Destruktors:

1. Destruktoren dürfen keine Parameter und Zugriffsmodifikatoren haben.
2. Jede Klasse sollte nur aus einem Destruktor bestehen.
3. Destruktoren können nicht überladen oder vererbt werden.
4. Der Destruktorname ist immer derselbe wie der Klassenname und hat keinen Rückgabetyp.
5. Der Destruktor verwendet die Finalize-Methode und wird vom Garbage Collector aufgerufen, wenn Objekte nicht mehr benötigt werden.
6. Der Destruktor folgt dem umgekehrten Muster. Im Destruktor wird zuerst die abgeleitete Klasse und dann die Basisklasse aufgerufen.

Wie funktioniert Destruktor in C#?

Hier sind einige Beispiele, die zeigen, wie es in C# funktioniert.

Beispiel #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());
}
}
}

Im obigen Beispiel wird der parametrisierte Konstruktor mit Parameternamen und Alter initialisiert, wobei es sich hierbei um ein Schlüsselwort handelt, das sich auf Klassenvariablen bezieht. Danach wird ein Destruktor mit demselben Namen wie der Klassenname und dem Symbol ~ erstellt. In der Hauptmethode gibt es ein Objekt der Klasse Person. Nachdem der Name und das Alter einer Person ermittelt wurden, werden keine Gegenstände mehr benötigt. Es wird also ein Destruktor aufgerufen, der die Objekte zerstört und ihre Erinnerungen freigibt.

Ausgabe:

Beispiel #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());
}
}
}

Dieses Beispiel ist fast das gleiche wie das vorherige Beispiel, aber in diesem Beispiel gibt es zwei Objekte in der Hauptmethode. Wie wir wissen, wird der Konstruktor für jedes Objekt ausgeführt und das Gleiche wird auch auf den Destruktor angewendet. In diesem Fall wird der Destruktor zweimal aufgerufen und gibt den Speicher jedes Objekts frei.

Ausgabe:

Beispiel #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();
}
}
}

Im obigen Beispiel wird die übergeordnete Klasse definiert, die einen Destruktor hat. Dann erbt die untergeordnete Klasse die übergeordnete Klasse und besteht ebenfalls aus einem Destruktor. Der untergeordnete Destruktor ruft also automatisch den Basisdestruktor auf.

In Konstruktoren wird zuerst der Basiskonstruktor aufgerufen. Wenn wir beispielsweise eine Basisklasse A haben, die von Klasse B geerbt wird, wird im Fall eines Konstruktors zuerst Klasse A und dann Klasse B aufgerufen. Im Fall eines Destruktors wird jedoch zuerst Klasse B (abgeleitete Klasse) vor Klasse A aufgerufen ( Basisklasse).

Ein weiteres Beispiel für die Auftragsausführung:-

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();
}
}
}

Ausgabe:

Wie Sie sehen können, wird zunächst der dritte Konstruktor aufgerufen, gefolgt vom zweiten und dem ersten.

Beispiel #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();
}
}
}

Ausgabe:

Der Destruktor gibt den Speicher des Objekts frei, wenn er am Ende des Programms nicht benötigt wird. Aber manchmal, wenn wir GC.Collect() mitten in der Programmausführung verwenden, werden Objekte in der Mitte zerstört und der Speicher dieser Objekte wird freigegeben. Der Destruktor kann implizit oder explizit aufgerufen werden. Es besteht jedoch keine Notwendigkeit, die Objekte explizit zu zerstören, da C# eine Garbage Collection bereitstellt. Wenn Sie jedoch mit den nicht verwalteten Ressourcen fertig sind, müssen Sie diese explizit freigeben. Es besteht keine Notwendigkeit, Ressourcen abzurufen oder zu verwalten. Verwenden Sie den Destruktor für den Umgang mit nicht verwalteten Ressourcen. Ein Garbage Collector ruft einen Destruktor auf, da er aus einer Liste von Objekten besteht, die über einen Destruktor verfügen. Wenn also ein Objekt erstellt oder zerstört wird, wird diese Liste aktualisiert. Wenn sich ein Objekt in der Warteschlange befindet, wird es nach der Ausführung des Destruktors vom Garbage Collector gesammelt.

Fazit

Der Hauptzweck des Destruktors besteht darin, den Speicher von Objekten nach ihrer Ausführung freizugeben. Daher werden im Destruktor verschiedene Aktionen ausgeführt, z. B. das Wiederherstellen des Speicherplatzes, das Freigeben von Netzwerkressourcen und Ressourcensperren usw. Destruktoren sollten verwendet werden, um nicht verwaltete Ressourcen und nicht verwaltete Ressourcen freizugeben.

 Empfohlener Artikel

Dies war eine Anleitung zum Destruktor in C#. Hier besprechen wir die Einführung, Eigenschaften sowie Beispiele des Destruktors in C#. Sie können auch unsere anderen empfohlenen Artikel durchsehen, um mehr zu erfahren –

1. Destruktor in Java
2. Vererbung in C#
3. Konstruktor in C# kopieren 
4. Destruktor in Python

Das obige ist der detaillierte Inhalt vonDestruktor in C#. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!