Pemusnah dalam C#

Dalam artikel Destructor dalam C# seperti namanya, destructors ialah kaedah dalam C# yang memusnahkan objek. Jika objek tidak lagi diperlukan, maka pemusnah dipanggil untuk memusnahkan objek tersebut daripada kelas. Pemusnah akan memanggil secara automatik oleh pemungut sampah dan memusnahkan objek.

Sintaks:

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

C# destructor ialah pintasan kaedah Finalize( ). Jadi apabila anda mengisytiharkan pemusnah

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

Pengkompil C# akan menterjemahkannya kepada:

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

Destructor diwakili oleh ~ (tilde).

Sifat Pemusnah dalam C#

Berikut adalah sifat-sifat pemusnah:

1. Pemusnah tidak boleh mempunyai sebarang parameter dan pengubah suai akses.
2. Setiap kelas hendaklah mengandungi hanya seorang pemusnah.
3. Pemusnah tidak boleh terlebih beban atau diwarisi.
4. Nama pemusnah sentiasa sama dengan nama kelas dan tidak mempunyai jenis pulangan.
5. Destructor menggunakan kaedah Finalize dan digunakan oleh Garbage Collector apabila objek tidak diperlukan lagi.
6. Destructor mengikut corak terbalik. Dalam pemusnah, kelas terbitan dipanggil pertama dan kemudian kelas asas.

Bagaimana Destructor berfungsi dalam C#?

Berikut ialah beberapa contoh yang menunjukkan cara ia berfungsi dalam C#.

Contoh #1

Kod:

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

Dalam contoh di atas, pembina berparameter dimulakan dengan nama parameter dan umur di mana ini adalah kata kunci yang merujuk kepada pembolehubah kelas. Selepas itu pemusnah dicipta dengan nama yang sama dengan nama kelas dan simbol ~. Dalam kaedah utama, terdapat objek orang kelas. Selepas mendapat nama dan umur seseorang, objek tidak lagi diperlukan. Jadi pemusnah dipanggil yang memusnahkan objek dan menyahperuntukkan ingatan mereka.

Output:

Contoh #2

Kod:

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

Contoh ini hampir sama dengan contoh sebelumnya, tetapi dalam contoh ini, terdapat dua objek dalam kaedah utama. Seperti yang kita ketahui, pembina berjalan untuk setiap objek dan perkara yang sama ini digunakan untuk pemusnah juga. Dalam kes ini, pemusnah dipanggil dua kali dan menyahperuntukkan memori setiap objek.

Output:

Contoh #3

Kod:

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

Dalam contoh di atas, kelas induk ditakrifkan yang mempunyai pemusnah. Kemudian kelas kanak-kanak mewarisi kelas induk dan terdiri daripada pemusnah juga. Jadi pemusnah kanak-kanak secara automatik memanggil pemusnah asas.

Dalam pembina, pembina asas dipanggil dahulu. Sebagai contoh, jika kita mempunyai kelas asas A yang diwarisi oleh kelas B jadi dalam kes kelas pembina A dipanggil pertama dan kemudian kelas B. Walau bagaimanapun, dalam kes kelas pemusnah B (kelas terbitan) dipanggil terlebih dahulu sebelum kelas A ( kelas asas).

Satu lagi contoh pelaksanaan pesanan:-

Kod:

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:

Seperti yang anda lihat, pembina ketiga dipanggil pada mulanya diikuti oleh yang kedua dan yang pertama.

Contoh #4

Kod:

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 menyahperuntukkan memori objek jika ia tidak diperlukan pada akhir program. Tetapi kadangkala jika kita menggunakan GC.Collect() di tengah-tengah pelaksanaan program, ia akan memusnahkan objek di tengah dan menyahperuntukkan memori objek tersebut. Pemusnah boleh dipanggil secara tersirat atau tersurat. Tetapi tidak perlu memusnahkan objek secara eksplisit kerana C# menyediakan pengumpulan sampah. Walau bagaimanapun, apabila anda selesai dengan sumber yang tidak terurus, anda perlu membebaskannya secara eksplisit. Tidak perlu dipanggil atau kes sumber terurus. Gunakan pemusnah untuk mengendalikan sumber yang tidak terurus. Pengumpul sampah akan memanggil pemusnah kerana ia terdiri daripada senarai objek yang mempunyai pemusnah. Oleh itu, apabila objek dicipta atau dimusnahkan, senarai itu dikemas kini. Jika terdapat objek dalam baris gilir, ia akan dikumpul oleh pemungut sampah selepas pemusnah melaksanakan.

Kesimpulan

Tujuan utama pemusnah adalah untuk membebaskan ingatan objek selepas pelaksanaannya. Jadi terdapat tindakan berbeza yang dilaksanakan dalam pemusnah seperti memulihkan ruang, melepaskan sumber rangkaian dan kunci sumber, dsb. Pemusnah harus digunakan untuk melepaskan sumber yang tidak terurus dan bukannya sumber terurus.

 Artikel Disyorkan

Ini telah menjadi panduan kepada Destructor dalam C#. Di sini kita membincangkan pengenalan, sifat serta Contoh Destructor dalam C#. Anda juga boleh menelusuri artikel cadangan kami yang lain untuk mengetahui lebih lanjut –

1. Pemusnah dalam Java
2. Warisan dalam C#
3. Salin Pembina dalam C# 
4. Pemusnah dalam Python

Atas ialah kandungan terperinci Pemusnah dalam C#. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!