Пример #1
0
        public static bool AssignableToTypeName(this Type type, string fullTypeName)
        {
            Type match;

            return(TypeExtensions.AssignableToTypeName(type, fullTypeName, out match));
        }
Пример #2
0
 private static bool IsCompatibleObject(object value)
 {
     return(value is T || value == null && (!TypeExtensions.IsValueType(typeof(T)) || ReflectionUtils.IsNullableType(typeof(T))));
 }
Пример #3
0
        public static object Convert(object initialValue, CultureInfo culture, Type targetType)
        {
            if (initialValue == null)
            {
                throw new ArgumentNullException("initialValue");
            }
            if (ReflectionUtils.IsNullableType(targetType))
            {
                targetType = Nullable.GetUnderlyingType(targetType);
            }
            Type type = initialValue.GetType();

            if (targetType == type)
            {
                return(initialValue);
            }
            if (ConvertUtils.IsConvertible(initialValue) && ConvertUtils.IsConvertible(targetType))
            {
                if (TypeExtensions.IsEnum(targetType))
                {
                    if (initialValue is string)
                    {
                        return(Enum.Parse(targetType, initialValue.ToString(), true));
                    }
                    if (ConvertUtils.IsInteger(initialValue))
                    {
                        return(Enum.ToObject(targetType, initialValue));
                    }
                }
                return(Convert.ChangeType(initialValue, targetType, (IFormatProvider)culture));
            }
            else
            {
                if (initialValue is string && typeof(Type).IsAssignableFrom(targetType))
                {
                    return((object)Type.GetType((string)initialValue, true));
                }
                if (TypeExtensions.IsInterface(targetType) || TypeExtensions.IsGenericTypeDefinition(targetType) || TypeExtensions.IsAbstract(targetType))
                {
                    throw new ArgumentException(StringUtils.FormatWith("Target type {0} is not a value type or a non-abstract class.", (IFormatProvider)CultureInfo.InvariantCulture, (object)targetType), "targetType");
                }
                if (initialValue is string)
                {
                    if (targetType == typeof(Guid))
                    {
                        return((object)new Guid((string)initialValue));
                    }
                    if (targetType == typeof(Uri))
                    {
                        return((object)new Uri((string)initialValue, UriKind.RelativeOrAbsolute));
                    }
                    if (targetType == typeof(TimeSpan))
                    {
                        return((object)TimeSpan.Parse((string)initialValue));
                    }
                }
                TypeConverter converter1 = ConvertUtils.GetConverter(type);
                if (converter1 != null && converter1.CanConvertTo(targetType))
                {
                    return(converter1.ConvertTo((ITypeDescriptorContext)null, culture, initialValue, targetType));
                }
                TypeConverter converter2 = ConvertUtils.GetConverter(targetType);
                if (converter2 != null && converter2.CanConvertFrom(type))
                {
                    return(converter2.ConvertFrom((ITypeDescriptorContext)null, culture, initialValue));
                }
                if (initialValue == DBNull.Value)
                {
                    if (ReflectionUtils.IsNullable(targetType))
                    {
                        return(ConvertUtils.EnsureTypeAssignable((object)null, type, targetType));
                    }
                    else
                    {
                        throw new Exception(StringUtils.FormatWith("Can not convert null {0} into non-nullable {1}.", (IFormatProvider)CultureInfo.InvariantCulture, (object)type, (object)targetType));
                    }
                }
                else if (initialValue is INullable)
                {
                    return(ConvertUtils.EnsureTypeAssignable(ConvertUtils.ToValue((INullable)initialValue), type, targetType));
                }
                else
                {
                    throw new InvalidOperationException(StringUtils.FormatWith("Can not convert from {0} to {1}.", (IFormatProvider)CultureInfo.InvariantCulture, (object)type, (object)targetType));
                }
            }
        }
Пример #4
0
        public static MemberInfo GetMemberInfoFromType(Type targetType, MemberInfo memberInfo)
        {
            if (TypeExtensions.MemberType(memberInfo) != MemberTypes.Property)
            {
                return(Enumerable.SingleOrDefault <MemberInfo>((IEnumerable <MemberInfo>)targetType.GetMember(memberInfo.Name, TypeExtensions.MemberType(memberInfo), BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)));
            }
            PropertyInfo propertyInfo = (PropertyInfo)memberInfo;

            Type[] types = Enumerable.ToArray <Type>(Enumerable.Select <ParameterInfo, Type>((IEnumerable <ParameterInfo>)propertyInfo.GetIndexParameters(), (Func <ParameterInfo, Type>)(p => p.ParameterType)));
            return((MemberInfo)targetType.GetProperty(propertyInfo.Name, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, (Binder)null, propertyInfo.PropertyType, types, (ParameterModifier[])null));
        }
Пример #5
0
 public static bool IsInstantiatableType(Type t)
 {
     ValidationUtils.ArgumentNotNull((object)t, "t");
     return(!TypeExtensions.IsAbstract(t) && !TypeExtensions.IsInterface(t) && (!t.IsArray && !TypeExtensions.IsGenericTypeDefinition(t)) && (t != typeof(void) && ReflectionUtils.HasDefaultConstructor(t)));
 }
 private static DynamicMethod CreateDynamicMethod(string name, Type returnType, Type[] parameterTypes, Type owner)
 {
     return(!TypeExtensions.IsInterface(owner) ? new DynamicMethod(name, returnType, parameterTypes, owner, true) : new DynamicMethod(name, returnType, parameterTypes, owner.Module, true));
 }