ConverterFactory.cs

Go to the documentation of this file.

// <copyright file=mitlicense.md url=http://lsauer.mit-license.org/ >
//             Lo Sauer, 2013-2016
// </copyright>
// <summary>   A tested, generic, portable, runtime-extensible type converter library   </summary
// <language>  C# > 6.0                                                                 </language>
// <version>   3.1.0.2                                                                  </version>
// <author>    Lorenz Lo Sauer; people credited in the sources                          </author>
// <project>   https://github.com/lsauer/dotnet-portable-type-cast                      </project>
namespace Core.TypeCast.Base
{
    using System;
    using System.Linq;
    using Core.TypeCast;
    using System.Diagnostics;
    using System.Reflection;
    using System.Runtime.Serialization;

    [System.Runtime.InteropServices.ComVisible(false)]
    public class ConverterFactory : ConverterFactory<Converter>
    {
        public override Converter Create<TIn, TOut>(Func<TIn, TOut> method)
        {
            var converter = new Converter<TIn, TOut>(method);
            converter.MergeFromMethodAttribute(method.GetMethodInfo());

            return converter;
        }

        public override Converter Create<TIn, TOut>(Func<TIn, TOut, TOut> method)
        {
            var converter = new Converter<TIn, TOut>(method);
            converter.MergeFromMethodAttribute(method.GetMethodInfo());

            return converter;
        }

        public Converter CreateWrapper(TypeInfo type, MethodInfo declaredMethod)
        {
            MethodInfo makeConverter;
            if(declaredMethod.GetParameters().Length == 0)
            {
                makeConverter = typeof(ConverterFactory).GetTypeInfo()
                                .GetDeclaredMethod(nameof(ConverterFactory.ConverterWrapper))
                                .MakeGenericMethod(type.AsType(), declaredMethod.ReturnParameter.ParameterType);
            }
            else if(declaredMethod.GetParameters().Length == 1)
            {
                makeConverter = typeof(ConverterFactory).GetTypeInfo()
                                .GetDeclaredMethod(nameof(ConverterFactory.ConverterWrapperAny))
                                .MakeGenericMethod(type.AsType(), declaredMethod.GetParameters().FirstOrDefault().ParameterType, declaredMethod.ReturnParameter.ParameterType);
            }
            else
            {
                throw new ConverterException(ConverterCause.ConverterArgumentDelegateTooManyParameters);
            }
            var args = new object[] { declaredMethod }; //: new object[] { declaredMethod }.Concat(parameters).ToArray();

            var converter = (Converter)makeConverter.Invoke(this, args);

            converter.MergeFromMethodAttribute(declaredMethod);

            return converter;
        }

        public Converter ConverterWrapper<TClass, TOut>(MethodInfo declaredMethod)
        {
            return this.Create<TClass, TOut>(InvocationWrapper<TClass, TOut>(declaredMethod));
        }

        public static Converter ConverterWrapperAny<TClass, TArg, TOut>(MethodInfo declaredMethod)
        {
            return new Converter<TClass, TOut, TArg>(InvocationWrapper<TClass, TArg, TOut>(declaredMethod));
        }

        private static Func<TClass, TOut> InvocationWrapper<TClass, TOut>(MethodInfo declaredMethod)
        {
            return (instance) => (TOut)declaredMethod.Invoke(instance, null);
        }

        private static Func<TClass, TArg, TOut> InvocationWrapper<TClass, TArg, TOut>(MethodInfo declaredMethod)
        {
            return (instance, parameter) => (TOut)declaredMethod.Invoke(instance, new object[] { parameter });
        }
    }
}