Difference between Collect and Dispose method

Please check the link

https://www.go4expert.com/articles/disposal-garbage-collection-c-sharp-t30059/ 

GC is garbage collection. It is the automatic memory management, that handles cleanup of objects allocated on the managed heap. The .NET GC employs a mark and sweep algorithm. When a garbage collection occurs it basically considers all object in the part of the heap to be cleaned as recoverable. Then it goes through a marking process where it scans for roots. I.e. it identifies objects that are still in use by the application. Having done that the remaining objects are eligible for cleanup. The heap may be compacted as part of the cleanup.

 

Dispose and finalizer methods both offer an option for cleaning resources, that are not handled by GC. E.g. this could be native handles and the like. They have nothing to do with reclaiming memory on the managed heap.

Dispose must be called explicitly on a type which implement IDisposable. It can be called either through the Dispose() method itself or via the using construct. The GC will not call Dispose automatically.

A finalizer or destructor (as the language specification calls it) on the other hand will automatically be called sometime after the object was eligible for cleanup. Finalize methods are executed sequentially on a dedicated thread.

Dispose() allows deterministic cleanup of resources while a finalizer can act as a safety net in case the user doesn't call Dispose().

If a type implements a finalizer, cleanup of instances is delayed as the finalizer must be called prior to cleanup. I.e. it will require an additional collect to reclaim the memory for instances of the type. If the type implements IDisposable as well, the Dispose method can be called and then the instance can remove itself from finalization. This will allow the object to be cleaned up as if it didn't have a finalizer.

If you want to dig into this, I recommend CLR via C# by Jeffrey Richter. It is a great book and it covers all the gory details of this (I left out a number of details).

Dispose  

=> Explicitly, it is called by user code and the class which is implementing dispose method, must has to implement    IDisposable interface.

=> It belongs to IDisposable interface.

Finalize

=> It can be used to free unmanaged resources (when you implement it) like files, database connections etc.

=> Internally, it is called by Garbage Collector and cannot be called by user code.

=> It belongs to Object class.

 

For more information please refer this link

https://www.dotnettricks.com/learn/netframework/difference-between-finalize-and-dispose-method 

Dispose method is not called automatically, you need to call it.

However, it can be implicitly called if you use "using" block, e.g.:

This is because at the end of the "using" block an IDisposable.Dispose method will be called:

 

Also, the Finalize method is never called, it is executed automatically by the Garbage Collector. 

Dispose Method is called automatically via Garbage Collector to release unused object.

But if programmer wants to delete any object specifically he could call Close/Finalize method