using System;
using System.Diagnostics;
using System.Reflection;
using System.Threading.Tasks;
 
namespace ConsoleApplication1
{
    class Program
    {
        private String Output { get; set; }
 
        static void Main(string[] args)
        {
            var p = new Program();
            var stopwatch = new Stopwatch();
            
            stopwatch.Start();
            p.TestNormal(stopwatch);
 
            stopwatch.Restart();
            p.TestNormalPlinq(stopwatch);
 
            stopwatch.Restart();
            p.TestReflection(stopwatch);
 
            stopwatch.Restart();
            p.TestReflectionCached(stopwatch);
 
            stopwatch.Restart();
            p.TestReflectionCachedPlinq(stopwatch);
        }
 
        string ReturnDate()
        {
            return DateTime.Now.ToString();
        }
 
        void TestNormal(Stopwatch stopwatch)
        {
            this.Output = DateTime.Now.ToString();
 
            for (int x = 0; x < 200000; x++)
            {
 
                // *** Get Property Test - note we have to set the value here or else the compiler will optimize the assignment
                this.Output = DateTime.Now.ToString();
 
                var Value = this.Output;
 
                // *** Set Property Test
                this.Output = DateTime.Now.ToString();
 
                this.Output = this.ReturnDate();
            }
 
            Debug.WriteLine("Normal test used: " + stopwatch.ElapsedMilliseconds + "ms");
        }
 
        void TestNormalPlinq(Stopwatch stopwatch)
        {
            this.Output = DateTime.Now.ToString();
 
            Parallel.For(0,
                         200000,
                         (i) =>
                             {
 
                                 // *** Get Property Test - note we have to set the value here or else the compiler will optimize the assignment
                                 this.Output = DateTime.Now.ToString();
 
                                 var Value = this.Output;
 
                                 // *** Set Property Test
                                 this.Output = DateTime.Now.ToString();
 
                                 this.Output = this.ReturnDate();
                             });
 
            Debug.WriteLine("NormalPlinq test used: " + stopwatch.ElapsedMilliseconds + "ms");
        }
 
        void TestReflection(Stopwatch stopwatch)
        {
            for (int x = 0; x < 200000; x++)
            {
                this.Output = DateTime.Now.ToString();
                string Value = (string) this.GetType().GetProperty("Output", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(this, null);
                    //,BindingFlags.Instance | BindingFlags.NonPublic,null,null);
 
                // *** Set Property Test
                this.GetType().GetProperty("Output", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(this, DateTime.Now.ToString(), null);
                    //,BindingFlags.Instance | BindingFlags.NonPublic,null,null);
                string value = (string) this.GetType().GetMethod("ReturnDate", BindingFlags.NonPublic | BindingFlags.Instance).Invoke(this, null);
            }
            
            Debug.WriteLine("Reflect test used: " + stopwatch.ElapsedMilliseconds + "ms");
        }
 
        void TestReflectionCached(Stopwatch stopwatch)
        {
            var pi = this.GetType().GetProperty("Output", BindingFlags.Instance | BindingFlags.NonPublic);
            var mi = this.GetType().GetMethod("ReturnDate", BindingFlags.Instance | BindingFlags.NonPublic);
 
            Func<string> getter = () => (string) pi.GetValue(this, null);
            Action<string> setter = (s) => pi.SetValue(this, s, null);
            Func<string> getMethod = () => (string) mi.Invoke(this, null);
 
            for (int x = 0; x < 200000; x++)
            {
                this.Output = DateTime.Now.ToString();
                string Value = getter();
 
                setter(DateTime.Now.ToString());
 
                string value = getMethod();
            }
 
            Debug.WriteLine("ReflectCache test used: " + stopwatch.ElapsedMilliseconds + "ms");
        }
 
        void TestReflectionCachedPlinq(Stopwatch stopwatch)
        {
            var pi = this.GetType().GetProperty("Output", BindingFlags.Instance | BindingFlags.NonPublic);
            var mi = this.GetType().GetMethod("ReturnDate", BindingFlags.Instance | BindingFlags.NonPublic);
 
            Func<string> getter = () => (string)pi.GetValue(this, null);
            Action<string> setter = (s) => pi.SetValue(this, s, null);
            Func<string> getMethod = () => (string)mi.Invoke(this, null);
 
            Parallel.For(0, 200000,
                         (i) =>
                             {
                                 this.Output = DateTime.Now.ToString();
                                 string Value = getter();
 
                                 setter(DateTime.Now.ToString());
 
                                 string value = getMethod();
                             });
 
            Debug.WriteLine("ReflectCachePlinq test used: " + stopwatch.ElapsedMilliseconds + "ms");
        }
    }
}