���using System;

namespace GenericMethodBinder
{
    static class ExtensionMethods
    {
        public static void StringMethod(this string text)
        {
            Console.Write("This the specific extension method for the type string with the text ");
            Console.WriteLine(text);
        }

        public static void GenericMethod<T>(this T value)
        {
            Console.Write("This is the generic Extension Method for the type ");
            Console.Write(typeof(T).ToString());
            Console.Write(" called with the value ");
            Console.WriteLine(value.ToString());
        }
    }

    static class MethodBuilder<T>
    {
        static string text;

        static MethodBuilder()
        {
            text = "This is the generic Method for the type " + typeof(T).Name + " called with the value ";
        }

        public static void Method(T value)
        {
            Console.Write(text);
            Console.WriteLine(value.ToString());
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("We are going to play with three method types:");
            Console.WriteLine(" - Method from a generic type, using the type parameter");
            Console.WriteLine(" - Generic extension method");
            Console.WriteLine(" - Specific extension method (which is the same as a regular method)");
            Console.WriteLine("Direct usage of the methods with the string type, just to show you what happens...");
            MethodBuilder<string>.Method("toto");
            "toto".GenericMethod();
            "toto".StringMethod();
            Console.WriteLine();

            Console.WriteLine("Binding the various methods using MethodManager...");
            MethodManager.Bind<int>(MethodBuilder<int>.Method);
            MethodManager.Bind<float>(MethodBuilder<float>.Method);
            MethodManager.Bind<string>(ExtensionMethods.StringMethod);
            MethodManager.Bind<short>(ExtensionMethods.GenericMethod);
            MethodManager.Bind<double>(ExtensionMethods.GenericMethod);
            Console.WriteLine();

            Console.WriteLine("Using the methods with MethodCaller...");
            new MethodCaller<int>(42).CallMethod();
            new MethodCaller<float>(0.5f).CallMethod();
            new MethodCaller<string>("bla bla bla").CallMethod();
            new MethodCaller<short>(33).CallMethod();
            new MethodCaller<double>(666).CallMethod();
            Console.WriteLine();

            Console.WriteLine("And finally, we try to use the MethodManager asking for an uninitialized method...");
            try
            {
                new MethodCaller<char>('@').CallMethod();
                Console.WriteLine("And the call is successful.");
            }
            catch (NullReferenceException e)
            {
                Console.WriteLine("And the call is unsuccessful.");
                Console.WriteLine(e.Message);
            }
            Console.WriteLine();

            Console.WriteLine("We could check the bindings before trying to use them, like this: ");
            TestBinding<int>();
            TestBinding<string>();
            TestBinding<float>();
            TestBinding<decimal>();
            TestBinding<double>();
            TestBinding<char>();
            TestBinding<byte>();
            TestBinding<short>();
            Console.WriteLine();

            Console.WriteLine("That's it.");
        }

        static void TestBinding<T>()
        {
            Console.WriteLine("The method for type " + typeof(T).Name + " is " + (MethodManager.IsBound<T>() ? string.Empty : "not ") + "bound.");
        }
    }

    delegate void MethodDelegate<T>(T value);

    static class MethodManager
    {
        static class MethodHolder<T>
        {
            public static MethodDelegate<T> Method;
        }

        public static void Bind<T>(MethodDelegate<T> method)
        {
            MethodHolder<T>.Method = method;
        }

        public static void CallMethod<T>(T value)
        {
            MethodHolder<T>.Method(value);
        }

        public static bool IsBound<T>()
        {
            return MethodHolder<T>.Method != null;
        }
    }

    public class MethodCaller<T>
    {
        T value;

        public MethodCaller(T value)
        {
            this.value = value;
        }

        public void CallMethod()
        {
            MethodManager.CallMethod(value);
        }
    }
}