class MyFile : IDisposable
{
     // interface implementation IDisposable
     public virtual void Dispose()
     {
          // clean up managed resources
          // ...

          // clean up unmanaged resources
          // ...
     }

     // class destructor
     ~MyFile()
     {
          // clean up unmanaged resources
          // ...
     }
}

MyFile file = new MyFile("D://a.txt");

// add text to the file
file.AddTextToFile("Hello");

// close unmanaged resources
file.Dispose();

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

// we connect a library for working with files
using System.IO;

namespace ConsoleApplication1
{
     class MyFile : IDisposable
     {
          protected FileStream MyFileStream { get; set; }
          protected StreamWriter MyStream { get; set; }

          // class constructor
          public MyFile(string filePath)
          {
               // check if the file exists
               if (!File.Exists(filePath))
                    MyFileStream = File.Create(filePath); // create a file
               else
                    MyFileStream = File.Open(filePath, FileMode.Append); // open the file

               // open the stream
               MyStream = new StreamWriter(MyFileStream);
          }

          public void AddTextToFile(string text)
          {
               // write text to a file
               if (MyStream != null)
                    MyStream.Write(text);
          }

          // interface implementation IDisposable
          public virtual void Dispose()
          {
               // clean up managed resources
               if (MyStream != null)
               {
                    MyStream.Dispose();
                    MyStream = null;
               }

               if (MyFileStream != null)
               {
                    MyFileStream.Dispose();
                    MyFileStream = null;
               }

               // clean up unmanaged resources
               // ... we have no unmanaged resources
          }

          // class destructor
          ~MyFile()
          {
               // clean up unmanaged resources
               // ... we have no unmanaged resources
          }

     }

     class Program
     {
          static void Main(string[] args)
          {
               // after using {...} the file will be closed
               using (MyFile file = new MyFile("D://a.txt"))
               {
                    // add text to the file
                    file.AddTextToFile("Hello");
               }

          }
     }
}

using (Font font1 = new Font("Arial", 10.0f),
font2 = new Font("Arial", 10.0f))
{
     // ...
     // we work with font1 and font2
}

public class MyClass : IDisposable
{
     // class field
     private bool disposed = false;

     // interface implementation IDisposable
     public void Dispose()
     {
          Dispose(true);
         
          // tell the garbage collector that our facility has already freed up resources
          GC.SuppressFinalize(this);
     }

     protected virtual void Dispose(bool disposing)
     {
          if (!disposed)
          {
               if (disposing)
               {
                    // freeing up managed resources
                    // ...
               }

               // freeing up UNMANAGED resources
               // ...

               disposed = true;
          }
     }

     // class destructor
     ~MyClass()
     {
          Dispose(false);
     }
}

using Microsoft.Win32.SafeHandles;
using System;
using System.Runtime.InteropServices;

class DerivedClass : BaseClass
{
     // class field
     bool disposed = false;

     // our managed resource
     SafeHandle handle = new SafeFileHandle(IntPtr.Zero, true);

     // realization IDisposable
     protected override void Dispose(bool disposing)
     {
          if (disposed)
               return;

          if (disposing)
          {
               // freeing up managed resources
               handle.Dispose();
               // ...
          }

          // freeing up UNMANAGED resources
          // ...

          disposed = true;

          // call the base class
          base.Dispose(disposing);
     }
}