using System;
using System.Diagnostics;

namespace DelegPerf
{
    public abstract class Function<T, TR>
    {
        public abstract TR Invoke(T v);
    }

    class Program
    {
        private long x;

        private long Work(int n)
        {
            x += n;
            return x;
        }

        public sealed class MyFunction : Function<int, long>
        {
            private readonly Program p;

            public MyFunction(Program p)
            {
                this.p = p;
            }

            public override long Invoke(int n)
            {
                return p.Work(n);
            }
        }

        private static void Main()
        {
            const int M = 100;
            const int N = 10*1000*1000;

            var p = new Program();

            Func<int, long> myDelegate = p.Work;
            Function<int, long> myFunction = new MyFunction(p);

            long directBestResult = long.MaxValue;
            long delegateBestResult = long.MaxValue;
            long myFuncBestResult = long.MaxValue;

            p.Work(1);
            myDelegate(1);
            myFunction.Invoke(1);

            var sw = new Stopwatch();

            for (int i = 0; i < M; i++)
            {
                sw.Reset();
                sw.Start();
                for (int j = 0; j < N; j++)
                    p.Work(1);
                sw.Stop();
                directBestResult = Math.Min(directBestResult, sw.ElapsedTicks);

                sw.Reset();
                sw.Start();
                for (int j = 0; j < N; j++)
                    myDelegate(1);
                sw.Stop();
                delegateBestResult = Math.Min(delegateBestResult, sw.ElapsedTicks);

                sw.Reset();
                sw.Start();
                for (int j = 0; j < N; j++)
                    myFunction.Invoke(1);
                sw.Stop();
                myFuncBestResult = Math.Min(myFuncBestResult, sw.ElapsedTicks);
            }

            Console.WriteLine("Direct: {0}", directBestResult);
            Console.WriteLine("Delegate: {0}", delegateBestResult);
            Console.WriteLine("MyFunction: {0}", myFuncBestResult);
            Console.WriteLine("Delegate - Direct: {0}", delegateBestResult - directBestResult);
            Console.WriteLine("MyFunction - Direct: {0}", myFuncBestResult - directBestResult);

            Console.ReadKey();
        }
    }
}