public static DbType ToDbType(Type type) { DbType dbType; switch ( type.GetTypeCode() ) { case TypeCode.String: dbType = DbType.String; break; case TypeCode.Int32: dbType = DbType.Int32; break; case TypeCode.DateTime: dbType = DbType.DateTime; break; case TypeCode.Boolean: dbType = DbType.Boolean; break; default: if(type == typeof(Guid)) dbType = DbType.Guid; else Enum.TryParse(type.GetTypeCode().ToString(), true, out dbType); break; } return dbType; }
/// <summary> /// Checks whether .NET type is primitive /// </summary> /// <param name="type">.NET type</param> /// <returns>Result of check (true - is primitive; false - is not primitive)</returns> public static bool IsPrimitiveType(Type type) { TypeCode typeCode = type.GetTypeCode(); bool result = _primitiveTypeCodes.Contains(typeCode); return result; }
// keep in sync with System.Core version internal static bool IsNumeric(Type type) { type = GetNonNullableType(type); if (!type.IsEnum()) { return IsNumeric(type.GetTypeCode()); } return false; }
public override object FromDbValue(Type fieldType, object value) { var strVal = value as string; if (strVal != null) return Enum.Parse(fieldType, strVal, ignoreCase:true); return Convert.ChangeType(value, fieldType.GetTypeCode()); }
internal static PrimitiveConverter ForType(BclType type) { TypeCode underlyingTypeCode = BclType.GetTypeCode(type.GetTypeInfo().GetEnumUnderlyingType()); if (!s_genericTypes.TryGetValue(underlyingTypeCode, out var genericConverterType)) { throw new InvalidOperationException($"Unexpected underlying type code for enum: {underlyingTypeCode}"); } return((PrimitiveConverter)Activator.CreateInstance(genericConverterType.MakeGenericType(type))); }
private static object CreateInstance(Type targetType) { if (Type.GetTypeCode(targetType) == TypeCode.String) { return(string.Empty); } else { return(Activator.CreateInstance(targetType)); } }
/// <summary> /// Checks whether the given type is any kind of a floating point or not. /// </summary> /// <param name="Type">A type.</param> /// <returns>True if the type is any kind of a floating point; False otherwise.</returns> public static Boolean IsFloatingPoint(Type Type) { switch (Type.GetTypeCode(Type)) { case TypeCode.Single: case TypeCode.Double: return true; } return false; }
public override string ToQuotedString(Type fieldType, object value) { var typeCode = fieldType.GetTypeCode(); switch (typeCode) { case TypeCode.Single: return ((float)value).ToString(CultureInfo.InvariantCulture); case TypeCode.Double: return ((double)value).ToString(CultureInfo.InvariantCulture); case TypeCode.Decimal: return ((decimal)value).ToString(CultureInfo.InvariantCulture); } return base.ToQuotedString(fieldType, value); }
// keep in sync with System.Core version internal static bool IsArithmetic(Type type) { type = GetNonNullableType(type); if (!type.IsEnum()) { switch (type.GetTypeCode()) { case TypeCode.Int16: case TypeCode.Int32: case TypeCode.Int64: case TypeCode.Double: case TypeCode.Single: case TypeCode.UInt16: case TypeCode.UInt32: case TypeCode.UInt64: return true; } } return false; }
public static Instruction Create(Type type) { Debug.Assert(!type.IsEnum()); switch (type.GetTypeCode()) { case TypeCode.Int16: return _Int16 ?? (_Int16 = new DivInt16()); case TypeCode.Int32: return _Int32 ?? (_Int32 = new DivInt32()); case TypeCode.Int64: return _Int64 ?? (_Int64 = new DivInt64()); case TypeCode.UInt16: return _UInt16 ?? (_UInt16 = new DivUInt16()); case TypeCode.UInt32: return _UInt32 ?? (_UInt32 = new DivUInt32()); case TypeCode.UInt64: return _UInt64 ?? (_UInt64 = new DivUInt64()); case TypeCode.Single: return _Single ?? (_Single = new DivSingle()); case TypeCode.Double: return _Double ?? (_Double = new DivDouble()); default: throw Assert.Unreachable; } }
public TypeInfo(Type type) { Type = type; _members = Type // do not consider consts and static members. .GetFields(BindingFlags.Instance | BindingFlags.Public) .Select(makeMemberInfo) .ToArray(); var defaultConstructor = Type.GetConstructor(new Type[] {}); _constructor = defaultConstructor == null ? (Func<object>) (() => FormatterServices.GetUninitializedObject(Type)) : (() => defaultConstructor.Invoke(null)); IsObject = Type.GetTypeCode(type) == TypeCode.Object; }
public static Instruction Create(Type type) { Debug.Assert(!type.IsEnum()); switch (type.GetTypeCode()) { case TypeCode.SByte: return _SByte ?? (_SByte = new LessThanSByte()); case TypeCode.Byte: return _Byte ?? (_Byte = new LessThanByte()); case TypeCode.Char: return _Char ?? (_Char = new LessThanChar()); case TypeCode.Int16: return _Int16 ?? (_Int16 = new LessThanInt16()); case TypeCode.Int32: return _Int32 ?? (_Int32 = new LessThanInt32()); case TypeCode.Int64: return _Int64 ?? (_Int64 = new LessThanInt64()); case TypeCode.UInt16: return _UInt16 ?? (_UInt16 = new LessThanUInt16()); case TypeCode.UInt32: return _UInt32 ?? (_UInt32 = new LessThanUInt32()); case TypeCode.UInt64: return _UInt64 ?? (_UInt64 = new LessThanUInt64()); case TypeCode.Single: return _Single ?? (_Single = new LessThanSingle()); case TypeCode.Double: return _Double ?? (_Double = new LessThanDouble()); default: throw Assert.Unreachable; } }
private static string ToSwaggerDataType(Type type) { if (GetCollectionType(type) != null) { return("array"); } if (IsNullable(type)) { type = Nullable.GetUnderlyingType(type); } if (IsDate(type)) { return("string"); } if (type.GetTypeInfo().IsEnum) { return("integer"); } return(Type.GetTypeCode(type) switch { TypeCode.Boolean => "boolean", TypeCode.Decimal => "number", TypeCode.Single => "number", TypeCode.Double => "number", TypeCode.UInt16 => "integer", TypeCode.UInt32 => "integer", TypeCode.UInt64 => "integer", TypeCode.SByte => "integer", TypeCode.Byte => "integer", TypeCode.Int16 => "integer", TypeCode.Int32 => "integer", TypeCode.Int64 => "integer", TypeCode.Char => "string", TypeCode.String => "string", _ => "object" });
/// <summary> /// Gets a value indicating whether the specified type is one of the numeric types /// </summary> /// <param name="type">The type</param> /// <returns>true if the specified type is one of the numeric types; otherwise, false</returns> public static bool IsNumericType(Type type) { TypeCode typeCode = type.GetTypeCode(); switch (typeCode) { case TypeCode.SByte: case TypeCode.Byte: case TypeCode.Int16: case TypeCode.UInt16: case TypeCode.Int32: case TypeCode.UInt32: case TypeCode.Int64: case TypeCode.UInt64: case TypeCode.Single: case TypeCode.Double: case TypeCode.Decimal: return true; default: return false; } }
public override object ToDbValue(Type fieldType, object value) { var isEnumFlags = fieldType.IsEnumFlags() || (!fieldType.IsEnum && fieldType.IsNumericType()); //i.e. is real int && not Enum if (isEnumFlags && value.GetType().IsEnum) return Convert.ChangeType(value, fieldType.GetTypeCode()); long enumValue; if (long.TryParse(value.ToString(), out enumValue)) { if (isEnumFlags) return enumValue; value = Enum.ToObject(fieldType, enumValue); } var enumString = DialectProvider.StringSerializer.SerializeToString(value); return enumString != null && enumString != "null" ? enumString.Trim('"') : value.ToString(); }
internal void Stelem(Type arrayElementType) { if (arrayElementType.GetTypeInfo().IsEnum) Stelem(Enum.GetUnderlyingType(arrayElementType)); else { OpCode opCode = GetStelemOpCode(arrayElementType.GetTypeCode()); if (opCode.Equals(OpCodes.Nop)) throw new InvalidOperationException(SR.Format(SR.ArrayTypeIsNotSupported, arrayElementType.GetTypeInfo().AssemblyQualifiedName)); _ilGen.Emit(opCode); } }
public override bool CanMatchType(Type requestedType) { return requestedType == null || requestedType.IsNumeric() || requestedType.GetTypeCode() == TypeCode.Boolean; }
public static Instruction CreateLifted(Type type) { Debug.Assert(!type.IsEnum()); switch (type.GetTypeCode()) { case TypeCode.Int16: return _Int16Lifted ?? (_Int16Lifted = new NegateOvfInt16Lifted()); case TypeCode.Int32: return _Int32Lifted ?? (_Int32Lifted = new NegateOvfInt32Lifted()); case TypeCode.Int64: return _Int64Lifted ?? (_Int64Lifted = new NegateOvfInt64Lifted()); case TypeCode.UInt16: return _UInt16Lifted ?? (_UInt16Lifted = new NegateOvfUInt16Lifted()); case TypeCode.UInt32: return _UInt32Lifted ?? (_UInt32Lifted = new NegateOvfUInt32Lifted()); case TypeCode.Single: return _SingleLifted ?? (_SingleLifted = new NegateOvfSingleLifted()); case TypeCode.Double: return _DoubleLifted ?? (_DoubleLifted = new NegateOvfDoubleLifted()); default: throw Assert.Unreachable; } }
public virtual string GetQuotedValue(object value, Type fieldType) { if (value == null) return "NULL"; //var dialectProvider = OrmLiteConfig.DialectProvider; //if (fieldType.IsRefType()) //{ // return dialectProvider.GetQuotedValue(dialectProvider.StringSerializer.SerializeToString(value)); //} var typeCode = fieldType.GetTypeCode(); switch (typeCode) { case TypeCode.Single: return ((float)value).ToString(CultureInfo.InvariantCulture); case TypeCode.Double: return ((double)value).ToString(CultureInfo.InvariantCulture); case TypeCode.Decimal: return ((decimal)value).ToString(CultureInfo.InvariantCulture); case TypeCode.Byte: case TypeCode.Int16: case TypeCode.Int32: case TypeCode.Int64: case TypeCode.SByte: case TypeCode.UInt16: case TypeCode.UInt32: case TypeCode.UInt64: if (fieldType.IsNumericType()) return Convert.ChangeType(value, fieldType).ToString(); break; } if (fieldType == typeof(TimeSpan)) return ((TimeSpan)value).Ticks.ToString(CultureInfo.InvariantCulture); return ShouldQuoteValue(fieldType) ? DialectProvider.Instance.GetQuotedValue(value.ToString()) : value.ToString(); }
internal SwitchInfo(SwitchExpression node, LocalBuilder value, Label @default) { Node = node; Value = value; Default = @default; Type = Node.SwitchValue.Type; IsUnsigned = TypeUtils.IsUnsigned(Type); var code = Type.GetTypeCode(Type); Is64BitSwitch = code == TypeCode.UInt64 || code == TypeCode.Int64; }
internal void LoadDefaultValue(Type type) { if (type.GetTypeInfo().IsValueType) { switch (type.GetTypeCode()) { case TypeCode.Boolean: Ldc(false); break; case TypeCode.Char: case TypeCode.SByte: case TypeCode.Byte: case TypeCode.Int16: case TypeCode.UInt16: case TypeCode.Int32: case TypeCode.UInt32: Ldc(0); break; case TypeCode.Int64: case TypeCode.UInt64: Ldc(0L); break; case TypeCode.Single: Ldc(0.0F); break; case TypeCode.Double: Ldc(0.0); break; case TypeCode.Decimal: case TypeCode.DateTime: default: LocalBuilder zero = DeclareLocal(type, "zero"); LoadAddress(zero); InitObj(type); Load(zero); break; } } else Load(null); }
internal void Stelem(Type arrayElementType) { if (arrayElementType.GetTypeInfo().IsEnum) Stelem(Enum.GetUnderlyingType(arrayElementType)); else { OpCode opCode = GetStelemOpCode(arrayElementType.GetTypeCode()); if (opCode.Equals(OpCodes.Nop)) throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.Format(SR.ArrayTypeIsNotSupported, DataContract.GetClrTypeFullName(arrayElementType)))); if (_codeGenTrace != CodeGenTrace.None) EmitSourceInstruction(opCode.ToString()); EmitStackTop(arrayElementType); _ilGen.Emit(opCode); } }
internal static bool IsKnownType(Type type) { if (type == typeof(object)) return true; if (type.GetTypeInfo().IsEnum) return false; switch (type.GetTypeCode()) { case TypeCode.String: return true; case TypeCode.Int32: return true; case TypeCode.Boolean: return true; case TypeCode.Int16: return true; case TypeCode.Int64: return true; case TypeCode.Single: return true; case TypeCode.Double: return true; case TypeCode.Decimal: return true; case TypeCode.DateTime: return true; case TypeCode.Byte: return true; case TypeCode.SByte: return true; case TypeCode.UInt16: return true; case TypeCode.UInt32: return true; case TypeCode.UInt64: return true; case TypeCode.Char: return true; default: if (type == typeof(XmlQualifiedName)) return true; else if (type == typeof(byte[])) return true; else if (type == typeof(Guid)) return true; else if (type == typeof(XmlNode[])) return true; break; } return false; }
private void InternalConvert(Type source, Type target, bool isAddress) { if (target == source) return; if (target.GetTypeInfo().IsValueType) { if (source.GetTypeInfo().IsValueType) { OpCode opCode = GetConvOpCode(target.GetTypeCode()); if (opCode.Equals(OpCodes.Nop)) { throw new CodeGeneratorConversionException(source, target, isAddress, "NoConversionPossibleTo"); } else { _ilGen.Emit(opCode); } } else if (source.IsAssignableFrom(target)) { Unbox(target); if (!isAddress) Ldobj(target); } else { throw new CodeGeneratorConversionException(source, target, isAddress, "IsNotAssignableFrom"); } } else if (target.IsAssignableFrom(source)) { if (source.GetTypeInfo().IsValueType) { if (isAddress) Ldobj(source); Box(source); } } else if (source.IsAssignableFrom(target)) { Castclass(target); } else if (target.GetTypeInfo().IsInterface || source.GetTypeInfo().IsInterface) { Castclass(target); } else { throw new CodeGeneratorConversionException(source, target, isAddress, "IsNotAssignableFrom"); } }
internal static XmlQualifiedName GetPrimitiveTypeNameInternal(Type type) { string typeName; string typeNs = XmlSchema.Namespace; switch (type.GetTypeCode()) { case TypeCode.String: typeName = "string"; break; case TypeCode.Int32: typeName = "int"; break; case TypeCode.Boolean: typeName = "boolean"; break; case TypeCode.Int16: typeName = "short"; break; case TypeCode.Int64: typeName = "long"; break; case TypeCode.Single: typeName = "float"; break; case TypeCode.Double: typeName = "double"; break; case TypeCode.Decimal: typeName = "decimal"; break; case TypeCode.DateTime: typeName = "dateTime"; break; case TypeCode.Byte: typeName = "unsignedByte"; break; case TypeCode.SByte: typeName = "byte"; break; case TypeCode.UInt16: typeName = "unsignedShort"; break; case TypeCode.UInt32: typeName = "unsignedInt"; break; case TypeCode.UInt64: typeName = "unsignedLong"; break; case TypeCode.Char: typeName = "char"; typeNs = UrtTypes.Namespace; break; default: if (type == typeof(XmlQualifiedName)) typeName = "QName"; else if (type == typeof(byte[])) typeName = "base64Binary"; else if (type == typeof(Guid)) { typeName = "guid"; typeNs = UrtTypes.Namespace; } else if (type == typeof (TimeSpan)) { typeName = "TimeSpan"; typeNs = UrtTypes.Namespace; } else if (type == typeof (XmlNode[])) { typeName = Soap.UrType; } else return null; break; } return new XmlQualifiedName(typeName, typeNs); }
internal void Ldobj(Type type) { OpCode opCode = GetLdindOpCode(type.GetTypeCode()); if (!opCode.Equals(OpCodes.Nop)) { _ilGen.Emit(opCode); } else { _ilGen.Emit(OpCodes.Ldobj, type); } }
internal EnumConverter(BclType targetType) : base(targetType) { _typeCode = BclType.GetTypeCode(TargetType); }
private bool TryWritePrimitiveArray(Type type, Type itemType, LocalBuilder value, LocalBuilder itemName) { PrimitiveDataContract primitiveContract = PrimitiveDataContract.GetPrimitiveDataContract(itemType); if (primitiveContract == null) return false; string writeArrayMethod = null; switch (itemType.GetTypeCode()) { case TypeCode.Boolean: writeArrayMethod = "WriteJsonBooleanArray"; break; case TypeCode.DateTime: writeArrayMethod = "WriteJsonDateTimeArray"; break; case TypeCode.Decimal: writeArrayMethod = "WriteJsonDecimalArray"; break; case TypeCode.Int32: writeArrayMethod = "WriteJsonInt32Array"; break; case TypeCode.Int64: writeArrayMethod = "WriteJsonInt64Array"; break; case TypeCode.Single: writeArrayMethod = "WriteJsonSingleArray"; break; case TypeCode.Double: writeArrayMethod = "WriteJsonDoubleArray"; break; default: break; } if (writeArrayMethod != null) { WriteArrayAttribute(); MethodInfo writeArrayMethodInfo = typeof(JsonWriterDelegator).GetMethod( writeArrayMethod, Globals.ScanAllMembers, new Type[] { type, typeof(XmlDictionaryString), typeof(XmlDictionaryString) }); _ilg.Call(_xmlWriterArg, writeArrayMethodInfo, value, itemName, null); return true; } return false; }
internal static Candidate PreferConvert(Type t1, Type t2) { switch (t1.GetTypeCode()) { case TypeCode.SByte: switch (t2.GetTypeCode()) { case TypeCode.Byte: case TypeCode.UInt16: case TypeCode.UInt32: case TypeCode.UInt64: return Candidate.Two; default: return Candidate.Equivalent; } case TypeCode.Int16: switch (t2.GetTypeCode()) { case TypeCode.UInt16: case TypeCode.UInt32: case TypeCode.UInt64: return Candidate.Two; default: return Candidate.Equivalent; } case TypeCode.Int32: switch (t2.GetTypeCode()) { case TypeCode.UInt32: case TypeCode.UInt64: return Candidate.Two; default: return Candidate.Equivalent; } case TypeCode.Int64: switch (t2.GetTypeCode()) { case TypeCode.UInt64: return Candidate.Two; default: return Candidate.Equivalent; } case TypeCode.Boolean: if (t2 == typeof(int)) { return Candidate.Two; } return Candidate.Equivalent; case TypeCode.Decimal: case TypeCode.Double: if (t2 == typeof(BigInteger)) { return Candidate.Two; } return Candidate.Equivalent; case TypeCode.Char: if (t2 == typeof(string)) { return Candidate.Two; } return Candidate.Equivalent; } return Candidate.Equivalent; }
private void InternalConvert(Type source, Type target, bool isAddress) { if (target == source) return; if (target.GetTypeInfo().IsValueType) { if (source.GetTypeInfo().IsValueType) { OpCode opCode = GetConvOpCode(target.GetTypeCode()); if (opCode.Equals(OpCodes.Nop)) throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.Format(SR.NoConversionPossibleTo, DataContract.GetClrTypeFullName(target)))); else { if (_codeGenTrace != CodeGenTrace.None) EmitSourceInstruction(opCode.ToString()); _ilGen.Emit(opCode); } } else if (source.IsAssignableFrom(target)) { Unbox(target); if (!isAddress) Ldobj(target); } else throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.Format(SR.IsNotAssignableFrom, DataContract.GetClrTypeFullName(target), DataContract.GetClrTypeFullName(source)))); } else if (target.IsAssignableFrom(source)) { if (source.GetTypeInfo().IsValueType) { if (isAddress) Ldobj(source); Box(source); } } else if (source.IsAssignableFrom(target)) { Castclass(target); } else if (target.GetTypeInfo().IsInterface || source.GetTypeInfo().IsInterface) { Castclass(target); } else throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.Format(SR.IsNotAssignableFrom, DataContract.GetClrTypeFullName(target), DataContract.GetClrTypeFullName(source)))); }
private void InternalConvert(Type source, Type target, bool isAddress) { if (target == source) return; if (target.GetTypeInfo().IsValueType) { if (source.GetTypeInfo().IsValueType) { OpCode opCode = GetConvOpCode(target.GetTypeCode()); if (opCode.Equals(OpCodes.Nop)) { throw new InvalidOperationException(SR.Format(SR.NoConversionPossibleTo, target.GetTypeInfo().AssemblyQualifiedName)); } else { _ilGen.Emit(opCode); } } else if (source.IsAssignableFrom(target)) { Unbox(target); if (!isAddress) Ldobj(target); } else { throw new InvalidOperationException(SR.Format(SR.IsNotAssignableFrom, target.GetTypeInfo().AssemblyQualifiedName, source.GetTypeInfo().AssemblyQualifiedName)); } } else if (target.IsAssignableFrom(source)) { if (source.GetTypeInfo().IsValueType) { if (isAddress) Ldobj(source); Box(source); } } else if (source.IsAssignableFrom(target)) { Castclass(target); } else if (target.GetTypeInfo().IsInterface || source.GetTypeInfo().IsInterface) { Castclass(target); } else { throw new InvalidOperationException(SR.Format(SR.IsNotAssignableFrom, target.GetTypeInfo().AssemblyQualifiedName, source.GetTypeInfo().AssemblyQualifiedName)); } }
internal void Ldobj(Type type) { OpCode opCode = GetLdindOpCode(type.GetTypeCode()); if (!opCode.Equals(OpCodes.Nop)) { if (_codeGenTrace != CodeGenTrace.None) EmitSourceInstruction(opCode.ToString()); _ilGen.Emit(opCode); } else { if (_codeGenTrace != CodeGenTrace.None) EmitSourceInstruction("Ldobj " + type); _ilGen.Emit(OpCodes.Ldobj, type); } }
private bool TryReadPrimitiveArray(Type itemType) { PrimitiveDataContract primitiveContract = PrimitiveDataContract.GetPrimitiveDataContract(itemType); if (primitiveContract == null) return false; string readArrayMethod = null; switch (itemType.GetTypeCode()) { case TypeCode.Boolean: readArrayMethod = "TryReadBooleanArray"; break; case TypeCode.Decimal: readArrayMethod = "TryReadDecimalArray"; break; case TypeCode.Int32: readArrayMethod = "TryReadInt32Array"; break; case TypeCode.Int64: readArrayMethod = "TryReadInt64Array"; break; case TypeCode.Single: readArrayMethod = "TryReadSingleArray"; break; case TypeCode.Double: readArrayMethod = "TryReadDoubleArray"; break; case TypeCode.DateTime: readArrayMethod = "TryReadJsonDateTimeArray"; break; default: break; } if (readArrayMethod != null) { _ilg.Load(_xmlReaderArg); _ilg.ConvertValue(typeof(XmlReaderDelegator), typeof(JsonReaderDelegator)); _ilg.Load(_contextArg); _ilg.Load(_memberNamesArg); // Empty namespace _ilg.Load(_emptyDictionaryStringArg); // -1 Array Size _ilg.Load(-1); _ilg.Ldloca(_objectLocal); _ilg.Call(typeof(JsonReaderDelegator).GetMethod(readArrayMethod, Globals.ScanAllMembers)); return true; } return false; }
public static Instruction CreateLifted(Type type) { Debug.Assert(!type.IsEnum()); switch (type.GetTypeCode()) { case TypeCode.SByte: return _SByteLifted ?? (_SByteLifted = new LessThanSByte() { LiftedToNull = true }); case TypeCode.Byte: return _ByteLifted ?? (_ByteLifted = new LessThanByte() { LiftedToNull = true }); case TypeCode.Char: return _CharLifted ?? (_CharLifted = new LessThanChar() { LiftedToNull = true }); case TypeCode.Int16: return _Int16Lifted ?? (_Int16Lifted = new LessThanInt16() { LiftedToNull = true }); case TypeCode.Int32: return _Int32Lifted ?? (_Int32Lifted = new LessThanInt32() { LiftedToNull = true }); case TypeCode.Int64: return _Int64Lifted ?? (_Int64Lifted = new LessThanInt64() { LiftedToNull = true }); case TypeCode.UInt16: return _UInt16Lifted ?? (_UInt16Lifted = new LessThanUInt16() { LiftedToNull = true }); case TypeCode.UInt32: return _UInt32Lifted ?? (_UInt32Lifted = new LessThanUInt32() { LiftedToNull = true }); case TypeCode.UInt64: return _UInt64Lifted ?? (_UInt64Lifted = new LessThanUInt64() { LiftedToNull = true }); case TypeCode.Single: return _SingleLifted ?? (_SingleLifted = new LessThanSingle() { LiftedToNull = true }); case TypeCode.Double: return _DoubleLifted ?? (_DoubleLifted = new LessThanDouble() { LiftedToNull = true }); default: throw Assert.Unreachable; } }
// IConvertible methods Start --> public TypeCode GetTypeCode () { return Type.GetTypeCode (GetUnderlyingType (this.GetType ())); }