{"id":63,"date":"2014-05-23T05:43:00","date_gmt":"2014-05-23T04:43:00","guid":{"rendered":"https:\/\/debuggersspace.com\/index.php\/2014\/05\/23\/what-is-the-use-significance-of-dispose-and-finalize-method\/"},"modified":"2014-05-23T05:43:00","modified_gmt":"2014-05-23T04:43:00","slug":"what-is-the-use-significance-of-dispose-and-finalize-method","status":"publish","type":"post","link":"https:\/\/debuggersspace.com\/index.php\/2014\/05\/23\/what-is-the-use-significance-of-dispose-and-finalize-method\/","title":{"rendered":"What is the use\/significance of Dispose and Finalize method?"},"content":{"rendered":"
\n
\n \t<\/i> Read Time:<\/span>4 Minute, 55 Second <\/div>\n\n <\/div>
\n
\n.NET Framework provides two methods Finalize and Dispose for
\nreleasing unmanaged resources like: <\/span>Windows API created objects, File,
\nDatabase connection objects, COM objects<\/span>.<\/span><\/o:p><\/span><\/div>\n
\nIt is always recommended to use Dispose method to clean
\nunmanaged resources. Do not implement the Finalize method until it is extremely
\nnecessary<\/span><\/o:p><\/span><\/div>\n
\nDispose:<\/span><\/u><\/o:p><\/span><\/div>\n
\n<\/div>\n
\nDispose <\/span>method belongs to \u2018<\/span>IDisposable<\/span>\u2019 interface. If any
\nobject wants to release its unmanaged code, the best is to implement <\/span>IDisposable <\/span>and override
\nthe <\/span>Dispose <\/span>method  of <\/span>IDisposable <\/span>interface. Now once
\nyour class has exposed the <\/span>Dispose<\/span> method, it is
\nthe responsibility of the client to call the <\/span>Dispose <\/span>method to do the
\ncleanup. <\/span>
\n
<\/span><\/div>\n
\n
\n

\n<\/span><\/o:p><\/span><\/div>\n
\nHow do I force the <\/span><\/b>Dispose <\/span><\/b>method to be called
\nautomatically, as clients can forget to call <\/span><\/b>Dispose <\/span><\/b>method?<\/span><\/b><\/o:p><\/span><\/div>\n
\n<\/div>\n
\nCall the <\/span>Dispose <\/span>method in <\/span>Finalize <\/span>method and in <\/span>Dispose <\/span>method, suppress
\nthe <\/span>finalize <\/span>method using <\/span>GC.SuppressFinalize<\/span>. <\/o:p><\/span><\/div>\n
\n<\/div>\n
\nBelow is the sample code of the pattern. This is the best way we
\ndo clean our unallocated resources and yes not to forget we do not get the hit
\nof running the Garbage collector twice.

\n

\n<\/span><\/o:p><\/span><\/div>\n
\n
\n <\/span><\/span>public<\/span> <\/span>class<\/span> CleanClass :
\nIDisposable<\/o:p><\/span><\/div>\n
\n    <\/span>{<\/o:p><\/span><\/div>\n
\n        <\/span><\/span>public<\/span> <\/span>void<\/span> Dispose()<\/o:p><\/span><\/div>\n
\n        <\/span>{<\/o:p><\/span><\/div>\n
\n            <\/span>GC.SuppressFinalize(<\/span>this<\/span>);<\/o:p><\/span><\/div>\n
\n        <\/span>}<\/o:p><\/span><\/div>\n
\n         <\/span><\/o:p><\/span><\/div>\n
\n        <\/span>~CleanClass()<\/o:p><\/span><\/div>\n
\n        <\/span>{<\/o:p><\/span><\/div>\n
\n            <\/span>Dispose();<\/o:p><\/span><\/div>\n
\n         <\/span>}<\/o:p><\/span><\/div>\n
\n    <\/span>} <\/span><\/o:p><\/span><\/div>\n<\/div>\n
\n
\n<\/span>Finalize:<\/span><\/u><\/o:p><\/span><\/div>\n
\n
\n.NET Garbage collector does almost all clean up activity for your objects. But
\nunmanaged resources (example: Windows API created objects, File, Database
\nconnection objects, COM objects, etc.) are outside the scope of .NET Framework.
\nWe have to explicitly clean our resources. For these types of objects, .NET
\nFramework provides<\/span>Object.Finalize <\/span>method.<\/span><\/o:p><\/span><\/div>\n
\n<\/div>\n
\n
\nWhat is the difference between Finalize() and Dispose() methods?<\/b><\/span><\/o:p><\/span><\/div>\n
\n<\/div>\n
\nDispose:<\/span><\/u><\/o:p><\/span><\/div>\n
    \n
  1. Dispose
    \n It belongs to IDisposable interface. and internal called by user code.<\/span><\/o:p><\/span><\/li>\n
  2. Dispose
    \n () of IDisposable interface is called by the programmer to explicitly
    \n release resources when they are no longer being used. Dispose () can be
    \n called even if other references to the object are alive.<\/span><\/o:p><\/span><\/li>\n
  3. It
    \n is called by user code and the class implementing dispose method must
    \n implement IDisposable interface.It belongs to IDisposable
    \n interface.Implement this when you are writing a custom class that will be
    \n used by other users.There is no performance costs associated with Dispose
    \n method<\/span><\/o:p><\/span><\/li>\n<\/ol>\n
    \nFinalize:<\/span><\/u><\/o:p><\/span><\/div>\n
      \n
    1. Finalize
      \n It belongs to Object class. and It’s implemented with the help of
      \n destructor in C#.<\/span><\/o:p><\/span><\/li>\n
    2. Used
      \n to free unmanaged resources like files, database connections, COM etc.
      \n held by an object before that object is destroyed.Internally, it is called
      \n by Garbage Collector and cannot be called by user code.<\/span><\/o:p><\/span><\/li>\n
    3. The
      \n finalizer method is called when your object is garbage collected and you
      \n have no guarantee when this will happen (you can force it, but it will
      \n hurt performance).<\/span><\/o:p><\/span><\/li>\n<\/ol>\n
      \n
      \nWhy is it preferred to not use finalize for clean up?<\/span><\/b><\/o:p><\/span><\/div>\n
      \n
      \nThe problem with f<\/span>inalize <\/span>is that garbage collection has to make two rounds in order
      \nto remove objects which have f<\/span>inalize <\/span>methods.<\/span><\/o:p><\/span><\/div>\n
      \n<\/div>\n
      \nLet us assume, there are three objects, <\/span>Object1<\/span>, <\/span>Object2<\/span>, and <\/span>Object3<\/span>. <\/span><\/o:p><\/span><\/div>\n
      \n
      \n<\/span>Object2 <\/span>has the finalize method overridden and remaining objects
      \ndo not have the <\/span>finalize <\/span>method overridden.<\/span><\/o:p><\/span><\/div>\n
      \n<\/div>\n
      \nNow when garbage collector runs for the first time, it searches
      \nfor objects whose memory has to free. It can see three objects but only cleans
      \nthe memory for <\/span>Object1 <\/span>and <\/span>Object3<\/span>. <\/span><\/o:p><\/span><\/div>\n
      \n
      \n<\/span>Object2 <\/span>it pushes to the finalization queue.<\/span><\/o:p><\/span><\/div>\n
      \n<\/div>\n
      \nNow garbage collector runs for the second time. It sees there
      \nare no objects to be released and then checks for the finalization queue and at
      \nthis moment, it clears <\/span>object2 <\/span>from the memory. <\/span><\/o:p><\/span><\/div>\n
      \n
      \nSo if you notice, <\/span>object2 <\/span>was released from memory in the second round and not
      \nfirst. That is why the best practice is not to write clean up
      \nnon.NET\/unmanaged resources in <\/span>Finalize <\/span>method rather use
      \nthe <\/span>DISPOSE<\/span>.<\/span><\/o:p><\/span><\/p>\n

      <\/span><\/p>\n

      \nWhat
      \nis the purpose of the Using block in C#?<\/span><\/b><\/div>\n
      \n
      <\/span><\/div>\n
      \nThe using statement allows the programmer to specify when
      \nobjects that use resources should release them. The object provided to the
      \nusing statement must implement the IDisposable interface. This interface
      \nprovides the Dispose method, which should release the object’s resources.<\/span><\/div>\n<\/div>\n
      \n
      \n
      <\/span><\/span>\n<\/div>\n
      \n<\/o:p><\/span><\/div>\n
      public<\/span><\/span> <\/span><\/span><\/span>class<\/span><\/span><\/span> <\/span><\/span><\/span>Debuggersspace<\/span><\/span> <\/span><\/span><\/span>:<\/span><\/span><\/span> <\/span><\/span><\/span>IDisposable<\/span><\/span><\/span><\/span><\/pre>\n
      {<\/pre>\n
       \/\/<\/span><\/span>implementation details<\/span><\/span><\/span>...<\/span><\/span><\/span><\/pre>\n
      }<\/pre>\n
      \n<\/pre>\n

      \n<\/span><\/span><\/span><\/p>\n
      \nThese
      \nare equivalent:<\/span><\/span><\/span><\/span>
      \nDebuggersspace<\/span><\/span> <\/span>qa <\/span><\/span><\/span>=<\/span><\/span><\/span> <\/span><\/span><\/span>new<\/span><\/span><\/span> <\/span><\/span><\/span>Debuggersspace<\/span><\/span> <\/span><\/span><\/span>();<\/span><\/span><\/span><\/span><\/span><\/span>
      \ntry<\/span><\/span> <\/span><\/span><\/span><\/span><\/span><\/span>
      \n<\/span>{<\/span><\/span><\/span><\/span><\/span><\/span>
      \n        <\/span>qa<\/span><\/span>.<\/span><\/span><\/span>Action<\/span><\/span><\/span>();<\/span><\/span><\/span><\/span><\/span><\/span>
      \n}<\/span><\/span><\/span><\/span>
      \nfinally<\/span><\/span><\/span><\/span><\/span>
      \n{<\/span>
      \n       <\/span><\/span>if<\/span><\/span> <\/span><\/span><\/span>(<\/span><\/span><\/span>qa <\/span><\/span><\/span>!=<\/span><\/span><\/span> <\/span><\/span><\/span>null<\/span><\/span><\/span>)<\/span><\/span><\/span><\/span><\/span><\/span>
      \n       qa<\/span><\/span>.<\/span><\/span>Dispose<\/span><\/span><\/span>();<\/span><\/span><\/span><\/span><\/span><\/span>
      \n}<\/span><\/span><\/span><\/span>
      \n
      <\/span><\/span><\/span><\/span>
      \nIn other words, the <\/span>using<\/span><\/code> statement tells .NET to release the object specified in the <\/span>using<\/span><\/code> block once it is no longer needed<\/span><\/span><\/span><\/span><\/span>
      \n
      <\/span><\/span><\/span><\/span><\/span>
      \nusing <\/span><\/span><\/span>(<\/span><\/span><\/span>Debuggersspace<\/span><\/span> <\/span>qa <\/span><\/span><\/span>=<\/span><\/span><\/span> <\/span><\/span><\/span>new<\/span><\/span><\/span> <\/span><\/span><\/span>Debuggersspace<\/span><\/span> <\/span><\/span><\/span>())<\/span><\/span><\/span><\/span><\/span><\/span>
      \n{<\/span><\/span><\/span><\/span>
      \n    <\/span>qa<\/span><\/span>.<\/span><\/span>Action<\/span><\/span><\/span>();<\/span><\/span><\/span> <\/span><\/span><\/span><\/span>
      \n}<\/span><\/span><\/span><\/span><\/div>\n
      <\/p>\n
      \nPoints to remember:<\/span><\/div>\n
      \n<\/div>\n
        \n
      1. If you declare the
        \nvariable outside the using block and then create a new instance in the using
        \nstatement it may not dispose the item<\/span><\/li>\n
      2. So the using
        \nstatement will automatically dispose of the object once that context is complete.<\/span><\/li>\n
      3. The using statement
        \nis used to work with an object in C# that implements the IDisposable<\/span><\/code>interface.<\/span><\/li>\n
      4. The IDisposable<\/span><\/code> interface has one public method called <\/span>Dispose<\/span><\/code> that is used to dispose of the object.<\/span><\/li>\n
      5. we use the using
        \nstatement, we don’t need to explicitly dispose of the object in the code, the
        \nusing statement takes care of it.<\/li>\n<\/ol>\n
        <\/span><\/span><\/span><\/span><\/span><\/span><\/span><\/span><\/span>
        <\/span>
        \n<\/p>\n
        \n<\/div>\n
        \n
        \nC# Disposable pattern, Using, Dispose Vs Finalize:<\/o:p><\/span><\/b><\/div>\n<\/h1>\n
        \n
        <\/span><\/div>\n<\/div>\n
        \n
        \n