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

using System;

namespace ConfigurableConvertTest.GenericConverters
{
	/// <summary>
	/// This is a converter capable of doing any "already possible" conversion.
	/// That is, you want to convert a List of integers to an Enumerable of integers,
	/// or you want to convert the System.Int32 type to the System.Object type.
	/// The truth is, they are already child of those types, so a direct cast can
	/// be made. But we know, you are using a general-purpose conversion utility,
	/// so, why not tell that those conversions are available, even if it seems
	/// a little odd?
	/// </summary>
	public static class AlreadyCompatibleConverter
	{
		/// <summary>
		/// Gets a conversion from an input type to an output type, considering
		/// a cast is already valid from one to another.
		/// </summary>
		public static Delegate Get(Type inputType, Type outputType)
		{
			if (inputType == null)
				throw new ArgumentNullException("inputType");

			if (outputType == null)
				throw new ArgumentNullException("outputType");

			if (!outputType.IsAssignableFrom(inputType))
				throw new ArgumentException("outputType must already support the inputType (that is, inputType must be outputType or any of its subclasses).");

			var genericType = typeof(AlreadyCompatibleConverter<,>).MakeGenericType(inputType, outputType);
			var property = genericType.GetProperty("Instance");
			var converter = property.GetValue(null, null);
			return (Delegate)converter;
		}

		private static readonly SearchingConverterEventHandler _searchingConverterHandler = _SearchingConverter;
		/// <summary>
		/// Gets the Event Handler that you can use to add such natural conversion to the
		/// Converters class, so you make this available to your entire application.
		/// </summary>
		public static SearchingConverterEventHandler SearchingConverterHandler
		{
			get
			{
				return _searchingConverterHandler;
			}
		}
		private static void _SearchingConverter(SearchingConverterEventArgs args)
		{
			var inputType = args.InputType;
			var outputType = args.OutputType;
			if (outputType.IsAssignableFrom(inputType))
				args.Converter = Get(inputType, outputType);
		}
	}

	/// <summary>
	/// This is a converter capable of doing any "already possible" conversion.
	/// That is, you want to convert a List of integers to an Enumerable of integers,
	/// or you want to convert the System.Int32 type to the System.Object type.
	/// The truth is, they are already child of those types, so a direct cast can
	/// be made. But we know, you are using a general-purpose conversion utility,
	/// so, why not tell that those conversions are available, even if it seems
	/// a little odd?
	/// </summary>
	public static class AlreadyCompatibleConverter<TInput, TOutput>
	where
		TInput: TOutput
	{
		private static readonly Converter<TInput, TOutput> _instance = _Convert;

		/// <summary>
		/// Gets the Converter instance that will convert an input to an output type,
		/// when the input type is already a child (or even the same) output type.
		/// </summary>
		public static Converter<TInput, TOutput> Instance
		{
			get
			{
				return _instance;
			}
		}

		private static TOutput _Convert(TInput input)
		{
			return input;
		}
	}
}