ObjectExtension.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
{
    using System;
    using System.Reflection;
    using System.Linq;

    using System.Runtime.CompilerServices;
    using System.Collections;
    using System.Collections.Generic;

    using Core.TypeCast.Base;
    using Core.Extensions;

    public static partial class ObjectExtension
    {
        private static Type objectType = typeof(object);
        private static TypeInfo objectTypeInfo = typeof(object).GetTypeInfo();

        private static bool GetConverterOrDefault<TIn, TOut>(
            TIn self,
            out Converter converter,
            out TOut result,
            Type typeArgument = null,
            Type typeTo = null,
            Type typeBase = null,
            bool throwException = false,
            bool unboxObjectType = true,
            string attributeName = null,
            bool withContext = false)
        {
            ConverterCollection.AutoInitialize();
            if(typeof(TIn) == objectType)
            {
                if(throwException == true && unboxObjectType == false && ConverterCollection.CurrentInstance.Settings.AllowGenericTypes == false)
                {
                    throw new ConverterException(ConverterCause.ConverterTypeInIsExplicitObject);
                }

                var typeFrom = unboxObjectType ? self.GetType() : objectType;
                if(typeTo == null || typeof(TOut) != objectType)
                {
                    typeTo = typeTo ?? typeof(TOut);
                }
                converter = ConverterCollection.CurrentInstance.Get(typeFrom: typeFrom.GetTypeInfo(), typeTo: typeTo?.GetTypeInfo(), typeArgument: typeArgument?.GetTypeInfo(), 
                                        typeBase: typeBase?.GetTypeInfo(), attributeName: attributeName, loadOnDemand: true, assignable: false, withContext: withContext);
                // Retry by widening the search to type-inheritance
                if(converter == null)
                {
                    converter = ConverterCollection.CurrentInstance.Get(typeFrom: typeFrom.GetTypeInfo(), typeTo: typeTo?.GetTypeInfo(), typeArgument: typeArgument?.GetTypeInfo(),
                                        typeBase: typeBase?.GetTypeInfo(), attributeName: attributeName, loadOnDemand: false, assignable: true, withContext: withContext);
                }
                // no specific converter found, lets find a generic fallback converter
                if(converter == null && unboxObjectType == true && typeof(TIn) == objectType)
                {
                    converter = ConverterCollection.CurrentInstance.Get(typeFrom: objectTypeInfo, typeTo: typeTo?.GetTypeInfo(), typeArgument: typeArgument?.GetTypeInfo(),
                                        typeBase: typeBase?.GetTypeInfo(), attributeName: attributeName, loadOnDemand: false, assignable: false, withContext: withContext);
                }
            }
            else
            {
                converter = ConverterCollection.CurrentInstance.Get<TIn, TOut>(self, typeArgument: typeArgument, loadOnDemand: true);
            }

            if(self is TOut)
            {
                result = (TOut)(object)self;
                return true;
            }

            result = default(TOut);
            return false;
        }

        private static bool InvokeConvert<TIn, TOut>(TIn self, out TOut result, object defaultValue, bool throwException, Converter converter, IConvertContext contextInstance = null, [CallerMemberName] string caller = null)
        {
            if(defaultValue is IConvertContext)
            {
                contextInstance = SetContext<TIn, TOut>(defaultValue as IConvertContext, ((IConvertContext)defaultValue).Value, throwException, converter, caller);
            }
            else
            {
                contextInstance = SetContext<TIn, TOut>(contextInstance, defaultValue, throwException, converter, caller);
            }

            if(converter != null)
            {
                try
                {
                    result = (TOut)converter.Convert(self, contextInstance ?? defaultValue);
                    return IsDefaultValue<TOut>(result) == false;
                }
                catch(Exception exc)
                {
                    if(exc is IException)
                    {
                        if(throwException == true)
                        {
                            throw;
                        }
                    }
                    else if(exc is System.FormatException)
                    {
                        if(throwException == true)
                        {
                            throw new ConverterException(ConverterCause.BadInputFormat, exc);
                        }
                    }
                    else if(exc is System.OverflowException || exc is System.InvalidOperationException || exc is System.ArithmeticException)
                    {
                        if(throwException == true)
                        {
                            throw new ConverterException(ConverterCause.LogicError, exc);
                        }
                    }
                    else
                    {
                        throw new ConverterException(ConverterCause.ConvertFailed, exc);
                    }
                }
            }

            result = default(TOut);

            if(ConverterCollection.CurrentInstance.Settings.AllowDynamicType == true)
            {
                // lets use the internal CLR reflection logic via `dynamic` to invoke a Type's dynamic implicit cast method if available
                try
                {
                    dynamic tmp = self;
                    result = (TOut)tmp;
                    return true;
                }
                // don't handle exceptions any further at this point
                catch(Exception) { }
            }
            return false;
        }

        private static IConvertContext SetContext<TIn, TOut>(IConvertContext contextInstance, object defaultValue, bool throwException, Converter converter, string caller)
        {
            if(contextInstance != null)
            {
                contextInstance = new ConvertContext<TIn, TOut>(defaultValue)
                {
                    Argument = defaultValue?.GetType(),
                    Converter = contextInstance.Converter ?? converter,
                    Caller = contextInstance.Caller ?? caller,
                    ThrowExceptions = contextInstance.ThrowExceptions ?? throwException,
                    Nullable = contextInstance.Nullable ?? false
                };
            }

            return contextInstance;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static bool CanConvertTo<TIn, TOut>(this TIn self, TOut target = default(TOut))
        {
            TOut result = default(TOut);
            Converter converter = null;
            GetConverterOrDefault<TIn, TOut>(self, out converter, out result);
            return converter != null;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static bool CanConvertTo<TOut, TArg>(this object self, TOut target = default(TOut), TArg model = default(TArg))
        {
            TOut result = default(TOut);
            Converter converter = null;
            GetConverterOrDefault<object, TOut>(self, out converter, out result, typeArgument: typeof(TArg), unboxObjectType: true);
            return converter != null;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static bool CanConvertTo<TIn, TArg>(this TIn self, Type typeTo, TArg model = default(TArg))
        {
            object result = null;
            Converter converter = null;
            GetConverterOrDefault<TIn, object>(self, out converter, out result, typeTo: typeTo, typeArgument: typeof(TArg));
            return converter != null;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static bool CanConvertTo<TIn>(this TIn self, Type typeTo, Type typeModel)
        {
            object result = null;
            Converter converter = null;
            GetConverterOrDefault<TIn, object>(self, out converter, out result, typeTo: typeTo, typeArgument: typeModel?.GetType());
            return converter != null;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static bool CanConvertTo<TIn>(this TIn self, Type typeTo)
        {
            object result = null;
            Converter converter = null;
            GetConverterOrDefault<TIn, object>(self, out converter, out result, typeTo: typeTo, unboxObjectType: true);
            return converter != null;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static bool CanConvertTo<TOut>(this object self)
        {
            TOut result = default(TOut);
            Converter converter = null;
            GetConverterOrDefault<object, TOut>(self, out converter, out result, unboxObjectType: true);
            return converter != null;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static bool IsDefaultValue<TIn>(this TIn self)
        {
            return Object.Equals(self, default(TIn)) == true;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static bool IsDefaultValue<TIn>(this object self)
        {
            return Object.Equals(self, default(TIn)) == true;
        }
    }
}