public static object GetValue(this JsonElement json, Type type) { switch (Type.GetTypeCode(type)) { case TypeCode.Boolean: return(json.GetBoolean()); case TypeCode.SByte: return(json.GetSByte()); case TypeCode.Int16: return(json.GetInt16()); case TypeCode.Int32: return(json.GetInt32()); case TypeCode.Int64: return(json.GetInt64()); case TypeCode.Byte: return(json.GetByte()); case TypeCode.UInt16: return(json.GetUInt16()); case TypeCode.UInt32: return(json.GetUInt32()); case TypeCode.UInt64: return(json.GetUInt64()); case TypeCode.Single: return(json.GetSingle()); case TypeCode.Double: return(json.GetDouble()); case TypeCode.Decimal: return(json.GetDecimal()); case TypeCode.String: return(json.GetString()); case TypeCode.DateTime: return(json.GetDateTime()); } return(Convert.ChangeType(json.GetRawText(), type)); }
private static object WrapResultObject(JsonElement value) { switch (value.ValueKind) { case JsonValueKind.Array: return(value.EnumerateArray() .Select(x => WrapResultObject(x)) .ToList()); case JsonValueKind.Object: return(new DynamicJsonObject(value)); case JsonValueKind.False: case JsonValueKind.True: return(value.GetBoolean()); case JsonValueKind.String: return(value.GetString()); case JsonValueKind.Number: return(value.GetInt64()); case JsonValueKind.Null: case JsonValueKind.Undefined: return(null); default: return(value); } }
/// <summary> /// Sums the integer values in the specified JSON element, ignoring any values from /// child elements that contain the specified string value, if specified. /// </summary> /// <param name="element">The JSON element.</param> /// <param name="valueToIgnore">The elements to ignore if they contain this value.</param> /// <returns>The sum of the elements in <paramref name="element"/>.</returns> internal static long SumIntegerValues(JsonElement element, string valueToIgnore) { long sum = 0; if (element.ValueKind == JsonValueKind.Number) { sum = element.GetInt64(); } else if (element.ValueKind == JsonValueKind.Array) { foreach (JsonElement child in element.EnumerateArray()) { sum += SumIntegerValues(child, valueToIgnore); } } else if (element.ValueKind == JsonValueKind.Object) { foreach (JsonProperty child in element.EnumerateObject()) { if (child.Value.ValueKind == JsonValueKind.String && child.Value.GetString() == valueToIgnore) { return(0); } sum += SumIntegerValues(child.Value, valueToIgnore); } } return(sum); }
private object GetValue(JsonElement enumValue) { switch (enumValue.ValueKind) { case JsonValueKind.String: return(enumValue.GetString()); case JsonValueKind.Number: if (enumValue.TryGetInt32(out Int32 intValue)) { return(enumValue.GetInt32()); } if (enumValue.TryGetInt64(out Int64 LongValue)) { return(enumValue.GetInt64()); } return(enumValue.GetDouble()); case JsonValueKind.True: case JsonValueKind.False: return(enumValue.GetBoolean()); case JsonValueKind.Null: return(null); default: return(enumValue.ToString()); } }
public static void SetValueFromJson(this PropertyInfo property, Object obj, JsonElement value, string dateTimeFormat = null) { TypeCode typeCode = Type.GetTypeCode(property.PropertyType); switch (typeCode) { case TypeCode.Int32: int int32Value = value.GetInt32(); property.SetValue(obj, int32Value); break; case TypeCode.Int64: long int64Value = value.GetInt64(); property.SetValue(obj, int64Value); break; case TypeCode.Double: double doubleValue = value.GetDouble(); property.SetValue(obj, doubleValue); break; case TypeCode.Decimal: decimal decimalValue = value.GetDecimal(); property.SetValue(obj, decimalValue); break; case TypeCode.Boolean: bool boolValue = value.GetBoolean(); property.SetValue(obj, boolValue); break; case TypeCode.DateTime: DateTime dateTimeValue; if (value.ValueKind == JsonValueKind.Null) { dateTimeValue = DateTime.MinValue; } else if (!string.IsNullOrEmpty(dateTimeFormat)) { var stringDateTimeValue = value.GetString(); dateTimeValue = DateTime.ParseExact(stringDateTimeValue, dateTimeFormat, CultureInfo.InvariantCulture); } else { dateTimeValue = value.GetDateTime(); } property.SetValue(obj, dateTimeValue); break; case TypeCode.String: string stringValue = value.GetString(); property.SetValue(obj, stringValue); break; default: //ThrowNotImplementedException(type); TODO: Сделать исключение. break; } }
public override void SerializePrimitive <T>(ref T val) { switch (val) { case bool: Unsafe.As <T, bool>(ref val) = currentNode.GetBoolean(); break; case int: Unsafe.As <T, int>(ref val) = currentNode.GetInt32(); break; case uint: Unsafe.As <T, uint>(ref val) = currentNode.GetUInt32(); break; case float: Unsafe.As <T, float>(ref val) = currentNode.GetSingle(); break; case double: Unsafe.As <T, double>(ref val) = currentNode.GetDouble(); break; case long: Unsafe.As <T, long>(ref val) = currentNode.GetInt64(); break; case ulong: Unsafe.As <T, ulong>(ref val) = currentNode.GetUInt64(); break; case short: Unsafe.As <T, short>(ref val) = currentNode.GetInt16(); break; case ushort: Unsafe.As <T, ushort>(ref val) = currentNode.GetUInt16(); break; case char: Unsafe.As <T, char>(ref val) = (char)currentNode.GetUInt16(); break; case sbyte: Unsafe.As <T, sbyte>(ref val) = currentNode.GetSByte(); break; case byte: Unsafe.As <T, byte>(ref val) = currentNode.GetByte(); break; case decimal: Unsafe.As <T, decimal>(ref val) = currentNode.GetDecimal(); break; } }
public static object ToObject(this JsonElement element, ColumnType columnType) { return(columnType switch { ColumnType.Boolean => element.GetBoolean(), ColumnType.Decimal => element.GetDecimal(), ColumnType.Integer => element.GetInt64(), ColumnType.String => element.GetString(), ColumnType.DateTime => element.GetDateTime(), _ => throw new ArgumentException($"Unsupported columnType conversion [{columnType}]", nameof(columnType)) });
private static bool ValidateSimpleDataType(DataTypeEnum dataType, JsonElement prop, List <string> errors) { if (dataType == DataTypeEnum.Time) { return(CanConvertToTime(prop.GetString())); } else if (dataType == DataTypeEnum.DateTime || dataType == DataTypeEnum.Date) { return(CanConvertToDateTime(prop.GetString())); } else if (dataType == DataTypeEnum.Binary) { return(CanConvertToBase64(prop.GetString())); } else if (dataType == DataTypeEnum.GUID) { return(CanConvertToGuid(prop.GetString())); } else if (dataType == DataTypeEnum.Booelan) { return(CanConvertToBoolean(prop.GetString())); } else if (dataType == DataTypeEnum.String) { return(true); } else if (dataType == DataTypeEnum.Float) { try { prop.GetDouble(); return(true); } catch { return(false); } } else if (dataType == DataTypeEnum.Integer) { try { prop.GetInt64(); return(true); } catch { return(false); } } return(false); }
private long SumNumbers(JsonElement element, Func <JsonElement, bool> shouldSkipObject) { return(element.ValueKind switch { JsonValueKind.Undefined => 0, JsonValueKind.Object => shouldSkipObject(element) ? 0 : element.EnumerateObject().Sum(p => SumNumbers(p.Value, shouldSkipObject)), JsonValueKind.Array => element.EnumerateArray().Sum(e => SumNumbers(e, shouldSkipObject)), JsonValueKind.String => long.TryParse(element.GetString(), out long l) ? l : 0, JsonValueKind.Number => element.GetInt64(), JsonValueKind.True => 0, JsonValueKind.False => 0, JsonValueKind.Null => 0, _ => 0 });
public Contributor(JsonElement contributor) { if (contributor.IsNull()) { return; } if (contributor.ValueKind == JsonValueKind.Number) { ID = contributor.GetInt64().ToString(); } else { ID = contributor.GetLong("id_str").ToString(); ScreenName = contributor.GetString("screen_name"); } }
public override object?Invert(JsonElement value) { if (value.ValueKind == JsonValueKind.Null) { return(null); } return(columnType switch { DValueType.Bool => value.GetBoolean(), DValueType.Integer => value.GetInt64(), DValueType.Real => value.GetDouble(), DValueType.Date => value.GetDateTime(), DValueType.Datetime => value.GetDateTime(), DValueType.Text => value.GetString(), DValueType.Timestamp => value.GetDateTime(), DValueType.Unknown => value.GetString(), _ => throw new InvalidOperationException($"Unknown column type <{columnType}>"), });
/// <summary> /// A potentially recursive function that deserializes a property from JSON to its .NET equivalent type. /// For properties that are class types, this will recurse and deserialize that type as well if there are any valid GraphQL properties /// </summary> /// <param name="value">The JSON element to deserialize</param> /// <param name="modelProperty">The destination model property</param> /// <param name="model">The model that owns the property being deserialized</param> public void DeserializeMember(JsonElement value, PropertyInfo modelProperty, object model) { if (modelProperty.PropertyType == typeof(string)) { modelProperty.SetValue(model, value.GetString()); } else if (modelProperty.PropertyType == typeof(double)) { modelProperty.SetValue(model, value.GetDouble()); } else if (modelProperty.PropertyType == typeof(short)) { modelProperty.SetValue(model, value.GetInt16()); } else if (modelProperty.PropertyType == typeof(int)) { modelProperty.SetValue(model, value.GetInt32()); } else if (modelProperty.PropertyType == typeof(long)) { modelProperty.SetValue(model, value.GetInt64()); } else if (modelProperty.PropertyType.IsEnum) { modelProperty.SetValue(model, Enum.Parse(modelProperty.PropertyType, value.GetRawText())); } else if (modelProperty.PropertyType.IsClass) { var properties = modelProperty.PropertyType .GetProperties() .Where(property => property.CustomAttributes.Any(attr => attr.AttributeType == typeof(GraphQLPropertyAttribute))) .ToList(); foreach (var property in properties) { var fieldName = property.GetCustomAttribute <GraphQLPropertyAttribute>().FieldName; var propModel = Activator.CreateInstance(modelProperty.PropertyType); modelProperty.SetValue(model, propModel); DeserializeMember(value.GetProperty(fieldName), property, propModel); } } }
public static object ConsumeJsonElement(Type targetReturnType, JsonElement e) { // ReSharper disable once HeapView.BoxingAllocation object ParseNumber(JsonElement el) { if (el.TryGetInt64(out var l)) { return(l); } return(el.GetDouble()); } return(targetReturnType switch { _ when targetReturnType == typeof(bool) => e.GetBoolean(), _ when targetReturnType == typeof(byte) => e.GetByte(), _ when targetReturnType == typeof(decimal) => e.GetDecimal(), _ when targetReturnType == typeof(double) => e.GetDouble(), _ when targetReturnType == typeof(Guid) => e.GetGuid(), _ when targetReturnType == typeof(short) => e.GetInt16(), _ when targetReturnType == typeof(int) => e.GetInt32(), _ when targetReturnType == typeof(long) => e.GetInt64(), _ when targetReturnType == typeof(float) => e.GetSingle(), _ when targetReturnType == typeof(string) => e.GetString(), _ when targetReturnType == typeof(DateTime) => e.GetDateTime(), _ when targetReturnType == typeof(DateTimeOffset) => e.GetDateTimeOffset(), _ when targetReturnType == typeof(ushort) => e.GetUInt16(), _ when targetReturnType == typeof(uint) => e.GetUInt32(), _ when targetReturnType == typeof(ulong) => e.GetUInt64(), _ when targetReturnType == typeof(sbyte) => e.GetSByte(), _ when targetReturnType == typeof(DynamicDictionary) => DynamicDictionary.Create(e), _ when targetReturnType == typeof(object) && e.ValueKind == JsonValueKind.Array => e.EnumerateArray().Select(je => ConsumeJsonElement(targetReturnType, je)).ToArray(), _ when targetReturnType == typeof(object) && e.ValueKind == JsonValueKind.Object => e.ToDictionary(), _ when targetReturnType == typeof(object) && e.ValueKind == JsonValueKind.True => true, _ when targetReturnType == typeof(object) && e.ValueKind == JsonValueKind.False => false, _ when targetReturnType == typeof(object) && e.ValueKind == JsonValueKind.Null => null, _ when targetReturnType == typeof(object) && e.ValueKind == JsonValueKind.String => e.GetString(), _ when targetReturnType == typeof(object) && e.ValueKind == JsonValueKind.Number => ParseNumber(e), _ => null });
private static object ToObject(this JsonElement jsonElement) { switch (jsonElement.ValueKind) { case JsonValueKind.Null: return(null); case JsonValueKind.String: return(jsonElement.GetString()); case JsonValueKind.Number: return(jsonElement.GetInt64()); case JsonValueKind.True: return(true); case JsonValueKind.False: return(false); case JsonValueKind.Undefined: case JsonValueKind.Object: case JsonValueKind.Array: default: throw new NotSupportedException($"Unsupported ValueKind - {jsonElement.ValueKind}"); } }
public async Task TestActorSettingsWithRemindersStoragePartitions() { var actorType = typeof(TestActor); var options = new ActorRuntimeOptions(); options.Actors.RegisterActor <TestActor>(); options.RemindersStoragePartitions = 12; var runtime = new ActorRuntime(options, loggerFactory, activatorFactory, proxyFactory); Assert.Contains(actorType.Name, runtime.RegisteredActors.Select(a => a.Type.ActorTypeName), StringComparer.InvariantCulture); ArrayBufferWriter <byte> writer = new ArrayBufferWriter <byte>(); await runtime.SerializeSettingsAndRegisteredTypes(writer); // read back the serialized json var array = writer.WrittenSpan.ToArray(); string s = Encoding.UTF8.GetString(array, 0, array.Length); JsonDocument document = JsonDocument.Parse(s); JsonElement root = document.RootElement; // parse out the entities array JsonElement element = root.GetProperty("entities"); Assert.Equal(1, element.GetArrayLength()); JsonElement arrayElement = element[0]; string actor = arrayElement.GetString(); Assert.Equal("TestActor", actor); element = root.GetProperty("remindersStoragePartitions"); Assert.Equal(12, element.GetInt64()); }
public override long Get(JsonElement property) => property.GetInt64();
private static object ParseValue(JsonElement jsonEl, Type type) { var valueKind = jsonEl.ValueKind; var targetType = type; var isNullable = false; var nullableType = Nullable.GetUnderlyingType(type); if (nullableType != null) { targetType = nullableType; isNullable = true; } if (targetType.IsEnum) { targetType = Enum.GetUnderlyingType(targetType); } switch (valueKind) { case JsonValueKind.Array: case JsonValueKind.Null: case JsonValueKind.Undefined: case JsonValueKind.Object: return(isNullable ? null : targetType.GetDefault()); case JsonValueKind.False: case JsonValueKind.True: return(jsonEl.GetBoolean()); case JsonValueKind.String: return(targetType == typeof(string) ? jsonEl.GetString() : targetType == typeof(DateTime) ? jsonEl.GetDateTime() : targetType == typeof(Guid) ? jsonEl.GetGuid() : targetType.GetDefault()); case JsonValueKind.Number: return(targetType == typeof(byte) ? jsonEl.GetByte() : targetType == typeof(decimal) ? jsonEl.GetDecimal() : targetType == typeof(double) ? jsonEl.GetDouble() : targetType == typeof(short) ? jsonEl.GetInt16() : targetType == typeof(int) ? jsonEl.GetInt32() : targetType == typeof(long) ? jsonEl.GetInt64() : targetType == typeof(sbyte) ? jsonEl.GetSByte() : targetType == typeof(float) ? jsonEl.GetSingle() : targetType == typeof(ushort) ? jsonEl.GetUInt16() : targetType == typeof(uint) ? jsonEl.GetUInt32() : targetType == typeof(ulong) ? jsonEl.GetUInt64() : targetType.GetDefault()); default: return(targetType.GetDefault()); } }
public static object ToObject(this JsonElement element, Type type) { object result = null; var nonNullType = Nullable.GetUnderlyingType(type); if (nonNullType != null) { type = nonNullType; } switch (Type.GetTypeCode(type)) { case TypeCode.Boolean: result = element.GetBoolean(); break; case TypeCode.Byte: result = element.GetByte(); break; case TypeCode.SByte: result = element.GetSByte(); break; case TypeCode.Int16: result = element.GetInt16(); break; case TypeCode.UInt16: result = element.GetUInt16(); break; case TypeCode.Int32: result = element.GetInt32(); break; case TypeCode.UInt32: result = element.GetUInt32(); break; case TypeCode.Int64: result = element.GetInt64(); break; case TypeCode.UInt64: result = element.GetUInt64(); break; case TypeCode.Single: result = element.GetSingle(); break; case TypeCode.Double: result = element.GetDouble(); break; case TypeCode.Decimal: result = element.GetDecimal(); break; case TypeCode.DateTime: result = element.GetDateTime(); break; case TypeCode.String: result = element.GetString(); break; default: if (type == typeof(Guid)) { result = element.GetGuid(); break; } throw new NotImplementedException(); } if (nonNullType != null) { return(result.ToNullable()); } return(result); }
public dynamic Objectify(JsonElement graphsonObject, GraphSONReader reader) { var milliseconds = graphsonObject.GetInt64(); return(UnixStart.AddTicks(TimeSpan.TicksPerMillisecond * milliseconds)); }
private long DeserializeLong(JsonElement obj, string fieldName) { JsonElement value = obj.GetProperty(fieldName); return((long)_longSerializer.Deserialize(value.GetInt64())); }
private static object DeserializeJsonValue(Type type, JsonElement value) { if (value.ValueKind == JsonValueKind.Null && (type == typeof(string) || Nullable.GetUnderlyingType(type) != null)) { return(null); } else if (type == typeof(bool) || type == typeof(bool?)) { return(value.GetBoolean()); } else if (type == typeof(byte) || type == typeof(byte?)) { return(value.GetByte()); } else if (type == typeof(short) || type == typeof(short?)) { return(value.GetInt16()); } else if (type == typeof(ushort) || type == typeof(ushort?)) { return(value.GetUInt16()); } else if (type == typeof(int) || type == typeof(int?)) { return(value.GetInt32()); } else if (type == typeof(uint) || type == typeof(uint?)) { return(value.GetUInt32()); } else if (type == typeof(long) || type == typeof(long?)) { return(value.GetInt64()); } else if (type == typeof(ulong) || type == typeof(ulong?)) { return(value.GetUInt64()); } else if (type == typeof(float) || type == typeof(float?)) { return(value.GetSingle()); } else if (type == typeof(double) || type == typeof(double?)) { return(value.GetDouble()); } else if (type == typeof(decimal) || type == typeof(decimal?)) { return(value.GetDecimal()); } else if (type == typeof(DateTime) || type == typeof(DateTime?)) { return(value.GetDateTime()); } else if (type == typeof(DateTimeOffset) || type == typeof(DateTimeOffset?)) { return(value.GetDateTimeOffset()); } else if (type == typeof(TimeSpan) || type == typeof(TimeSpan?)) { return(TimeSpan.Parse(value.GetString())); } else if (type == typeof(string)) { return(value.GetString()); } else { return(JsonSerializer.Deserialize(value.GetRawText(), type)); } }
protected void AssertJsonValue(JsonElement expected, object actual) { bool switched = true; switch (actual) { case Guid guid: Assert.Equal(new Guid(expected.GetString()), guid); break; case DateTime dateTime: Assert.Equal(expected.GetDateTime(), dateTime); break; case DateTimeOffset dateTime: Assert.Equal(expected.GetDateTimeOffset(), dateTime); break; case TimeSpan timeSpan: Assert.Equal(TimeSpan.FromSeconds(expected.GetInt32()), timeSpan); break; case int @int: if (expected.ValueKind == JsonValueKind.String) { Assert.Equal(int.Parse(expected.GetString()), @int); } else { Assert.Equal(expected.GetInt32(), @int); } break; case long @long: if (expected.ValueKind == JsonValueKind.String) { Assert.Equal(long.Parse(expected.GetString()), @long); } else { Assert.Equal(expected.GetInt64(), @long); } break; case double @double: Assert.Equal(expected.GetDouble(), @double, 10); break; case bool @bool: Assert.Equal(expected.GetBoolean(), @bool); break; case string @string: Assert.Equal(expected.GetString(), @string); break; case null: if (expected.ValueKind == JsonValueKind.String) { Assert.Equal(expected.GetString(), string.Empty); } break; default: switched = false; break; } if (!switched) { var type = actual !.GetType(); if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(ApiEnum <>)) { var enumType = type.GenericTypeArguments[0]; dynamic @enum = actual; // Just for easiness Assert.Equal(expected.GetString(), @enum.RawValue); if (@enum.IsUnknown) { var enumNames = Enum.GetNames(enumType) .Select(x => enumType.GetField(x).GetCustomAttribute <EnumMemberAttribute>()?.Value ?? x); Assert.True(enumNames.Contains((string)@enum.RawValue, StringComparer.OrdinalIgnoreCase), $"Expected '{expected}' to be a value in enumerator {@enum.Value.GetType().FullName}; detected value '{@enum.Value}'"); } dynamic expectedEnum = Activator.CreateInstance(type, BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public, null, new[] { expected.GetString() }, null); Assert.Equal(expectedEnum.Value, @enum.Value); switched = true; } } if (!switched) { Assert.Equal(expected.GetString(), actual !.ToString()); } }
public static long ParseInt64(this JsonElement el) { return(el.ValueKind == JsonValueKind.String ? long.Parse(el.GetString()) : el.GetInt64()); }
protected override dynamic FromJsonElement(JsonElement graphson) => graphson.GetInt64();
private static object WithValue(this PropertyInfo property, JsonElement value) { var propType = property.PropertyType; if (value.ValueKind == JsonValueKind.Null) { return(propType.GetDefaultValue()); } else if (typeof(bool) == propType) { return(value.GetBoolean()); } else if (typeof(int) == propType) { return(value.GetInt32()); } else if (typeof(uint) == propType) { return(value.GetUInt32()); } else if (typeof(short) == propType) { return(value.GetInt16()); } else if (typeof(ushort) == propType) { return(value.GetUInt16()); } else if (typeof(long) == propType) { return(value.GetInt64()); } else if (typeof(ulong) == propType) { return(value.GetUInt64()); } else if (typeof(string) == propType) { return(value.GetString()); } else if (typeof(byte) == propType) { return(value.GetByte()); } else if (typeof(sbyte) == propType) { return(value.GetSByte()); } else if (typeof(DateTime) == propType) { return(value.GetDateTime()); } else if (typeof(DateTimeOffset) == propType) { return(value.GetDateTimeOffset()); } else if (typeof(double) == propType) { return(value.GetDouble()); } else if (typeof(float) == propType) { return(value.GetSingle()); } else if (typeof(Guid) == propType) { return(value.GetGuid()); } else if (typeof(decimal) == propType) { return(value.GetDecimal()); } else if (value.GetType() == propType) { return(value); } else { return(value.ToObject(propType)); } }
static object UnboxJson(JsonElement value) => value.ValueKind == JsonValueKind.String ? value.GetString() : value.ValueKind == JsonValueKind.Number ? value.GetInt64() : (object)value;
public override object Create(JsonElement reader, Type type, JsonSerializer serializer) { return(Enum.ToObject(type, reader.GetInt64())); }
public static object GetValue(JsonElement jsonElement) { if (_columnDataType == typeof(DateTime)) { return(jsonElement.GetDateTime()); } else if (_columnDataType.IsEnum) { if (jsonElement.ValueKind == JsonValueKind.Number) { return(Enum.Parse(THelper.GetUnderlyingType <TValue>(), jsonElement.GetInt32().ToString())); } else { return(Enum.Parse(THelper.GetUnderlyingType <TValue>(), jsonElement.GetString())); } } else if (_columnDataType == typeof(byte)) { return(jsonElement.GetByte()); } else if (_columnDataType == typeof(decimal)) { return(jsonElement.GetDecimal()); } else if (_columnDataType == typeof(double)) { return(jsonElement.GetDouble()); } else if (_columnDataType == typeof(short)) { return(jsonElement.GetInt16()); } else if (_columnDataType == typeof(int)) { return(jsonElement.GetInt32()); } else if (_columnDataType == typeof(long)) { return(jsonElement.GetInt64()); } else if (_columnDataType == typeof(sbyte)) { return(jsonElement.GetSByte()); } else if (_columnDataType == typeof(float)) { return(jsonElement.GetSingle()); } else if (_columnDataType == typeof(ushort)) { return(jsonElement.GetUInt16()); } else if (_columnDataType == typeof(uint)) { return(jsonElement.GetUInt32()); } else if (_columnDataType == typeof(ulong)) { return(jsonElement.GetUInt64()); } else if (_columnDataType == typeof(Guid)) { return(jsonElement.GetGuid()); } else if (_columnDataType == typeof(bool)) { if (jsonElement.ValueKind == JsonValueKind.True) { return(true); } else { return(false); } } else { return(jsonElement.GetString()); } }