TypeInfoExtension.cs

Go to the documentation of this file.

// <copyright file=mitlicense.md url=http://lsauer.mit-license.org/ >
//             Lo Sauer, 2016
// </copyright>
// <summary>   A custom excerpt of the Core.Extensions library. Not for reuse!  </summary
// <language>  C# > 3.0                                                         </language>
// <version>   2.0.0.4                                                          </version>
// <author>    Lo Sauer; people credited in the sources                         </author>
// <project>   https://github.com/lsauer/dotnet-core.extensions                 </project>
namespace Core.Extensions
{
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Reflection;
    using System.Runtime.CompilerServices;

    public static partial class TypeInfoExtension
    {
        public static IEnumerable<ConstructorInfo> GetConstructorsByParameterType(this TypeInfo type, Type parameterType)
        {
            return from constructorInfo in type.DeclaredConstructors
                   where constructorInfo.GetParameters().Any(p => p.IsOptional == false && p.ParameterType == parameterType)
                   select constructorInfo;
        }

        public static ConstructorInfo GetConstructorByParameterTypes(this TypeInfo type, Type[] parameterTypes)
        {
            return (from constructorInfo in type.DeclaredConstructors
                    let parameterInfos = constructorInfo.GetParameters()
                    where
                         parameterInfos.Length == parameterTypes.Length
                         && parameterInfos.Select(p => p.ParameterType.Name).SequenceEqual(parameterTypes.Select(t => t.Name))
                    select constructorInfo)?.
                   FirstOrDefault();
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static bool IsDependencyInjectable(this TypeInfo type, Type interfaceType)
        {
            return type.GetConstructorsByParameterType(interfaceType).Any();
        }


        public static bool IsInvokableWithParameters(this TypeInfo method, Type returnParameter, params Type[] argumentParameters)
        {
            var methodInfo = method.GetDeclaredMethod("Invoke");
            if(methodInfo == null)
            {
                return false;
            }
            var parameters = methodInfo.GetParameters();
            bool trueForAll = true;
            for(int i = 0; i < argumentParameters.Length; i++)
            {
                if(argumentParameters[i] == null)
                {
                    continue;
                }
                if(i <= parameters.Length)
                {
                    trueForAll &= (parameters[i] != null && parameters[i].ParameterType == argumentParameters[i]);
                }
            }
            return methodInfo.ReturnParameter.ParameterType == returnParameter && trueForAll;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static object GetDefault(this TypeInfo type)
        {
            if(type.GetConstructorsByParameterType(null) != null && type.IsAbstract == false && type.IsValueType == true)
            {
                return Activator.CreateInstance(type.AsType());
            }
            else
            {
                return null;
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Type GetReturnParameterType(this TypeInfo type, Type defaultType = null)
        {
            if(typeof(Delegate).GetTypeInfo().IsAssignableFrom(type) == true)
            {
                return type.GetDeclaredMethod("Invoke")?.ReturnParameter?.ParameterType ?? defaultType;
            }
            else
            {
                return null;
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static TypeMatch IsSameOrSimilar<TOut>(this TypeInfo self, bool? checkIsSame = null)
        {
            var typeOut = typeof(TOut).GetTypeInfo();
            if((checkIsSame == null || checkIsSame == true) && self == typeOut)
            {
                return TypeMatch.Same;
            }

            if((checkIsSame == null || checkIsSame == false) && (self.Namespace == typeOut.Namespace) && (self.BaseType == typeOut.BaseType))
            {
                return TypeMatch.Similar;
            }
            return TypeMatch.None;
        }


        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static bool IsSuperOrSubType(this TypeInfo self, TypeInfo typeBase)
        {
            if(self == typeBase)
            {
                return true;
            }
            return self.AsType() != typeof(object) && (self.IsAssignableFrom(typeBase) || typeBase.IsAssignableFrom(self));
        }
    }
}