���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);
    }
  }
}