internal static Comparator GetComparator(Type type) { if (type.IsNullable<DateTime>()) { return new NullableDateComparator(); } if (type == typeof (DateTime)) { return new DateComparator(); } if (type == typeof (string)) { return new StringComparator(); } if (type.IsNullable()) { return new NullableComparator(); } if (type.IsValueType) { return new ValueTypeComparator(); } return new Comparator(); }
public void GenerateCanEvalutateManyTimesTest(Type type, bool typeSupported, double min, double max) { if (typeSupported == false) { // Ignore this test return; } var target = new NumericValueGenerator(); for (var index = 0; index < 10000; index++) { var value = target.Generate(type, null, null); if (type.IsNullable() && value == null) { // Nullable values could be returned so nothing more to assert return; } var evaluateType = type; if (type.IsNullable()) { evaluateType = type.GenericTypeArguments[0]; } value.Should().BeOfType(evaluateType); var convertedValue = Convert.ToDouble(value); convertedValue.Should().BeGreaterOrEqualTo(min); convertedValue.Should().BeLessOrEqualTo(max); } }
/// <summary> /// Checks that a type is the same as the expected one. /// </summary> /// <param name="instanceType">The type of the instance to be checked.</param> /// <param name="expectedType">The expected type for the instance to be checked.</param> /// <param name="value">The value of the instance to be checked (may be a nullable instance).</param> public static void IsSameType(Type instanceType, Type expectedType, object value) { if (instanceType != expectedType || (value == null && !instanceType.IsNullable())) { throw new FluentCheckException(BuildErrorMessageForNullable(instanceType, expectedType, value, false)); } }
static System.Type CalculateAverageType(System.Type inputType) { var isNullable = false; if (inputType.IsNullable()) { isNullable = true; inputType = inputType.NullableOf(); } switch (System.Type.GetTypeCode(inputType)) { case TypeCode.Int16: case TypeCode.Int32: case TypeCode.Int64: case TypeCode.Single: case TypeCode.Double: return(isNullable ? typeof(double?) : typeof(double)); case TypeCode.Decimal: return(isNullable ? typeof(decimal?) : typeof(decimal)); } throw new NotSupportedException(inputType.FullName); }
/// <summary> /// Gets TsTypeFamily of the CLR type. /// </summary> /// <param name="type">The CLR type to get TsTypeFamily of</param> /// <returns>TsTypeFamily of the CLR type</returns> internal static TsTypeFamily GetTypeFamily(System.Type type) { if (type.IsNullable()) { return(TsType.GetTypeFamily(type.GetNullableValueType())); } var isString = (type == typeof(string)); var isEnumerable = typeof(IEnumerable).IsAssignableFrom(type); // surprisingly Decimal isn't a primitive type if (isString || type.IsPrimitive || type.FullName == "System.Decimal" || type.FullName == "System.DateTime" || type.FullName == "System.DateTimeOffset") { return(TsTypeFamily.System); } else if (isEnumerable) { return(TsTypeFamily.Collection); } if (type.IsEnum) { return(TsTypeFamily.Enum); } if ((type.IsClass && type.FullName != "System.Object") || type.IsValueType /* structures */ || type.IsInterface) { return(TsTypeFamily.Class); } return(TsTypeFamily.Type); }
public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType) { if (destinationType.IsNullable()) return CanConvertTo(context, Nullable.GetUnderlyingType(destinationType)); return GoodTypes.Contains(destinationType) || base.CanConvertTo(context, destinationType); }
/// <summary> /// Initializes a new instance of the TsType class with the specific CLR type. /// </summary> /// <param name="type">The CLR type represented by this instance of the TsType.</param> public TsType(Type type) { if (type.IsNullable()) { type = type.GetNullableValueType(); } this.Type = type; }
public static NpgsqlDbType ToDbType(Type type) { if (type.IsNullable()) return ToDbType(type.GetInnerTypeFromNullable()); if (type == typeof (DateTime)) return NpgsqlDbType.Date; return (NpgsqlDbType) _getNgpsqlDbTypeMethod.Invoke(null, new object[] {type}); }
internal static System.Type UnwrapIfNullable(this System.Type type) { if (type.IsNullable()) { return(type.NullableOf()); } return(type); }
public bool IsPrimitiveType(Type type) { if (type == null) return false; if (type.IsNullable()) type = Nullable.GetUnderlyingType(type); return type.IsPrimitive || type.IsEnum || primitiveTypes.Any(x => x.IsAssignableFrom(type)); }
/// <summary> /// Extension point. Try to find per-type <see cref="ReplicationBehavior"/> or /// return <c>null</c>, if current <see cref="IMetadataProvider"/> does not specify it. /// </summary> protected virtual ReplicationBehavior? TryGetPerTypeBehavior(Type entityType) { if (entityType.IsPrimitive || entityType.IsEnum || entityType == typeof (string)) return ReplicationBehavior.Copy; if (entityType.IsNullable()) { Type underlyingType = entityType.GetNullableUnderlyingType(); return GetPerTypeBehavior(underlyingType); } return null; }
public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType) { if (destinationType.IsNullable() && value != null) return ConvertTo(context, culture, value, Nullable.GetUnderlyingType(destinationType)); if (GoodTypes.Contains(destinationType)) return Convert.ChangeType(value, destinationType); return base.ConvertTo(context, culture, value, destinationType); }
public override object ReadJson( JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer ) { var jsonValue = serializer.Deserialize<JValue>(reader); switch ( jsonValue.Type ) { case JTokenType.Integer: var dto = DateTimeOffsetHelper.FromUnixTimeSeconds( jsonValue.Value<long>() ); if ( objectType == DateTimeOffsetType || ( objectType.IsNullable() && Nullable.GetUnderlyingType( objectType ) == DateTimeOffsetType ) ) return dto; return dto.LocalDateTime; case JTokenType.Date: if ( objectType == DateTimeOffsetType || (objectType.IsNullable() && Nullable.GetUnderlyingType(objectType) == DateTimeOffsetType)) return jsonValue.Value<DateTimeOffset>(); return jsonValue.Value<DateTime>(); case JTokenType.Null: if ( objectType.IsNullable() ) return null; throw new JsonSerializationException( $"Can't deserialize null value to non-nullable type" ); default: throw new JsonSerializationException( $"Unexpected token {jsonValue.Type} when parsing a date." ); } }
public static object ToType(this string origin, Type dest) { if (dest.IsNullable() && string.IsNullOrEmpty(origin)) return null; var realType = dest.GetValueTypeIfNullable(); if (typeof(IConvertible).IsAssignableFrom(realType)) return Convert.ChangeType(origin, realType); throw new NotSupportedException("Cannot convert to type"); }
public static DataType BuildDataType(Type type, Func<Type, MemberInfo, int> membersOrder = null) { if (DataType.IsPrimitiveType(type) || type.IsEnum || type == typeof(Guid) || type.IsKeyValuePair() || type.IsArray || type.IsList() || type.IsDictionary() || type.IsNullable()) return BuildDataType(type, membersOrder, new HashSet<Type>()); List<DataType> slots = new List<DataType>(); foreach (var member in GetPublicMembers(type, membersOrder)) slots.Add(BuildDataType(member.GetPropertyOrFieldType(), membersOrder, new HashSet<Type>())); return DataType.Slots(slots.ToArray()); }
public static string GetPgType(Type memberType) { if (memberType.IsEnum) return "integer"; if (memberType.IsNullable()) { return GetPgType(memberType.GetInnerTypeFromNullable()); } return PgTypes[memberType]; }
private static bool CheckIfIsImmutable(Type type, List<Type> checkedTypes) { bool result; if (ImmutableCheckedTypes.TryGetValue(type, out result)) { return result; } if (type.IsNullable()) { var underlyingType = Nullable.GetUnderlyingType(type); result = CheckIfIsImmutable(underlyingType, checkedTypes); } else if (type == typeof(bool)) { result = true; } else if (type.IsEnum) { result = true; } else if (type.IsArray) { result = false; } else if (type.IsDelegate()) { result = true; } else if (type.IsImmutableList() || type.IsImmutableArray() || type.IsImmutableHashSet()) { var itemType = type.GetItemType(); result = CheckIfIsImmutable(itemType, checkedTypes); } else if (type.IsKeyValuePair()) { var genericArguments = type.GetGenericArguments(); result = CheckIfIsImmutable(genericArguments[0], checkedTypes) && CheckIfIsImmutable(genericArguments[1], checkedTypes); } else if (CanBeImmutable(type)) { result = HasImmutableMembers(type, checkedTypes); } else { result = false; } ImmutableCheckedTypes.TryAdd(type, result); return result; }
/// <summary> /// Returns a Expression reading a property from a IDataRecord, at the specified index /// The lambda parameters are: /// - IDataRecord /// - MappingContext /// - int (field index) /// </summary> /// <param name="returnType">The expected return type (to be mapped to the property)</param> /// <returns>An expression returning the field value</returns> public virtual LambdaExpression GetPropertyReader(Type returnType) { // if we have a nullable, then use its inner type if (returnType.IsNullable()) { var nonNullableReturnType = returnType.GetNullableType(); return GetNullablePropertyReader(nonNullableReturnType); } // otherwise, it's simple return GetNullablePropertyReader(returnType); }
public ClassMapper(Type fromType, Type toType) : base(fromType, toType) { if (!toType.IsAbstract) { if (toType.IsNullable()) Ctor = DynamicMethodFactory.GetDefaultCreator(Nullable.GetUnderlyingType(toType)); else Ctor = DynamicMethodFactory.GetDefaultCreator(toType); } }
public DataRowMapper(Type toType) : base(typeof(DataRow), toType) { if (!toType.IsAbstract) { if (toType.IsNullable()) Ctor = DynamicMethodFactory.GetDefaultCreator(Nullable.GetUnderlyingType(toType)); else Ctor = DynamicMethodFactory.GetDefaultCreator(toType); } }
/// <summary> /// 写入类型转换的 IL 指令。 /// </summary> /// <param name="generator">IL 的指令生成器。</param> /// <param name="inputType">要转换的对象的类型。</param> /// <param name="outputType">要将输入对象转换到的类型。</param> /// <param name="isChecked">是否执行溢出检查。</param> public override void Emit(ILGenerator generator, Type inputType, Type outputType, bool isChecked) { Contract.Assume(inputType.IsNullable()); Type inputUnderlyingType = Nullable.GetUnderlyingType(inputType); generator.EmitCall(inputType.GetMethod("get_Value")); if (inputUnderlyingType != outputType) { Conversion conversion = ConversionFactory.GetConversion(inputUnderlyingType, outputType); Contract.Assume(conversion != null); conversion.Emit(generator, inputUnderlyingType, outputType, isChecked); } }
/// <summary> /// Converts <paramref name="value"/> to the corresponding value of /// type <paramref name="targetType"/>. <paramref name="targetType"/> /// must be one of the following types: string, value type, and nullable type. /// </summary> /// <param name="value">The string to be converted.</param> /// <param name="targetType">The target type to convert <paramref name="value"/> to.</param> /// <returns>The corresponding value, in <paramref name="targetType"/>, of <paramref name="value"/>.</returns> /// <seealso cref="Convert.ChangeType(object,System.Type)"/> public static object ConvertToType(this string value, Type targetType) { if (value == null) return null; if (targetType == typeof(string)) return value; if (targetType.IsEnum) return Enum.Parse(targetType, value, true); if (targetType.IsNullable()) targetType = Nullable.GetUnderlyingType(targetType); return Convert.ChangeType(value, targetType, CultureInfo.InvariantCulture); }
public SimpleValueObjectContext(Type type, object value) { if (type == null) throw new ArgumentNullException("type"); if (value == null && type.IsValueType && !type.IsNullable()) throw new ArgumentNullException("Specified type '" + type.Name + "' cannot be null.", "value"); if (value != null && !type.IsInstanceOfType(value)) throw new ArgumentException("Specified value '" + value + "' is not an instance of the specified type '" + type + "'.", "value"); _value = value; _type = type; }
public CommonReplicationStrategy(IMetadataProvider metadataProvider, Type entityType) { Guard.AgainstNull(metadataProvider, "metadataProvider"); Guard.AgainstNull(entityType, "entityType"); Guard.AgainstViolation(!entityType.IsNullable() && !entityType.IsArray, "CommonReplicationStrategy is not applicable to nullable or array types"); this.entityType = entityType; memberDescriptions = metadataProvider.GetFieldsReplicationInfo(entityType) .Where(t => t.Behavior != ReplicationBehavior.Ignore) .Select(t => new MemberReplicationInfo(entityType, t)) .ToArray(); }
public Func<string, object> ConverterFor(Type type) { if (!type.IsNullable()) return null; var innerType = type.GetGenericArguments().First(); var inner = _conversions.FindConverter(innerType); return str => { if (str == "NULL") return null; return inner(str); }; }
/// <summary> /// 写入类型转换的 IL 指令。 /// </summary> /// <param name="generator">IL 的指令生成器。</param> /// <param name="inputType">要转换的对象的类型。</param> /// <param name="outputType">要将输入对象转换到的类型。</param> /// <param name="isChecked">是否执行溢出检查。</param> public override void Emit(ILGenerator generator, Type inputType, Type outputType, bool isChecked) { Contract.Assume(outputType.IsNullable()); Type outputUnderlyingType = Nullable.GetUnderlyingType(outputType); if (inputType != outputUnderlyingType) { Conversion conversion = ConversionFactory.GetConversion(inputType, outputUnderlyingType); Contract.Assume(conversion != null); conversion.Emit(generator, inputType, outputUnderlyingType, isChecked); } ConstructorInfo ctor = outputType.GetConstructor(new[] { outputUnderlyingType }); Contract.Assume(ctor != null); generator.Emit(OpCodes.Newobj, ctor); }
private List <Option> GetOptions(System.Type type) { return(type.IsEnum || (type.IsNullable() && Nullable.GetUnderlyingType(type).IsEnum) ? type.GetEnumOptions() .Where(x => !x.HasAttribute <HideAttribute>()) .Select(x => { var option = _optionConvention.GetDescription(x); return _configuration.OptionOverrides.Apply(x, new Option { Name = option.WhenNotNull(y => y.Name).OtherwiseDefault(), Comments = option.WhenNotNull(y => y.Comments).OtherwiseDefault(), Value = _configuration.EnumValue == EnumValue.AsString ? x.Name : x.GetRawConstantValue().ToString() }); }).OrderBy(x => x.Name ?? x.Value).ToList() : new List <Option>()); }
public static object Evaluate (object a, object b, Type t, ExpressionType et) { TypeCode tc = Type.GetTypeCode (t); if (tc == TypeCode.Object) { if (!t.IsNullable ()) { throw new NotImplementedException ( string.Format ( "Expression with Node type {0} for type {1}", t.FullName, tc)); } return EvaluateNullable (a, b, Type.GetTypeCode (t.GetGenericArguments () [0]), et); } return Evaluate (a, b, tc, et); }
public static bool IsAllPrimitive(Type type, Func<Type, MemberInfo, int> membersOrder = null) { if (DataType.IsPrimitiveType(type)) return true; if (type.IsArray || type.IsList() || type.IsDictionary() || type.IsKeyValuePair() || type.IsNullable() || type == typeof(Guid)) return false; foreach (var member in GetPublicMembers(type, membersOrder)) { if (!DataType.IsPrimitiveType(member.GetPropertyOrFieldType())) return false; } return true; }
internal static bool IsPrimitiveTypeMapping(Type fromType, Type toType) { if (fromType == null) return false; if (toType == null) return false; if (fromType.IsNullable()) fromType = fromType.GetGenericArguments()[0]; if (Type.GetTypeCode(fromType) == TypeCode.Object) return false; if (toType.IsNullable()) toType = toType.GetGenericArguments()[0]; if (Type.GetTypeCode(toType) == TypeCode.Object) return false; return true; }
public static string GetValueResponseWrapperTypeName(Type type) { var unwrappedType = type.GetUnwrappedNullableType(); if (unwrappedType.IsNumericType(true) || unwrappedType == typeof(bool) || (unwrappedType.IsEnum && type.IsNullable())) { return "NumberValueResponse"; } else if (unwrappedType is FickleListType) { return "ArrayValueResponse"; } else { return TypeSystem.GetPrimitiveName(unwrappedType, true) + "ValueResponse"; } }
/// <inheritdoc /> /// <exception cref="ArgumentNullException">The <paramref name="type"/> parameter is null.</exception> public override bool IsSupported(Type type, string referenceName, LinkedList<object> buildChain) { if (type == null) { throw new ArgumentNullException(nameof(type)); } if (type.IsNullable()) { // Get the internal type var internalType = type.GetGenericArguments()[0]; return Generator.IsSupported(internalType); } return Generator.IsSupported(type); }
private static bool SatisfiesConstraints(this Type genericVariable, SigTypeContext typeContextOfConstraintDeclarer, Type typeArg) { GenericParameterAttributes specialConstraints = genericVariable.GenericParameterAttributes & GenericParameterAttributes.SpecialConstraintMask; if ((specialConstraints & GenericParameterAttributes.NotNullableValueTypeConstraint) != 0) { if (!typeArg.IsValueType) return false; else { // the type argument is a value type, however if it is any kind of Nullable we want to fail // as the constraint accepts any value type except Nullable types (Nullable itself is a value type) if (typeArg.IsNullable()) return false; } } if ((specialConstraints & GenericParameterAttributes.ReferenceTypeConstraint) != 0) { if (typeArg.IsValueType) return false; } if ((specialConstraints & GenericParameterAttributes.DefaultConstructorConstraint) != 0) { if (!typeArg.HasExplicitOrImplicitPublicDefaultConstructor()) return false; } // Now check general subtype constraints foreach (var constraint in genericVariable.GetGenericParameterConstraints()) { Type instantiatedTypeConstraint = constraint.Instantiate(typeContextOfConstraintDeclarer); // System.Object constraint will be always satisfied - even if argList is empty if (instantiatedTypeConstraint.IsSystemObject()) continue; // if a concrete type can be cast to the constraint, then this constraint will be satisifed if (!AreTypesAssignable(typeArg, instantiatedTypeConstraint)) return false; } return true; }
public static bool IsPrimitive(this System.Type type) { return(type.IsValueType || type.IsNullable() || type == typeof(string)); }
public static bool IsNullableOrReference(this System.Type type) { return(!type.IsValueType || type.IsNullable()); }
private ModelSpec CreateSpecFor(Type type, bool deferIfComplex, Dictionary<Type, ModelSpec> deferredMappings) { if (_customMappings.ContainsKey(type)) return _customMappings[type]; if (PrimitiveMappings.ContainsKey(type)) return PrimitiveMappings[type]; if (type.IsEnum) return new ModelSpec {Type = "string", Enum = type.GetEnumNames()}; Type innerType; if (type.IsNullable(out innerType)) return CreateSpecFor(innerType, deferIfComplex, deferredMappings); Type itemType; if (type.IsEnumerable(out itemType)) return new ModelSpec { Type = "array", Items = CreateSpecFor(itemType, true, deferredMappings) }; // Anthing else is complex if (deferIfComplex) { if (!deferredMappings.ContainsKey(type)) deferredMappings.Add(type, null); // Just return a reference for now return new ModelSpec {Ref = UniqueIdFor(type)}; } return CreateComplexSpecFor(type, deferredMappings); }