C# Type.IsNullableType方法代码示例

 private NumberJsonSerializer(Type type, bool encrypt)
 {
     _encrypt = encrypt;
     _nullable = type.IsNullableType();
     _type = type;
     SetDelegates(out _write, out _read);
 }

        public object Parse(string value, Type targetType)
        {
            if (targetType == null) throw new ArgumentNullException(nameof(targetType));

            if(value == null)
            {
                if (targetType.IsNullableType())
                    return null;

                throw new ArgumentException($"Cannot parse null value as type {targetType}");
            }

            targetType = Nullable.GetUnderlyingType(targetType) ?? targetType;

            try
            {
                if(!CanParseType(targetType))
                    throw new InvalidOperationException($"Cannot parse value, \"{value}\", and type, \"{targetType.FullName}\"");

                var enumValue = Enum.Parse(targetType, value);

                if(!Enum.IsDefined(targetType, enumValue))
                    throw new ArgumentException($"The enum, \"{targetType}\" does not define a value for \"{value}\"");

                return enumValue;
            }
            catch (ArgumentException)
            {
                throw new ArgumentOutOfRangeException(
                    $"The value, \"{value}\" does not exist for enumeration, \"{targetType.FullName}\"");
            }
        }

        public virtual Expression CreateReadValueExpression(Expression valueReader, Type type, int index)
        {
            Check.NotNull(valueReader, nameof(valueReader));
            Check.NotNull(type, nameof(type));

            var unwrappedTargetMemberType = type.UnwrapNullableType();
            var underlyingTargetMemberType = unwrappedTargetMemberType.UnwrapEnumType();
            var indexExpression = Expression.Constant(index);

            Expression readValueExpression
                = Expression.Call(
                    valueReader,
                    _readValue.MakeGenericMethod(underlyingTargetMemberType),
                    indexExpression);

            if (underlyingTargetMemberType != type)
            {
                readValueExpression
                    = Expression.Convert(readValueExpression, type);
            }

            if (type.IsNullableType())
            {
                readValueExpression
                    = Expression.Condition(
                        Expression.Call(valueReader, _isNull, indexExpression),
                        Expression.Constant(null, type),
                        readValueExpression);
            }

            return readValueExpression;
        }

 public override void InitDbParam(IDbDataParameter p, Type fieldType)
 {
     var sqlParam = (SqlParameter)p;
     sqlParam.SqlDbType = SqlDbType.Udt;
     sqlParam.IsNullable = fieldType.IsNullableType();
     sqlParam.UdtTypeName = ColumnDefinition;
 }

 internal static Type GetNullableType(Type type)
 {
     if (type.IsValueType && !type.IsNullableType())
     {
         return typeof(Nullable<>).MakeGenericType(new Type[] { type });
     }
     return type;
 }

 public static IPropertyEditor TryCreate(Type type)
 {
     if (type.IsNullableType())
     {
         return new NullablePropertyEditor(type);
     }
     return null;
 }

        public static ConditionalReceiver ConditionalReceiver(Type type)
        {
            ContractUtils.RequiresNotNull(type, nameof(type));

            if (type == typeof(void) || type.IsByRef || type.IsNullableType())
            {
                throw Error.InvalidConditionalReceiverType(type);
            }

            return new ConditionalReceiver(type);
        }

 public override void InitDbParam(IDbDataParameter p, Type fieldType)
 {
     if (fieldType == typeof(SqlHierarchyId))
     {
         var sqlParam = (SqlParameter)p;
         sqlParam.IsNullable = fieldType.IsNullableType();
         sqlParam.SqlDbType = SqlDbType.Udt;
         sqlParam.UdtTypeName = ColumnDefinition;
     }
     base.InitDbParam(p, fieldType);
 }

        public static Type GetEnumerationType(Type enumType)
        {
            if (enumType.IsNullableType())
            {
                enumType = enumType.GetGenericArguments()[0];
            }

            if (!enumType.IsEnum)
                return null;

            return enumType;
        }

 public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
 {
     if (targetType != null && targetType.IsNullableType())
     {
         String strValue = value as String;
         if (strValue == String.Empty)
         {
             return null;
         }
     }
     return value;
 }

 public DataRowFieldAccessExpressionBuilder(Type memberType, string memberName) : base(typeof(DataRow), memberName)
 {
     //Handle value types for null and DBNull.Value support converting them to Nullable<>
     if (memberType.IsValueType && !memberType.IsNullableType())
     {
         this.columnDataType = typeof(Nullable<>).MakeGenericType(memberType);
     }
     else
     {
         this.columnDataType = memberType;
     }
 }

        public static Type GetEnumerationType(Type enumType)
        {
            if (enumType.IsNullableType())
            {
                enumType = enumType.GetTypeInfo().GenericTypeArguments[0];
            }

            if (!enumType.IsEnum())
                return null;

            return enumType;
        }

        public static IPropertyEditor TryCreate(Type type, ICustomAttributeProvider attributes)
        {
            if (type.IsNullableType()) {
                return new NullablePropertyEditor(type.GetGenericArguments()[0]);
            }

            if (attributes != null &&
                type.IsClass && attributes.IsDefined(typeof(InspectorNullableAttribute), /*inherit:*/true)) {
                return new NullablePropertyEditor(type);
            }

            return null;
        }

        public static object ChangeType(object value, Type conversionType, CultureInfo cultureInfo) {
            if (value == DBNull.Value)
                value = null;
            if (value == null || value.Equals("")) {
                if (conversionType == typeof(DateTime))
                    return typeof(Nullable).IsAssignableFrom(conversionType) ? (object)null : DateTime.MinValue;
                if (conversionType == typeof(int) || conversionType == typeof(double))
                    return typeof(Nullable).IsAssignableFrom(conversionType) ? (object)null : 0;
                if (conversionType == typeof(bool))
                    return typeof(Nullable).IsAssignableFrom(conversionType) ? (object)null : false;
                if (typeof(IEnumerable).IsAssignableFrom(conversionType) && string.IsNullOrEmpty(value + ""))
                    return null;
                if (conversionType.IsValueType)
                    return conversionType.CreateInstance();
            } else if (typeof(Enum).IsAssignableFrom(conversionType))
                return Enum.Parse(conversionType, (string)value);
            else if ((value + "").IsGuid() && conversionType == typeof(Guid))
                return new Guid(value.ToString());
            else if (value.GetType() == conversionType)
                return value;
            else {
                var o = value as XPBaseObject;
                if (o != null) {
                    if (conversionType == typeof(int))
                        return o.ClassInfo.KeyProperty.GetValue(o);
                    if (conversionType == typeof(string))
                        return o.ClassInfo.KeyProperty.GetValue(o).ToString();
                    return value;
                }
                if (conversionType == typeof(DateTime)) {
                    if ((value + "").Length > 0) {
                        var val = (value + "").Val();
                        if (val > 0)
                            return new DateTime(val);
                    }
                } else if (value.GetType() != conversionType) {
                    if (conversionType.IsNullableType()) {
                        return ChangeType(value, conversionType.GetGenericArguments()[0], cultureInfo);
                    }
                    if (conversionType.IsGenericType) {
                        return value;
                    }
                }
            }

            return Convert.ChangeType(value, conversionType, cultureInfo);

        }

        private Type GetPropertyType(Type memberType)
        {
            var descriptorProviderPropertyType = this.GetPropertyTypeFromTypeDescriptorProvider();
            if (descriptorProviderPropertyType != null)
            {
                memberType = descriptorProviderPropertyType;
            }

            //Handle value types for null and DBNull.Value support converting them to Nullable<>
            if (memberType.IsValueType && !memberType.IsNullableType())
            {
                return typeof(Nullable<>).MakeGenericType(memberType);
            }

            return memberType;
        }