A destructor is a member that implements the actions required to destruct an
instance of a class. A destructor is
declared using a destructor-declaration:
destructor-declaration:
attributesopt externopt ~ identifier ( ) destructor-body
destructor-body:
block
;
A destructor-declaration may include a set of attributes (§24).
The identifier of a destructor-declarator must name the class in which the
destructor is declared. If any other
name is specified, a compile-time error occurs.
When a destructor declaration includes an extern modifier, the destructor
is said to be an external destructor.
Because an external destructor declaration provides no actual
implementation, its destructor-body consists of a
semicolon. For all other destructors, the destructor-body consists of a
block, which specifies the statements to
execute in order to destruct an instance of the class. A destructor-body
corresponds exactly to the method-body of
an instance method with a void return type (§17.5.8).
Destructors are not inherited. Thus, a class has no destructors other than
the one which may be declared in that
class.
[Note: Since a destructor is required to have no parameters, it cannot be
overloaded, so a class can have, at most,
one destructor. end note]
Destructors are invoked automatically, and cannot be invoked explicitly. An
instance becomes eligible for
destruction when it is no longer possible for any code to use that
instance. Execution of the destructor for the
instance may occur at any time after the instance becomes eligible for
destruction. When an instance is
destructed, the destructors in that instance?s inheritance chain are
called, in order, from most derived to least
derived [Example: The output of the example
Chapter 17 Classes
265
using System;
class A
{
~A() {
Console.WriteLine("A’s destructor");
}
}
class B: A
{
~B() {
Console.WriteLine("B’s destructor");
}
}
class Test
{
static void Main() {
B b = new B();
b = null;
GC.Collect();
GC.WaitForPendingFinalizers();
}
}
is
B?s destructor
A?s destructor
since destructors in an inheritance chain are called in order, from most
derived to least derived. The GC.Collect
method is not required, but may be provided by an implementation. end
example]
Destructors may be implemented by overriding the virtual method Finalize on
System.Object. In any event,
C# programs are not permitted to override this method or call it (or
overrides of it) directly. [Example: For
instance, the program
class A
{
override protected void Finalize() {} // error
public void F() {
this.Finalize(); // error
}
}
contains two errors. end example]
The compiler behaves as if this method, and overrides of it, does not exist
at all. [Example: Thus, this program:
class A
{
void Finalize() {} // permitted
}
is valid and the method shown hides System.Object?s Finalize method. end
example]
For a discussion of the behavior when an exception is thrown from a
destructor, see §23.3.
