Converters class - Register all your data-type conversions in a single place

using System;
using System.Linq.Expressions;

namespace ConfigurableConvertTest.GenericConverters
{
	/// <summary>
	/// Contains the SearchingConverterHandler to allow enums to be converter to their
	/// underlying types (that is, convert an enum to int, usually, but if the underlying
	/// type is different, it works too).
	/// </summary>
    public static class EnumToUnderlyingConverter
    {
		private static readonly SearchingConverterEventHandler _searchingConverterHandler = _SearchingConverter;
		/// <summary>
		/// Gets the Event Handler that you can use to add enum to underlying types
		/// conversion to your Converters class.
		/// </summary>
		public static SearchingConverterEventHandler SearchingConverterHandler
		{
			get
			{
				return _searchingConverterHandler;
			}
		}
		private static void _SearchingConverter(SearchingConverterEventArgs args)
		{
			var inputType = args.InputType;
			var outputType = args.OutputType;

            if (inputType.IsEnum && outputType == Enum.GetUnderlyingType(inputType))
            {
                var type = typeof(EnumToUnderlyingConverter<,>).MakeGenericType(inputType, outputType);
                var property = type.GetProperty("Instance");
                var converter = property.GetValue(null, null);
                args.Converter = (Delegate)converter;
            }
		}
    }

	/// <summary>
	/// Contains a delegate to do a enum to underlying type conversion.
	/// </summary>
    public static class EnumToUnderlyingConverter<TEnum, TUnderlying>
    {
		/// <summary>
		/// Initializes the Instance property.
		/// </summary>
        static EnumToUnderlyingConverter()
        {
            if (!typeof(TEnum).IsEnum)
                throw new InvalidOperationException("TEnum should be an enum type.");

            if (Enum.GetUnderlyingType(typeof(TEnum)) != typeof(TUnderlying))
                throw new InvalidOperationException("TUnderlying should be the TEnum underlying type.");

			var parameterExpression = Expression.Parameter(typeof(TEnum));
			var convertExpression = Expression.Convert(parameterExpression, typeof(TUnderlying));
			var lambdaExpresson = Expression.Lambda<Converter<TEnum, TUnderlying>>(convertExpression, parameterExpression);
			var compiled = lambdaExpresson.Compile();
			_instance = compiled;
        }

        private static readonly Converter<TEnum, TUnderlying> _instance;
		/// <summary>
		/// Gets a conversion from an enum to its underlying type.
		/// </summary>
        public static Converter<TEnum, TUnderlying> Instance
        {
            get
            {
                return _instance;
            }
        }
    }
}