C#

private System.Drawing.Icon ImageToIcon(System.Drawing.Image image)
{
   return System.Drawing.Icon.FromHandle(((Bitmap)image).Get Hicon());
}

Bitmap bitmapImage = new Bitmap(textBoxImageSource.Text);
Bitmap bitmapIcon = new Bitmap(32, 32);
Graphics graphics = Graphics.FromImage(bitmapIcon);
graphics.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
/* dont bother the x,y,w,and h.. i used them to scale the image. */
graphics.DrawImage(bitmapImage, x, y, w, h);
graphics.Flush();

public sealed class MyClass: IDisposable
{
// Variable to track if Dispose has been called
private bool disposed = false;
// Implement the IDisposable.Dispose() method
public void Dispose(){
// Check if Dispose has already been called
if (!disposed)
{
// Call the overridden Dispose method that contains common cleanup code
// Pass true to indicate that it is called from Dispose
Dispose(true);
// Prevent subsequent finalization of this object. This is not needed
// because managed and unmanaged resources have been explicitly released
GC.SuppressFinalize(this);
}
}
// Implement a finalizer by using destructor style syntax
~MyClass() {
// Call the overridden Dispose method that contains common cleanup code
// Pass false to indicate the it is not called from Dispose
Dispose(false);
}
// Implement the override Dispose method that will contain common
// cleanup functionality
protected virtual void Dispose(bool disposing){
if(disposing){
// Dispose time code
. . .
}
// Finalize time code
. . .
}
...
}

using (DisposableObject d = new DisposableObject())
{
   //...
}

DisposableObject d = new DisposableObject();
try
{
   //...
}
finally
{
   ((IDisposable)DisposableObject).Dispose();
}

class Handler
{
  private Socket sock = null;
  private Thread t = null;

  public Handler(Socket new_socket)
  {
     sock = new_socket;
     t = new Thread(DoSomeStuff());
  }

  public void DoSomeStuff()
  {
    //...do some processing here
  }
}

//... In the main thread:

server.Listen(10);

while(true)
{
  Socket new_client = server.Accept();
  new Handler(new_client);
}

invictus3 wrote:

Thanks for the excellent information.

invictus3 wrote:

So to sum it up, when will the Dispose() method be called? at the end of using() {} and whenever I call it explicitly, and when the GC decides that "for this object the Dispose() method needs to be called" ? Or will it happen for every object that has the IDisposable interface implemented?

1. At the end of the using statement.
   
2. When you call it explicitly.
   
3. When the GC runs a collection cycle and decides that an object needs to have the Dispose method called.

invictus3 wrote:

By the way, is a filehandler even needed to be cleaned up in the Dispose() or will the StreamWriter Disposer take care of it automatically?