C# 2008
I have been working on this for a while now, and I am still confused about the use of finalize and dispose methods in code. My questions are below:
-
I know that we only need a finalizer while disposing unmanaged resources. However, if there are managed resources that make calls to unmanaged resources, would it still need to implement a finalizer?
-
However, if I develop a class that doesn't use any unmanaged resource – directly or indirectly, should I implement the
IDisposable
to allow the clients of that class to use the 'using statement'?Would it be feasible to implement IDisposable just to enable clients of your class to use the using statement?
using(myClass objClass = new myClass()) { // Do stuff here }
-
I have developed this simple code below to demonstrate the Finalize/dispose use:
public class NoGateway : IDisposable { private WebClient wc = null; public NoGateway() { wc = new WebClient(); wc.DownloadStringCompleted += wc_DownloadStringCompleted; } // Start the Async call to find if NoGateway is true or false public void NoGatewayStatus() { // Start the Async's download // Do other work here wc.DownloadStringAsync(new Uri(www.xxxx.xxx)); } private void wc_DownloadStringCompleted(object sender, DownloadStringCompletedEventArgs e) { // Do work here } // Dispose of the NoGateway object public void Dispose() { wc.DownloadStringCompleted -= wc_DownloadStringCompleted; wc.Dispose(); GC.SuppressFinalize(this); } }
Question about the source code:
-
Here I have not added the finalizer, and normally the finalizer will be called by the GC, and the finalizer will call the Dispose. As I don't have the finalizer, when do I call the Dispose method? Is it the client of the class that has to call it?
So my class in the example is called NoGateway and the client could use and dispose of the class like this:
using(NoGateway objNoGateway = new NoGateway()) { // Do stuff here }
Would the Dispose method be automatically called when execution reaches the end of the using block, or does the client have to manually call the dispose method? i.e.
NoGateway objNoGateway = new NoGateway(); // Do stuff with object objNoGateway.Dispose(); // finished with it
-
I am using the
WebClient
class in myNoGateway
class. BecauseWebClient
implements theIDisposable
interface, does this mean thatWebClient
indirectly uses unmanaged resources? Is there a hard and fast rule to follow this? How do I know that a class uses unmanaged resources?
Best Answer
The recommended IDisposable pattern is here. When programming a class that uses IDisposable, generally you should use two patterns:
When implementing a sealed class that doesn't use unmanaged resources, you simply implement a Dispose method as with normal interface implementations:
When implementing an unsealed class, do it like this:
Notice that I haven't declared a finalizer in
B
; you should only implement a finalizer if you have actual unmanaged resources to dispose. The CLR deals with finalizable objects differently to non-finalizable objects, even ifSuppressFinalize
is called.So, you shouldn't declare a finalizer unless you have to, but you give inheritors of your class a hook to call your
Dispose
and implement a finalizer themselves if they use unmanaged resources directly:If you're not using unmanaged resources directly (
SafeHandle
and friends doesn't count, as they declare their own finalizers), then don't implement a finalizer, as the GC deals with finalizable classes differently, even if you later suppress the finalizer. Also note that, even thoughB
doesn't have a finalizer, it still callsSuppressFinalize
to correctly deal with any subclasses that do implement a finalizer.When a class implements the IDisposable interface, it means that somewhere there are some unmanaged resources that should be got rid of when you've finished using the class. The actual resources are encapsulated within the classes; you don't need to explicitly delete them. Simply calling
Dispose()
or wrapping the class in ausing(...) {}
will make sure any unmanaged resources are got rid of as necessary.