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