I have Class A that implements the Disposable pattern in order to release unmanaged resources such as unsubscribing from events. Class B uses Class A, but does not wrap it in a using {..} block nor explicity calls A.Dispose(true) so A.dispose is called in A's finalizer via the standard Dispose(false) call. But then by setting the bool parameter to false, the unmanaged resources will not be cleaned up, i.e not unsubscribing from subscribed events. Shouldn't the finalizer be calling Dispose(true) or should Class B explicitly call A.Dispose(true) at some point such as in its own finalizer?
private bool _disposed = false; // To detect redundant calls
protected virtual void Dispose(bool disposing)
{
if (!_disposed)
{
if (disposing)
{
_promotionsSQLTableDependency.Stop();
_awardsSQLTableDependency.Stop();
_progressiveGeneratorService.OnProgressiveLevelsUpdate -= _progressiveUpdateHandler;
}
_disposed = true;
}
}
~PromotionHandler()
{
Dispose(false);
}
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
implements the Disposable pattern in order to release unmanaged resources such as unsubscribing from events.
Unsubscribing from an event isn't an unmanaged resource that needs to be cleaned up though.
Class B uses Class A, but does not wrap it in a using {..} block nor explicity calls A.Dispose(true)
You should treat that as a bug in your program. The whole point of implementing IDisposable is because that object needs to be explicitly cleaned up with the owner(s) are finished with it.
But then by setting the bool parameter to false, the unmanaged resources will not be cleaned up,
But those aren't unmanaged resources, which is why they aren't cleaned up in the finally block.
Shouldn't the finalizer be calling Dispose(true) or should Class B explicitly call A.Dispose(true) at some point such as in its own finalizer?
No. You shouldn't be interacting with managed objects in the finalizer. It's not safe to do so. Since you have no unmanaged resources to clean up in a finalizer, you shouldn't even have a finalizer.
The dispose method must only use the disposing parameter to decide whether to free managed resources. Unmanaged resources must always be freed.
protected virtual void Dispose(bool disposing)
{
if (!_disposed)
{
if (disposing)
{
// Free managed resources
}
// always free unmanaged resources
_disposed = true;
}
}
if the Dispose call happens via the garbage collector (=via a call to the Finalizer) and the disposing is false, you don't need to free the managed resources. The garbage collector will also call the Finalizer of those managed objects (maybe even earlier).
This is what the documentation says:
In the second overload, the disposing parameter is a Boolean that
indicates whether the method call comes from a Dispose method (its
value is true) or from a finalizer (its value is false).
The body of the method consists of two blocks of code:
A block that frees unmanaged resources. This block executes regardless of the value of the disposing parameter.
A conditional block that frees managed resources. This block executes if the value of disposing is true. The managed resources that
it frees can include:
Managed objects that implement IDisposable. The conditional block can be used to call their Dispose implementation. If you have used a
safe handle to wrap your unmanaged resource, you should call the
SafeHandle.Dispose(Boolean) implementation here.
Managed objects that consume large amounts of memory or consume scarce resources. Freeing these objects explicitly in the Dispose
method releases them faster than if they were reclaimed
non-deterministically by the garbage collector.
If the method call comes from a finalizer (that is, if disposing is
false), only the code that frees unmanaged resources executes. Because
the order in which the garbage collector destroys managed objects
during finalization is not defined, calling this Dispose overload with
a value of false prevents the finalizer from trying to release managed
resources that may have already been reclaimed.
In this answer I found,
Cleanup the unmanaged resources in the Finalize method and the
managed ones in the Dispose method, when the Dispose/Finalize pattern
has been used in your code.
And later I found this nice article about finalize and dispose and got a clear idea about them. The article has the following code(Page 3), to explain the concepts:
class Test : IDisposable
{
private bool isDisposed = false;
~Test()
{
Dispose(false);
}
protected void Dispose(bool disposing)
{
if (disposing)
{
// Code to dispose the managed resources of the class
}
// Code to dispose the un-managed resources of the class
isDisposed = true;
}
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
}
But below that, the same note (which I included in the beginning of this question) appears.
The Dispose/Finalize Pattern
Microsoft recommends that you implement both Dispose and Finalize when working with unmanaged resources. The correct sequence then would
be for a developer to call Dispose. The Finalize implementation would
run and the resources would still be released when the object is
garbage collected even if a developer neglected to call the Dispose
method explicitly. Francesco Balena writes in his blog "the
Dispose/Finalize pattern should be used only when your type invokes
unmanaged code that allocates unmanaged resources (including unmanaged
memory) and returns a handle that you must use eventually to release
the resource. Both dispose and finalize must chain up to their parent
objects by calling their parent's respective methods after they have
disposed or finalized their own members".
Simply put, cleanup the unmanaged resources in the Finalize method and the managed ones in the Dispose method, when the
Dispose/Finalize pattern has been used in your code.
Now I am confused again. In the entire article and in the code sample, it is shown that unmanaged resources should be freed in Dispose(). But then what is the relevance of that comment?
Edit:
As it is confirmed that this line :
Simply put, cleanup the unmanaged resources in the Finalize method and
the managed ones in the Dispose method, when the Dispose/Finalize
pattern has been used in your code
is erroneous, I edited this answer.
See its very simple.
If you are dealing with unmanaged resources - Implement both Dispose and Finalize. Dispose is to be called by developers to free up the resources as soon as they see it that its no longer needed for them. If they forget to call Dispose then Framework calls the finalize in its own GC cycle (usually will take its own sweet time).
If your object uses disposable objects internally - You implement Dispose() if you created and retained a reference to any object of a type which implements Dispose() and which you haven't already disposed.
If neither of the above is the case (you are NOT dealing with unmanaged resources nor your object uses disposable objects internally) - Then don't do anything. Don't implement Finalize nor Dispose.
Some classic examples:
System.IO.FileStream object manages the lock/stream handles to files. So it implements both dispose and finalize. If the developer disposes it then the other program can access it right away. If he forgets to dispose it then Framework finalize it and close the handles later in its GC cycle.
System.Text.StringBuilder dose not have any unmanaged resource. So no dispose no finalize.
As far as the pattern is concerned what it means to
// Code to dispose the managed resources of the class
is that call the Dispose methods of any .NET objects that you have as components inside that class
And
// Code to dispose the un-managed resources of the class
Means to close the raw handles and pointers. Here is your updated code with examples
class Test : IDisposable
{
private bool isDisposed = false;
~Test()
{
Dispose(false);
}
protected void Dispose(bool disposing)
{
if (!isDisposed)
{
if (disposing)
{
// Code to dispose the managed resources of the class
internalComponent1.Dispose();
internalComponent2.Dispose();
}
// Code to dispose the un-managed resources of the class
CloseHandle(handle);
handle = IntPtr.Zero;
isDisposed = true;
}
}
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
}
Here is an old question explaining it
If a Foo has resources which will benefit from deterministic cleanup, but none that can be usefully cleaned up in a finalizer, it should implement IDisposable but should not override Finalize or have a destructor. If a class holds multiple resources, and at least one can be cleaned up in a finalizer, then each discrete resource that could be cleaned up in a finalizer should be encapsulated into its own Finalizer/destructor-equipped object (which may be defined in a protected nested class), and the class that would contain those resources should hold references to the wrapper objects. Once that is done, the outer class will fit the pattern for classes with a Dispose method but no finalizer/destructor.
I have two code samples and I want to know what is the deifference between them and which is better to use as best practice and performance wise:
using (TestForm test = new TestForm())
{
test.ShowDialog();
}
and the other is:
TestForm test = null;
try
{
test = new TestForm();
test.ShowDialog();
}
catch(Exception ex)
{
}
finally
{
test = null;
}
The IDisposable interface defines the Dispose method, as well as the possibility to use the "using" syntax. The dispose method of a class can be implemented to release resources, close database connections and any sort of finalizing and cleanup. Just setting the class instance to null won't execute any of the code defined in the dispose method. As a generic rule, if a class implements IDisposable, dispose should be called when you're finished with the class instance.
Dispose() is for freeing unmanaged resources. This may be done in a finalizer as well (which might call Dispose()) but don't rely on it. If it isn't done, then you leak unmanaged resources.
Setting a reference to null only means that a particular reference no longer points to that object. It can live on quite a while after that (or even indefinitely if you have another reference – well, if you have multiple reference to an object you Dispose()d of, then it gets ugly, probably).
Generally, always call Dispose() on IDiposables when you're done with them. It's easier if you wrap them into a using statement:
using (var foo = new SomeDiposableObject()) {
// do something with foo
}
The IDisposable pattern is a mechanism to timely free unmanaged and managed resources that an object may be consuming.
The typical way the pattern is implemented is as follows:
public void Dispose() //Implementes the IDisposable interface
{
this.Dispose(true);
GC.SupressFinalize(this); //All resources have been released, no need to run the finalizer. We make the GC's life a little easier;
}
protected void Dispose(bool disposing)
{
if (disposing)
{
//Relesase managed resources.
}
//Release unmanaged resources.
}
~MyDisposableObject() //finalizer
{
this.Dispose(false)
}
The thing to note here is that the release of resources through the Dispose method is very similar to what you logically would expect to find in a finalizer. It is not done directly in the finalizer due to two main reasons:
the finalizer is not executed in a deterministic order. That is why we do not dispose managed resources from the finalizer (Dispose(false)), as some or all the managed resources held by the object might have been finalized before the object itself. This is not true with unmanaged resources as, by definition, they will never be finalized by the GC.
We do not know when the finalizer is run (it is up to the GC).
The basic idea is that an object implementing IDisposable is a sign for any consumer saying: "hey, I'm holding on to a certain amount of unmanaged and/or managed resources that will eventually be released when the GC decides I'm no longer useful, but if you need those resources back in a timely way, call Dispose() and I'll be happy to oblige.".
On the other hand, setting a reference variable to null is not freeing any resources at all. If the reference you have removed from the object was the only one to said object, then the object will eventually be collected by the GC and managed and unmanaged resources will be freed (when, is anyones guess).
If there were more live references still pointing to the object, then the object would live one and no resources whatsoever would be freed.
I have been programming in .NET for four years (mostly C#) and I use IDiposable extensively, but I am yet to find a need for a finaliser. What are finalisers for?
A finalizer is a last ditch attempt to ensure that something is cleaned up correctly, and is usually reserved for objects that wrap unmanaged resources, such as unmanaged handles etc that won't get garbage collected.
It is rare indeed to write a finalizer. Fortunately (and unlike IDisposable), finalizers don't need to be propagated; so if you have a ClassA with a finalizer, and a ClassB which wraps ClassA, then ClassB does not need a finalizer - but quite likely both ClassA and ClassB would implement IDisposable.
For managed code, IDisposable is usually sufficient. Even if you don't clean up correctly, eventually the managed objects will get collected (assuming they are released).
Finalizers are only for freeing unmanaged resources like GDI bitmap handles for example. If you don't allocate any unmanaged resources then you don't need finalizers. In general it's a bad idea to touch any managed object in a finalizer because the order of finalization is not guaranteed.
One other useful technique using a finalizer is to assert that Dispose has been called when the application is required to do so. This can help catch coding errors in a DEBUG build:
void Dispose()
{
GC.SuppressFinalize(this);
}
#if DEBUG
~MyClass()
{
Debug.Fail("Dispose was not called.");
}
#endif
Finalizers are meant as a mechanism to release resources not controlled by garbage collector, like an unmanaged handle. While Dispose might do it, it isn't guaranteed that the consumer will call it.
Finalizers are for cleaning up resources if they were not disposed.
IE, nothing enforces that you ever call Dispose(), but Finalizers are called automatically by the garbage collector.
This functionality should not be relied upon, as there is no guarantee when (or if) garbage collection will get to your object.
Wikipedia says:
...a finalizer is a piece of code that
ensures that certain necessary actions
are taken when an acquired resource...
is no longer being used [because the
owning object has been garbage
collected]
And if you're not using a finaliser when you're writing IDisposables you've quite possibly got memory leaks, because there's no guarantee an owner is actually going to call Dispose().
MS themselves recommend you write something similar to this into your implementers:
public void Dispose()
{
this.Dispose(true);
}
protected virtual void Dispose(bool disposing)
{
if (!this.isDisposed)
{
if (disposing)
{
GC.SuppressFinalize(this);
}
}
//Dispose of resources here
this.isDisposed = true;
}
~DisposableSafe()
{
this.Dispose(false);
}
private bool isDisposed = false;
Personally, I can't stand the copy-paste so I tend to wrap that in an abstract class for reuse.
Why do some people use the Finalize method over the Dispose method?
In what situations would you use the Finalize method over the Dispose method and vice versa?
The finalizer method is called when your object is garbage collected and you have no guarantee when this will happen (you can force it, but it will hurt performance).
The Dispose method on the other hand is meant to be called by the code that created your class so that you can clean up and release any resources you have acquired (unmanaged data, database connections, file handles, etc) the moment the code is done with your object.
The standard practice is to implement IDisposable and Dispose so that you can use your object in a using statment. Such as using(var foo = new MyObject()) { }. And in your finalizer, you call Dispose, just in case the calling code forgot to dispose of you.
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.
Finalize is the backstop method, called by the garbage collector when it reclaims an object. Dispose is the "deterministic cleanup" method, called by applications to release valuable native resources (window handles, database connections, etc.) when they are no longer needed, rather than leaving them held indefinitely until the GC gets round to the object.
As the user of an object, you always use Dispose. Finalize is for the GC.
As the implementer of a class, if you hold managed resources that ought to be disposed, you implement Dispose. If you hold native resources, you implement both Dispose and Finalize, and both call a common method that releases the native resources. These idioms are typically combined through a private Dispose(bool disposing) method, which Dispose calls with true, and Finalize calls with false. This method always frees native resources, then checks the disposing parameter, and if it is true it disposes managed resources and calls GC.SuppressFinalize.
Finalize gets called by the GC when this object is no longer in use.
Dispose is just a normal method which the user of this class can call to release any resources.
If user forgot to call Dispose and if the class have Finalize implemented then GC will make sure it gets called.
Finalize
Finalizers should always be protected, not public or private so that the method cannot be called from the application's code directly and at the same time, it can make a call to the base.Finalize method
Finalizers should release unmanaged resources only.
The framework does not guarantee that a finalizer will execute at all on any given instance.
Never allocate memory in finalizers or call virtual methods from finalizers.
Avoid synchronization and raising unhandled exceptions in the finalizers.
The execution order of finalizers is non-deterministic—in other words, you can't rely on another object still being available within your finalizer.
Do not define finalizers on value types.
Don't create empty destructors. In other words, you should never explicitly define a destructor unless your class needs to clean up unmanaged resources and if you do define one, it should do some work. If, later, you no longer need to clean up unmanaged resources in the destructor, remove it altogether.
Dispose
Implement IDisposable on every type that has a finalizer
Ensure that an object is made unusable after making a call to the Dispose method. In other words, avoid using an object after the Dispose method has been called on it.
Call Dispose on all IDisposable types once you are done with them
Allow Dispose to be called multiple times without raising errors.
Suppress later calls to the finalizer from within the Dispose method using the GC.SuppressFinalize method
Avoid creating disposable value types
Avoid throwing exceptions from within Dispose methods
Dispose/Finalized Pattern
Microsoft recommends that you implement both Dispose and Finalize when working with unmanaged resources. The Finalize implementation would run and the resources would still be released when the object is garbage collected even if a developer neglected to call the Dispose method explicitly.
Cleanup the unmanaged resources in the Finalize method as well as Dispose method. Additionally call the Dispose method for any .NET objects that you have as components inside that class(having unmanaged resources as their member) from the Dispose method.
There're some keys about from the book MCSD Certification Toolkit (exam 70-483) pag 193:
destructor ≈(it's almost equal to) base.Finalize(), The destructor is converted into an override version of the Finalize method that executes the destructor’s code and then calls the base class’s Finalize method. Then its totally non deterministic you can't able to know when will be called because depends on GC.
If a class contains no managed resources and no unmanaged resources, it shouldn't implement IDisposable or have a destructor.
If the class has only managed resources, it should implement IDisposable but it shouldn't have a destructor. (When the destructor executes, you can’t be sure managed objects still
exist, so you can’t call their Dispose() methods anyway.)
If the class has only unmanaged resources, it needs to implement IDisposable and needs a destructor in case the program doesn’t call Dispose().
Dispose() method must be safe to run more than once. You can achieve that by using a variable to keep track of whether it has been run before.
Dispose() should free both managed and unmanaged resources.
The destructor should free only unmanaged resources. When the destructor executes, you
can’t be sure managed objects still exist, so you can’t call their Dispose methods anyway. This is obtained by using the canonical protected void Dispose(bool disposing) pattern, where only managed resources are freed (disposed) when disposing == true.
After freeing resources, Dispose() should call GC.SuppressFinalize, so the object can
skip the finalization queue.
An Example of a an implementation for a class with unmanaged and managed resources:
using System;
class DisposableClass : IDisposable
{
// A name to keep track of the object.
public string Name = "";
// Free managed and unmanaged resources.
public void Dispose()
{
FreeResources(true);
// We don't need the destructor because
// our resources are already freed.
GC.SuppressFinalize(this);
}
// Destructor to clean up unmanaged resources
// but not managed resources.
~DisposableClass()
{
FreeResources(false);
}
// Keep track if whether resources are already freed.
private bool ResourcesAreFreed = false;
// Free resources.
private void FreeResources(bool freeManagedResources)
{
Console.WriteLine(Name + ": FreeResources");
if (!ResourcesAreFreed)
{
// Dispose of managed resources if appropriate.
if (freeManagedResources)
{
// Dispose of managed resources here.
Console.WriteLine(Name + ": Dispose of managed resources");
}
// Dispose of unmanaged resources here.
Console.WriteLine(Name + ": Dispose of unmanaged resources");
// Remember that we have disposed of resources.
ResourcesAreFreed = true;
}
}
}
99% of the time, you should not have to worry about either. :) But, if your objects hold references to non-managed resources (window handles, file handles, for example), you need to provide a way for your managed object to release those resources. Finalize gives implicit control over releasing resources. It is called by the garbage collector. Dispose is a way to give explicit control over a release of resources and can be called directly.
There is much much more to learn about the subject of Garbage Collection, but that's a start.
The finalizer is for implicit cleanup - you should use this whenever a class manages resources that absolutely must be cleaned up as otherwise you would leak handles / memory etc...
Correctly implementing a finalizer is notoriously difficult and should be avoided wherever possible - the SafeHandle class (avaialble in .Net v2.0 and above) now means that you very rarely (if ever) need to implement a finalizer any more.
The IDisposable interface is for explicit cleanup and is much more commonly used - you should use this to allow users to explicitly release or cleanup resources whenever they have finished using an object.
Note that if you have a finalizer then you should also implement the IDisposable interface to allow users to explicitly release those resources sooner than they would be if the object was garbage collected.
See DG Update: Dispose, Finalization, and Resource Management for what I consider to be the best and most complete set of recommendations on finalizers and IDisposable.
Diff between Finalize and Dispose methods in C#.
GC calls the finalize method to reclaim the unmanaged resources(such as file operarion, windows api, network connection, database connection) but time is not fixed when GC would call it. It is called implicitly by GC it means we do not have low level control on it.
Dispose Method: We have low level control on it as we call it from the code. we can reclaim the unmanaged resources whenever we feel it is not usable.We can achieve this by implementing IDisposal pattern.
The summary is -
You write a finalizer for your class if it has reference to unmanaged
resources and you want to make sure that those unmanaged resources
are released when an instance of that class is garbage collected
automatically. Note that you can't call the Finalizer of an object explicitly - it's called automatically by the garbage collector as and when it deems necessary.
On the other hand, you implement the IDisposable interface(and
consequently define the Dispose() method as a result for your class) when your class
has reference to unmanaged resources, but you don't want to wait for
the garbage collector to kick in (which can be anytime - not in
control of the programmer) and want to release those resources as
soon as you are done. Thus, you can explicitly release unmanaged resources by calling an object's Dispose() method.
Also, another difference is - in the Dispose() implementation, you should release managed resources as well, whereas that should not be done in the Finalizer. This is because it's very likely that the managed resources referenced by the object have already been cleaned up before it's ready to be finalized.
For a class that uses unmanaged resources, the best practice is to define both - the Dispose() method and the Finalizer - to be used as a fallback in case a developer forgets to explicitly dispose off the object. Both can use a shared method to clean up managed and unmanaged resources :-
class ClassWithDisposeAndFinalize : IDisposable
{
// Used to determine if Dispose() has already been called, so that the finalizer
// knows if it needs to clean up unmanaged resources.
private bool disposed = false;
public void Dispose()
{
// Call our shared helper method.
// Specifying "true" signifies that the object user triggered the cleanup.
CleanUp(true);
// Now suppress finalization to make sure that the Finalize method
// doesn't attempt to clean up unmanaged resources.
GC.SuppressFinalize(this);
}
private void CleanUp(bool disposing)
{
// Be sure we have not already been disposed!
if (!this.disposed)
{
// If disposing equals true i.e. if disposed explicitly, dispose all
// managed resources.
if (disposing)
{
// Dispose managed resources.
}
// Clean up unmanaged resources here.
}
disposed = true;
}
// the below is called the destructor or Finalizer
~ClassWithDisposeAndFinalize()
{
// Call our shared helper method.
// Specifying "false" signifies that the GC triggered the cleanup.
CleanUp(false);
}
The best example which i know.
public abstract class DisposableType: IDisposable
{
bool disposed = false;
~DisposableType()
{
if (!disposed)
{
disposed = true;
Dispose(false);
}
}
public void Dispose()
{
if (!disposed)
{
disposed = true;
Dispose(true);
GC.SuppressFinalize(this);
}
}
public void Close()
{
Dispose();
}
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
// managed objects
}
// unmanaged objects and resources
}
}
The main difference between Dispose and Finalize is that:
Dispose is usually called by your code. The resources are freed instantly when you call it. People forget to call the method, so using() {} statement is invented. When your program finishes the execution of the code inside the {}, it will call Dispose method automatically.
Finalize is not called by your code. It is mean to be called by the Garbage Collector (GC). That means the resource might be freed anytime in future whenever GC decides to do so. When GC does its work, it will go through many Finalize methods. If you have heavy logic in this, it will make the process slow. It may cause performance issues for your program. So be careful about what you put in there.
I personally would write most of the destruction logic in Dispose. Hopefully, this clears up the confusion.
Class instances often encapsulate control over resources that are not managed by the runtime, such as window handles (HWND), database connections, and so on. Therefore, you should provide both an explicit and an implicit way to free those resources. Provide implicit control by implementing the protected Finalize Method on an object (destructor syntax in C# and the Managed Extensions for C++). The garbage collector calls this method at some point after there are no longer any valid references to the object.
In some cases, you might want to provide programmers using an object with the ability to explicitly release these external resources before the garbage collector frees the object. If an external resource is scarce or expensive, better performance can be achieved if the programmer explicitly releases resources when they are no longer being used. To provide explicit control, implement the Dispose method provided by the IDisposable Interface. The consumer of the object should call this method when it is done using the object. Dispose can be called even if other references to the object are alive.
Note that even when you provide explicit control by way of Dispose, you should provide implicit cleanup using the Finalize method. Finalize provides a backup to prevent resources from permanently leaking if the programmer fails to call Dispose.
I searched the answer to this question a lot today. I will share my learnings here. My answer is based on this link, because it has the clearest explanation I have seen.
When your objects has access to unmanaged resources, you have to manually release those resources. This can be done via IDisposable or finalizer meaning they both release unmanaged resources.
Rule of thumb:
Implement IDisposable to release unmanaged resources and caller code must call Dispose method. If caller forgets to call Dispose() method, you still can provide a method to release those unmanaged resources. First option is using safe handle to wrap unmanaged resource. Second option is defining a finalizer. Using safe handle is recommended way in this case.
I think this link is the clearest answer to this question. I do not know why people provide complex explanations to this question on the internet. It made me feel confused until I find that link.
As we know dispose and finalize both are used to free unmanaged resources..
but the difference is finalize uses two cycle to free the resources , where as dispose uses one cycle..
To answer on the first part you should provide examples where people use
different approach for the exact same class-object.
Otherwise it is difficult (or even strange) to answer.
As for the second question better read first this
Proper use of the IDisposable interface
which claims that
It's your choice! But choose Dispose.
In other words: The GC only knows about finalizer (if any. Also known as destructor to Microsoft).
A good code will attempt to cleanup from both (finalizer and Dispose).