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 ()));
}
