In C# Differencebetween a Destructor and a Finalize Method in a Class

In C# what is the difference between a destructor and a Finalize method in a class?

A destructor in C# overrides System.Object.Finalize method. You have to use destructor syntax to do so. Manually overriding Finalize will give you an error message.

Basically what you are trying to do with your Finalize method declaration is hiding the method of the base class. It will cause the compiler to issue a warning which can be silenced using the new modifier (if it was going to work). The important thing to note here is that you can't both override and declare a new member with identical name at the same time so having both a destructor and a Finalize method will result in an error (but you can, although not recommended, declare a public new void Finalize() method if you're not declaring a destructor).

Difference between destructor, dispose and finalize method

Destructor implicitly calls the Finalize method, they are technically the same. Dispose is available with objects that implement the IDisposable interface.

You may see : Destructors C# - MSDN

The destructor implicitly calls Finalize on the base class of the
object.

Example from the same link:

class Car
{
    ~Car()  // destructor
    {
        // cleanup statements...
    }
}

The Destructor's code is implicitly translated to the following code:

protected override void Finalize()
{
    try
    {
        // Cleanup statements...
    }
    finally
    {
        base.Finalize();
    }
}

Your understanding for the Destructor is right:

From MSDN

The programmer has no control over when the destructor is called
because this is determined by the garbage collector. The garbage
collector checks for objects that are no longer being used by the
application. If it considers an object eligible for destruction, it
calls the destructor (if any) and reclaims the memory used to store
the object. Destructors are also called when the program exits. It is
possible to force garbage collection by calling Collect, but most of
the time, this should be avoided because it may create performance
issues.

The difference between a destructor and a finalizer?

1) Is there a well-defined difference between "destructor" and "finalizer" as used in industry or academia?

There certainly appears to be. The difference seems to be that destructors are cleanup methods that are invoked deterministically, whereas finalizers run when the garbage collector tells them to.

2) In that case, the C# spec gets it wrong -- finalizers are called "destructors" in C#. Why did the authors of the C# spec get it wrong?

I don't know, but I can guess. In fact, I have two guesses.

Guess #1 is that on May 12th, 1999 there was not a wikipedia article clearly describing the subtle difference between these two concepts. That's because there wasn't a wikipedia. Remember back when there wasn't a wikipedia? Dark ages, man. The error might simply have been an honest mistake, believing that the two terms were identical.

Heck, for all I know, the two terms were identical on May 12th, 1999, and the difference in definitions only evolved later, as it became obvious that there was a need to disambiguate between eager and lazy cleanup methods.

Guess #2 is that on May 12th, 1999, the language design committee wished to leave open the possibility that a "destructor" could be implemented as something other than a finalizer. That is, the "destructor" was designed to be a C# language concept that did not necessarily map one-to-one with the .NET "finalizer" concept. When designing a language at the same time as the framework it sits atop is also being designed, sometimes you want to insulate yourself against late-breaking design changes in your subsystems.

The language committee's notes for May 12th 1999 read in part:

We're going to use the term
"destructor" for the member which executes
when an instance is reclaimed. Classes
can have destructors; structs can't.
Unlike in C++, a destructor cannot be
called explicitly. Destruction is
non-deterministic – you can't reliably
know when the destructor will execute,
except to say that it executes at some
point after all references to the
object have been released. The
destructors in an inheritance chain
are called in order, from most
descendant to least descendant. There
is no need (and no way) for the
derived class to explicitly call the
base destructor. The C# compiler
compiles destructors to the
appropriate CLR representation. For
this version that probably means an
instance finalizer that is
distinguished in metadata. CLR may
provide static finalizers in the
future; we do not see any barrier to
C# using static finalizers.

So, there, you now know everything I know on the subject. If you want to know more, ask Anders next time you see him.

Is there a difference between defining a destructor and not?

C# is a garbage collected language. This means that the .NET framework, in which code written in C# is executed, has a mechanism for the memory management. We don't have like in C++ to care about the destruction of the created objects, in order we don't have a high memory footprint or memory leaks. That's the job of Garbage Collector.

As it is stated more formally in MSDN

In general, C# does not require as much memory management as is needed
when you develop with a language that does not target a runtime with
garbage collection. This is because the .NET Framework garbage
collector implicitly manages the allocation and release of memory for
your objects. However, when your application encapsulates unmanaged
resources such as windows, files, and network connections, you should
use destructors to free those resources. When the object is eligible
for destruction, the garbage collector runs the Finalize method of the
object.

However the concept of destructors exist also in C# and as in other languages are used for the destruction of instances of classes. Furthermore a destructor cannot be called. It is invoked automatically.

For instance, if we declare the following class:

class Customer
{
    ~Customer()
    {
        // Here we place our clean up statements.
    }
}

The destructor will implicitly call the Finalize method on the base class of the object. As it is explained in the above link this code would be translated to the following one by the C# compiler:

protected override void Finalize()
{
    try
    {
        // Here goes our clean up statements.
    }
    finally
    {
        base.Finalize();
    }
}

This means that the Finalize method is called recursively for all
instances in the inheritance chain, from the most-derived to the
least-derived.

In any case you should keep in mind the following:

The programmer has no control over when the destructor is called
because this is determined by the garbage collector. The garbage
collector checks for objects that are no longer being used by the
application. If it considers an object eligible for destruction, it
calls the destructor (if any) and reclaims the memory used to store
the object. Destructors are also called when the program exits.

Finalize vs Dispose

Others have already covered the difference between Dispose and Finalize (btw the Finalize method is still called a destructor in the language specification), so I'll just add a little about the scenarios where the Finalize method comes in handy.

Some types encapsulate disposable resources in a manner where it is easy to use and dispose of them in a single action. The general usage is often like this: open, read or write, close (Dispose). It fits very well with the using construct.

Others are a bit more difficult. WaitEventHandles for instances are not used like this as they are used to signal from one thread to another. The question then becomes who should call Dispose on these? As a safeguard types like these implement a Finalize method, which makes sure resources are disposed when the instance is no longer referenced by the application.

Is there a difference between defining a destructor and not?

C# is a garbage collected language. This means that the .NET framework, in which code written in C# is executed, has a mechanism for the memory management. We don't have like in C++ to care about the destruction of the created objects, in order we don't have a high memory footprint or memory leaks. That's the job of Garbage Collector.

As it is stated more formally in MSDN

In general, C# does not require as much memory management as is needed
when you develop with a language that does not target a runtime with
garbage collection. This is because the .NET Framework garbage
collector implicitly manages the allocation and release of memory for
your objects. However, when your application encapsulates unmanaged
resources such as windows, files, and network connections, you should
use destructors to free those resources. When the object is eligible
for destruction, the garbage collector runs the Finalize method of the
object.

However the concept of destructors exist also in C# and as in other languages are used for the destruction of instances of classes. Furthermore a destructor cannot be called. It is invoked automatically.

For instance, if we declare the following class:

class Customer
{
    ~Customer()
    {
        // Here we place our clean up statements.
    }
}

The destructor will implicitly call the Finalize method on the base class of the object. As it is explained in the above link this code would be translated to the following one by the C# compiler:

protected override void Finalize()
{
    try
    {
        // Here goes our clean up statements.
    }
    finally
    {
        base.Finalize();
    }
}

This means that the Finalize method is called recursively for all
instances in the inheritance chain, from the most-derived to the
least-derived.

In any case you should keep in mind the following:

The programmer has no control over when the destructor is called
because this is determined by the garbage collector. The garbage
collector checks for objects that are no longer being used by the
application. If it considers an object eligible for destruction, it
calls the destructor (if any) and reclaims the memory used to store
the object. Destructors are also called when the program exits.

---

Related Topics