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

using System;

namespace ConfigurableConvertTest.GenericConverters
{
    /// <summary>
    /// Holds the SearchingConverterHandler that you can add to your Converters class
    /// to make it capable of converting compatible delegate types (for example, Action
    /// to ThreadStart).
    /// </summary>
    public static class DelegateConverter
    {
        private static readonly SearchingConverterEventHandler _searchingConverterHandler = _Searching;
        /// <summary>
        /// Gets the handler that will add delegate conversions to your application.
        /// </summary>
        public static SearchingConverterEventHandler SearchingConverterHandler
        {
            get
            {
                return _searchingConverterHandler;
            }
        }

        /// <summary>
        /// Does a conversion from a delegate of any type to the
        /// TResultDelegate type.
        /// </summary>
        public static TResultDelegate Convert<TResultDelegate>(Delegate input)
        where
            TResultDelegate: class // unfortunatelly, we can't use Delegate as a constraint.
        {
            if (input == null)
                return null;

            var target = input.Target;
            var method = input.Method;
            object result = Delegate.CreateDelegate(typeof(TResultDelegate), target, method);
            return (TResultDelegate)result;
        }

        private static void _Searching(SearchingConverterEventArgs args)
        {
            var inputType = args.InputType;
            if (!typeof(Delegate).IsAssignableFrom(inputType))
                return;

            var outputType = args.OutputType;
            if (!typeof(Delegate).IsAssignableFrom(outputType))
                return;

            var type = typeof(DelegateConverter<,>).MakeGenericType(inputType, outputType);
            var property = type.GetProperty("Instance");
            var converter = property.GetValue(null, null);
            args.Converter = (Delegate)converter;
        }
    }


    /// <summary>
    /// This class holds a converter capable of converting
    /// delegates of type TInput to delegates of type TOutput.
    /// Both delegates must be already equivalent, like happens with 
    /// ThreadStart and Action.
    /// </summary>
    public static class DelegateConverter<TInput, TOutput>
    where
        TInput: class
    where
        TOutput: class
    {
        static DelegateConverter()
        {
            if (!typeof(Delegate).IsAssignableFrom(typeof(TInput)))
                throw new ArgumentException("TInput should be a delegate.");

            if (!typeof(Delegate).IsAssignableFrom(typeof(TOutput)))
                throw new ArgumentException("TOutput should be a delegate.");
        }

        private static readonly Converter<TInput, TOutput> _instance = Convert;
        /// <summary>
        /// Gets a Converter capable of converting delegates of TInput
        /// to delegates of type TOutput.
        /// </summary>
        public static Converter<TInput, TOutput> Instance
        {
            get
            {
                return _instance;
            }
        }

        /// <summary>
        /// Does a conversion from a delegate of type TInput to a delegate
        /// of type TOutput.
        /// </summary>
        private static TOutput Convert(TInput input)
        {
            Delegate inputDelegate = (Delegate)(object)input;
            return DelegateConverter.Convert<TOutput>(inputDelegate);
        }
    }
}