public static bool IsTuple(this Type type) { if (type is null) { Throw.NullArgument(nameof(type)); } return(typeof(ITuple).IsAssignableFrom(type)); }
public static bool IsNullable([NotNull] this Type type) { if (type is null) { Throw.NullArgument(nameof(type)); } return(Nullable.GetUnderlyingType(type) is object); }
public static bool HasDefaultConstructor([NotNull] this Type type) { if (type is null) { Throw.NullArgument(nameof(type)); } return(ConstructorCache.GetOrAddFor(type)); }
public static bool IsStatic([NotNull] this Type type) { if (type is null) { Throw.NullArgument(nameof(type)); } return(type.IsAbstract && type.IsSealed); }
/// <summary> /// Creates the mapper for the given type. /// </summary> /// <param name="type">The type.</param> public Mapper([NotNull] Type type) { if (type is null) { Throw.NullArgument(nameof(type)); } _source = type; }
public static bool TryGetCustomAttribute <T>( [NotNull] this Type type, [MaybeNullWhen(false)] out T attribute, bool inherited = true) where T : Attribute { if (type is null) { Throw.NullArgument(nameof(type)); } attribute = type.GetCustomAttribute <T>(inherited); return(attribute is object); }
public object CreateInstance([NotNull] params object[] args) { if (args is null) { Throw.NullArgument(nameof(args)); } if (_target.IsAbstract) { Throw.InvalidOperation("You cannot create an instance of an abstract type."); } if (args.Length != Parameters.Count) { Throw.ParameterCountMismatch($"This constructor {_target.Name}({string.Join(", ", Parameters.Select(x => x.ParameterType.Name))}) requires these parameters to be used."); } for (var index = 0; index < args.Length; index++) { if (!args[index].GetType().CanBeConvertedTo(Parameters[index].ParameterType)) { Throw.InvalidOperation($"The type {args[index].GetType().Name} cannot be implicitly converted to {Parameters[index].ParameterType.Name}"); } } if (_constructor is object) { return(_constructor(args)); } var array = Expression.Parameter(typeof(object[])); var parameters = args .Zip(Enumerable.Range(0, args.Length), (arg, index) => Expression.Convert( Expression.ArrayIndex( array, Expression.Constant(index)), arg.GetType())) .ToArray(); var @new = Expression.New(Member, parameters); var convert = Expression.Convert(@new, typeof(object)); _constructor = Expression.Lambda <Func <object[], object> >(convert, array).Compile(); return(_constructor(args)); }
/// <summary> /// Indicates if the provided type implements the provided interface type. /// </summary> /// <param name="type">The type.</param> /// <param name="interfaceType">The type of the interface to check.</param> /// <returns></returns> public static bool Implements([NotNull] this Type type, [NotNull] Type interfaceType) { if (type is null) { Throw.NullArgument(nameof(type)); } if (interfaceType is null) { Throw.NullArgument(nameof(interfaceType)); } if (type.IsInterface || !interfaceType.IsInterface) { return(false); } return(interfaceType.IsAssignableFrom(type)); }
/// <summary> /// Indicates if the provided type inherits from the base type provided. /// </summary> /// <param name="derived">The derived type.</param> /// <param name="base">The potential base of the type.</param> /// <returns></returns> public static bool Inherits([NotNull] this Type derived, [NotNull] Type @base) { if (derived is null) { Throw.NullArgument(nameof(derived)); } if (@base is null) { Throw.NullArgument(nameof(@base)); } if (derived == @base) { return(false); } if (derived.IsInterface) { return(@base.IsInterface && derived.GetTypeInfo().ImplementedInterfaces.Any(i => i == @base)); } return(@base.IsAssignableFrom(derived)); }