using System;
using System.Diagnostics;
using System.Linq;

#pragma warning disable 0169
public class SmallClass { int x; }
public class LargeClass { long a, b, c, d, e, f, g, h; }
public struct SmallStruct { int x; }
public struct LargeStruct { long a, b, c, d, e, f, g, h; }
#pragma warning restore 0169

public class Benchmark
{
    static Action[] Tests =
    {
        SmallStructWithConstraint,
        SmallStructWithProvider,
        LargeStructWithConstraint,
        LargeStructWithProvider,
        SmallClassWithConstraint,
        SmallClassWithProvider,
        LargeClassWithConstraint,
        LargeClassWithProvider,
    };
    
    private static void SmallStructWithConstraint()
    {
        MakeInstance<SmallStruct>();
    }
    
    private static void SmallStructWithProvider()
    {
        MakeInstance<SmallStruct>(() => new SmallStruct());
    }

    private static void LargeStructWithConstraint()
    {
        MakeInstance<LargeStruct>();
    }
    
    private static void LargeStructWithProvider()
    {
        MakeInstance<LargeStruct>(() => new LargeStruct());
    }

    private static void SmallClassWithConstraint()
    {
        MakeInstance<SmallClass>();
    }
    
    private static void SmallClassWithProvider()
    {
        MakeInstance<SmallClass>(() => new SmallClass());
    }

    private static void LargeClassWithConstraint()
    {
        MakeInstance<LargeClass>();
    }
    
    private static void LargeClassWithProvider()
    {
        MakeInstance<LargeClass>(() => new LargeClass());
    }
    
    private static void MakeInstance<T>() where T : new()
    {
        T t = new T();
        UseValue(t);
    }
    
    private static void MakeInstance<T>(Func<T> provider) where T : new()
    {
        T t = provider();
        UseValue(t);
    }
    
    private static void UseValue<T>(T instance)
    {
        // Do nothing...
    }
    
    
    // -------------- INFRASTRUCTURE BELOW HERE --------------
    const int Iterations = 100000000;
    
    static void Main()
    {
        Console.WriteLine("Environment: CLR {0} on {1}", Environment.Version, Environment.OSVersion);
        // Warm up
        RunTests(1, false, 0);
     
        int maxMethodLength = Tests.Select(x => x.Method.Name.Length).Max();
        
        // Real thing
        RunTests(Iterations, true, maxMethodLength);
    }
    
    static void RunTests(int count, bool displayResults, int maxLength)
    {
        foreach (Action action in Tests)
        {
            Stopwatch sw = Stopwatch.StartNew();
            for (int i = 0; i < count; i++)
            {
                action();
            }
            sw.Stop();            
            if (displayResults)
            {
                Console.WriteLine("{0}: {1}ms", action.Method.Name.PadRight(maxLength),
                                  ((int) sw.ElapsedMilliseconds).ToString().PadLeft(6));
            }
            GC.Collect();
            GC.WaitForPendingFinalizers();
            GC.Collect();
        }
    }
}