在 C# 中的析构函数一文中，顾名思义，析构函数是 C# 中销毁对象的方法。如果不再需要这些对象，则调用析构函数以从类中销毁这些对象。析构函数将由垃圾收集器自动调用并销毁对象。
语法：
class Demo
{
// other methods
~Demo() // destructor
{
// your code
}
}C# 析构函数是 Finalize( ) 方法的快捷方式。所以当你声明析构函数时
~Demo() // destructor
{
// your code
}C# 编译器会将其翻译为：
protected override void Finalize()
{
try
{
// your code
}
finally
{
base.Finalize();
}
}析构函数由 ~（波形符）表示。
以下是析构函数的属性：
这里有一些示例，展示了它在 C# 中的工作原理。
代码：
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());
}
}
}在上面的示例中，参数化构造函数使用参数名称和年龄进行初始化，其中这是引用类变量的关键字。之后，使用与类名和符号相同的名称创建析构函数〜。在main方法中，有一个person类的对象。获得一个人的姓名和年龄后，就不再需要对象了。因此，析构函数被调用，它会销毁对象并取消分配它们的内存。
输出：
代码：
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());
}
}
}这个例子和前面的例子几乎一样，但是在这个例子中，main方法中有两个对象。众所周知，构造函数为每个对象运行，同样的事情也适用于析构函数。在这种情况下，析构函数被调用两次并取消分配每个对象的内存。
输出：
代码：
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，它被类 B 继承，那么在构造函数的情况下，首先调用类 A，然后调用类 B。但是，在析构函数的情况下，首先调用类 B（派生类），然后再调用类 A（基类）。
订单执行的另一个例子：-
代码：
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();
}
}
}输出：
如您所见，首先调用第三个构造函数，然后调用第二个和第一个构造函数。
代码：
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();
}
}
}输出：
如果程序结束时不需要对象的内存，则析构函数会取消分配对象的内存。但有时如果我们在程序执行过程中使用GC.Collect()，它会在中间销毁对象并释放这些对象的内存。析构函数可以隐式或显式调用。但无需显式销毁对象，因为 C# 提供垃圾收集。但是，当您使用完非托管资源后，您将需要显式释放它们。无需调用或管理资源的情况。使用析构函数来处理非托管资源。垃圾收集器将调用析构函数，因为它由具有析构函数的对象列表组成。因此，每当创建或销毁对象时，该列表就会更新。如果队列中有对象，则在析构函数执行后，它会被垃圾收集器收集。
析构函数的主要目的是在对象执行后释放其内存。因此，析构函数中执行了不同的操作，例如回收空间、释放网络资源和资源锁等。析构函数应该用于释放非托管资源而不是托管资源。
这是 C# 中析构函数的指南。这里我们讨论C#中析构函数的介绍、属性以及示例。 您还可以阅读我们其他推荐的文章以了解更多信息 –
以上是C# 中的析构函数的详细内容。更多信息请关注PHP中文网其他相关文章！
