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