Code:
using System;

namespace FinalizeBenchmark {
    
    class Benchmark {

        /// <summary>
        /// Start with an arg to perform the Dispose benchmark.  Start with no args for a no dispose benchmark.
        /// </summary>
        static void Main(string[] args)    {
            // Get everything jitted
            DateTime x = DateTime.Now;
            FinalizeObject o = new FinalizeObject();
            o.DoSomeWork();
            o.Dispose();
            o = new FinalizeObject();

            // Collect and wait
            GC.Collect();
            GC.WaitForPendingFinalizers();

            // Benchmark
            if (args.Length != 0) {
                performBenchmarkDispose();
            } else {
                performBenchmarkNoDispose();
            }
        }


        static void performBenchmarkNoDispose() {
            DateTime start, end;
            start = DateTime.Now;
            for (int i = 0; i < 10000000; i++) {
                FinalizeObject o = new FinalizeObject();
                o.DoSomeWork();
            }
            GC.Collect();
            GC.WaitForPendingFinalizers();
            end = DateTime.Now;
            Console.WriteLine("No dispose time: {0}", end - start);
        }


        static void performBenchmarkDispose() {
            DateTime start, end;
            start = DateTime.Now;
            for (int i = 0; i < 10000000; i++) {
                FinalizeObject o = new FinalizeObject();
                o.DoSomeWork();
                o.Dispose();
            }
            GC.Collect();
            GC.WaitForPendingFinalizers();
            end = DateTime.Now;
            Console.WriteLine("Dispose time: {0}", end - start);
        }

    }


    class FinalizeObject : IDisposable {
        private volatile int someInt;
        private static Random random = new Random();

        public void DoSomeWork() {
            this.someInt = random.Next(10000000);
        }


        private bool disposed = false;

        public void Dispose() {
            Dispose(true);
            GC.SuppressFinalize(this);
        }


        protected void Dispose(bool disposing) {
            if (disposed) return;
            disposed = true;
            if (disposing) {
                // Dispose Managed resources
                // Not needed in this class, but we could have a reference to 
                // a managed object that has an unmanaged resource
            }
            // Unmanaged resources
            // Here we would get rid of direct unmanaged resources
        }


        ~FinalizeObject() {
            Dispose(false);    
        }
    }
}