private bool ElementEquals(JsonElement element1, JsonElement element2)
{
if (!element1.ValueKind.Equals(element2.ValueKind))
{
return(false);
}
else
{
switch (element1.ValueKind)
{
case JsonValueKind.Array:
return(ArrayElementEquals(element1, element2));
case JsonValueKind.Object:
return(ObjectElementEquals(element1, element2));
case JsonValueKind.Undefined:
case JsonValueKind.Null:
case JsonValueKind.True:
case JsonValueKind.False:
return(true);
case JsonValueKind.Number:
return(element1.GetDecimal().Equals(element2.GetDecimal()));
case JsonValueKind.String:
return(string.Equals(element1.GetString(), element2.GetString()));
default:
throw new NotSupportedException($"JSON value kind not supported: {element1.ValueKind}");
}
}
}
static object GetPropertyValue(JsonElement jsonElement)
{
switch (jsonElement.ValueKind)
{
case JsonValueKind.String:
return(jsonElement.GetString());
case JsonValueKind.Number:
int integerOutput;
if (jsonElement.TryGetInt32(out integerOutput))
{
return(integerOutput);
}
else
{
return(jsonElement.GetDecimal());
}
case JsonValueKind.True:
case JsonValueKind.False:
return(jsonElement.GetBoolean());
case JsonValueKind.Null:
return(null);
case JsonValueKind.Object:
case JsonValueKind.Array:
return(ParseJsonElement(jsonElement));
}
throw new ArgumentException();
}
private string GetStringValue(JsonElement value)
{
var valueKind = value.ValueKind;
if (valueKind == JsonValueKind.Array)
{
return(string.Empty);
}
if (valueKind == JsonValueKind.False || valueKind == JsonValueKind.True)
{
return(value.GetBoolean().ToString());
}
if (valueKind == JsonValueKind.Number)
{
return(value.GetDecimal().ToString());
}
if (valueKind == JsonValueKind.String)
{
return(value.GetString());
}
return(default);
/// <summary>
/// Get value of JsonElement
/// </summary>
/// <param name="property"></param>
/// <returns></returns>
public static object GetValue(this JsonElement property)
{
switch (property.ValueKind)
{
case JsonValueKind.Array:
throw new NotSupportedException("Array is not supported, use [FromBody] and Model instead");
case JsonValueKind.False:
return(false);
case JsonValueKind.Null:
return(null);
case JsonValueKind.Number:
return(property.GetDecimal());
case JsonValueKind.Object:
throw new NotSupportedException("Object is not supported, use [FromBody] and Model instead");
case JsonValueKind.String:
return(property.GetString());
case JsonValueKind.True:
return(true);
case JsonValueKind.Undefined:
return(null);
default:
throw new ArgumentException("Unkown property.ValueKind");
}
}
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;
}
}
private object ReadValue(JsonElement element)
{
switch (element.ValueKind)
{
case JsonValueKind.Array:
return(ReadArray(element));
case JsonValueKind.False:
return(false);
case JsonValueKind.Null:
return(null);
case JsonValueKind.Number:
return(element.GetDecimal());
case JsonValueKind.Object:
return(ReadObject(element));
case JsonValueKind.String:
return(element.GetString());
case JsonValueKind.True:
return(true);
case JsonValueKind.Undefined:
return(null);
default:
throw new ArgumentOutOfRangeException(nameof(element));
}
}
/// <summary>
/// 对JsonElement对象的辅助扩展
/// </summary>
/// <param name="o">对象</param>
/// <returns>JSON字符串</returns>
public static T Value <T>(this JsonElement json, string key)
{
JsonElement j = json.GetProperty(key);
switch (j.ValueKind)
{
case JsonValueKind.Undefined:
return(default(T));
case JsonValueKind.Object:
return((T)(Object)j);
case JsonValueKind.Array:
return((T)(Object)j);
case JsonValueKind.String:
return((T)(Object)j.GetString());
case JsonValueKind.Number:
return((T)(Object)j.GetDecimal());
case JsonValueKind.True:
return((T)(Object)true);
case JsonValueKind.False:
return((T)(Object)false);
case JsonValueKind.Null:
return(default(T));
default:
return((T)(Object)j);
}
}
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));
}
protected override dynamic FromJsonElement(JsonElement graphson)
{
if (graphson.ValueKind == JsonValueKind.String)
{
return(decimal.Parse(graphson.GetString(), CultureInfo.InvariantCulture));
}
return(graphson.GetDecimal());
}
private static object?ConvertObject(JsonElement token, OperationSymbol operationSymbol)
{
switch (token.ValueKind)
{
case JsonValueKind.Undefined: return(null);
case JsonValueKind.String:
if (token.TryGetDateTime(out var dt))
{
return(dt);
}
if (token.TryGetDateTimeOffset(out var dto))
{
return(dto);
}
return(token.GetString());
case JsonValueKind.Number: return(token.GetDecimal());
case JsonValueKind.True: return(true);
case JsonValueKind.False: return(false);
case JsonValueKind.Null: return(null);
case JsonValueKind.Object:
{
if (token.TryGetProperty("EntityType", out var entityType))
{
return(token.ToObject <Lite <Entity> >(SignumServer.JsonSerializerOptions));
}
if (token.TryGetProperty("Type", out var type))
{
return(token.ToObject <ModifiableEntity>(SignumServer.JsonSerializerOptions));
}
var conv = CustomOperationArgsConverters.TryGetC(operationSymbol);
if (conv == null)
{
throw new InvalidOperationException("Impossible to deserialize request before executing {0}.\r\nConsider registering your own converter in 'CustomOperationArgsConverters'.\r\nReceived JSON:\r\n\r\n{1}".FormatWith(operationSymbol, token));
}
return(conv.GetInvocationListTyped().Select(f => conv(token)).NotNull().FirstOrDefault());
}
case JsonValueKind.Array:
var result = token.EnumerateArray().Select(t => ConvertObject(t, operationSymbol)).ToList();
return(result);
default:
throw new UnexpectedValueException(token.ValueKind);
}
}
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 SearchMetaData(JsonElement metaData)
{
CompletedIn = metaData.GetDecimal("completed_in");
NextResults = metaData.GetString("next_results");
Query = metaData.GetString("query");
RefreshUrl = metaData.GetString("refresh_url");
Count = metaData.GetInt("count");
MaxID = (metaData.GetString("max_id_str") ?? string.Empty).GetULong();
SinceID = (metaData.GetString("since_id_str") ?? string.Empty).GetULong();
}
private Expression ParseTree <T>(
JsonElement condition,
ParameterExpression parm)
{
Expression left = null;
var gate = condition.GetProperty(nameof(condition)).GetString();
JsonElement rules = condition.GetProperty(nameof(rules));
Binder binder = gate == And ? (Binder)Expression.And : Expression.Or;
Expression bind(Expression left, Expression right) =>
left == null ? right : binder(left, right);
foreach (var rule in rules.EnumerateArray())
{
if (rule.TryGetProperty(nameof(condition), out JsonElement check))
{
var right = ParseTree <T>(rule, parm);
left = bind(left, right);
continue;
}
string @operator = rule.GetProperty(nameof(@operator)).GetString();
string type = rule.GetProperty(nameof(type)).GetString();
string field = rule.GetProperty(nameof(field)).GetString();
JsonElement value = rule.GetProperty(nameof(value));
var property = Expression.Property(parm, field);
if (@operator == In)
{
var contains = MethodContains.MakeGenericMethod(typeof(string));
object val = value.EnumerateArray().Select(e => e.GetString())
.ToList();
var right = Expression.Call(
contains,
Expression.Constant(val),
property);
left = bind(left, right);
}
else
{
object val = (type == StringStr || type == BooleanStr) ?
(object)value.GetString() : value.GetDecimal();
var toCompare = Expression.Constant(val);
var right = Expression.Equal(property, toCompare);
left = bind(left, right);
}
}
return(left);
}
private static object GetGenericNumber(this JsonElement jsonElement)
{
// Attempt to parse the JSON Element as an Int32 first
if (jsonElement.TryGetInt32(out int int32))
{
return(int32);
}
// Failing that, parse it as a Decimal instead
return(jsonElement.GetDecimal());
}
public static bool IsTruthy(this JsonElement element)
{
return(element.ValueKind switch
{
JsonValueKind.Array => element.GetArrayLength() != 0,
JsonValueKind.String => element.GetString() != string.Empty,
JsonValueKind.Number => element.GetDecimal() != 0,
JsonValueKind.True => true,
JsonValueKind.False => false,
JsonValueKind.Null => false,
_ => throw new JsonLogicException($"Cannot determine truthiness of `{element.ValueKind}`.")
});
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 Document PrintImpl(JsonElement element, IndentationOptions indentation)
{
return(element.ValueKind switch
{
JsonValueKind.Array => PrintArray(element, indentation),
JsonValueKind.Object => PrintObject(element, indentation),
JsonValueKind.String => JsonEscape(element.GetString()),
JsonValueKind.Number => element.GetDecimal().ToString(),
JsonValueKind.True => "true",
JsonValueKind.False => "false",
JsonValueKind.Null => "null",
_ => throw new NotImplementedException()
});
public static decimal AsDecimal(JsonElement element)
{
switch (element.ValueKind)
{
case JsonValueKind.Number:
return(element.GetDecimal());
case JsonValueKind.String:
return(decimal.Parse(element.GetString(), CultureInfo.InvariantCulture));
default:
throw new NotSupportedException();
}
}
/// <summary>
/// Determines JSON-compatible equivalence.
/// </summary>
/// <param name="a">The first element.</param>
/// <param name="b">The second element.</param>
/// <returns><code>true</code> if the element are equivalent; <code>false</code> otherwise.</returns>
/// <exception cref="ArgumentOutOfRangeException">The <see cref="JsonElement.ValueKind"/> is not valid.</exception>
public static bool IsEquivalentTo(this JsonElement a, JsonElement b)
{
if (a.ValueKind != b.ValueKind)
{
return(false);
}
switch (a.ValueKind)
{
case JsonValueKind.Object:
var aProperties = a.EnumerateObject().ToList();
var bProperties = b.EnumerateObject().ToList();
if (aProperties.Count != bProperties.Count)
{
return(false);
}
var grouped = aProperties.Concat(bProperties)
.GroupBy(p => p.Name)
.Select(g => g.ToList())
.ToList();
return(grouped.All(g => g.Count == 2 && g[0].Value.IsEquivalentTo(g[1].Value)));
case JsonValueKind.Array:
var aElements = a.EnumerateArray().ToList();
var bElements = b.EnumerateArray().ToList();
if (aElements.Count != bElements.Count)
{
return(false);
}
var zipped = aElements.Zip(bElements, (ae, be) => (ae, be));
return(zipped.All(p => p.ae.IsEquivalentTo(p.be)));
case JsonValueKind.String:
return(a.GetString() == b.GetString());
case JsonValueKind.Number:
return(a.GetDecimal() == b.GetDecimal());
case JsonValueKind.Undefined:
return(false);
case JsonValueKind.True:
case JsonValueKind.False:
case JsonValueKind.Null:
return(true);
default:
throw new ArgumentOutOfRangeException();
}
}
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
});
public static decimal ToDecimal(this JsonElement element)
{
if (element.ValueKind == JsonValueKind.Number)
{
return(element.GetDecimal());
}
if (element.ValueKind == JsonValueKind.String)
{
var str = element.ToString();
if (decimal.TryParse(str, out var value))
{
return(value);
}
throw new Exception($"Failed to convert string to decimal: {str}");
}
throw new Exception("Invalid element type, number or string expected.");
}
private static IRenderable GetPropertyValue(JsonElement property)
{
var valueKind = property.ValueKind;
object?value = null;
switch (valueKind)
{
case JsonValueKind.String:
value = property.GetString();
break;
case JsonValueKind.True:
case JsonValueKind.False:
value = property.GetBoolean();
break;
case JsonValueKind.Number:
value = property.GetDecimal();
break;
}
return(new Markup(value?.ToString() ?? "-"));
}
private static object GetValue(JsonElement value)
{
switch (value.ValueKind)
{
case JsonValueKind.Object:
{
var output = new Dictionary <string, object>();
foreach (var kvp in value.EnumerateObject())
{
output.Add(kvp.Name, GetValue(kvp.Value));
}
return(output);
}
case JsonValueKind.Array:
return(value.EnumerateArray().Select(GetValue).ToArray());
case JsonValueKind.Null:
case JsonValueKind.Undefined:
return(null);
case JsonValueKind.String:
return(value.GetString());
case JsonValueKind.Number:
return(value.GetDecimal());
case JsonValueKind.True:
return(true);
case JsonValueKind.False:
return(false);
default:
return(value.GetRawText());
}
}
private static object PrepareJsonElement(this JsonElement obj)
{
switch (obj.ValueKind)
{
case JsonValueKind.Object:
IDictionary <string, object> expando = new ExpandoObject();
foreach (var property in obj.EnumerateObject())
{
expando.Add(property.Name, property.Value.PrepareJsonElement());
}
return(expando);
case JsonValueKind.Array:
return(obj.EnumerateArray().Select(jsonElement => jsonElement.PrepareJsonElement()));
case JsonValueKind.String:
return(obj.GetString());
case JsonValueKind.Number:
return(obj.GetDecimal());
case JsonValueKind.True:
return(true);
case JsonValueKind.False:
return(false);
case JsonValueKind.Null:
return(null);
case JsonValueKind.Undefined:
return(null);
default:
throw new ArgumentException();
}
}
private bool valueEquals(JsonElement elem1, JsonElement elem2)
{
var valueKind = elem1.ValueKind;
if (valueKind == JsonValueKind.True || valueKind == JsonValueKind.False)
{
return(elem1.GetBoolean() == elem2.GetBoolean());
}
else if (valueKind == JsonValueKind.Number)
{
return(elem1.GetDecimal() == elem2.GetDecimal());
}
else if (valueKind == JsonValueKind.String)
{
return(elem1.GetString() == elem2.GetString());
}
else if (valueKind == JsonValueKind.Null)
{
return(true);
}
return(false);
}
/// <summary>
/// Writes a <see cref="JsonElement"/> to the stream.
/// </summary>
/// <param name="writer">The JSON stream writer.</param>
/// <param name="element">The element to write.</param>
/// <exception cref="ArgumentOutOfRangeException">The <see cref="JsonElement.ValueKind"/> is not valid.</exception>
public static void WriteValue(this Utf8JsonWriter writer, JsonElement element)
{
switch (element.ValueKind)
{
case JsonValueKind.Object:
WriteObject(writer, element);
break;
case JsonValueKind.Array:
WriteArray(writer, element);
break;
case JsonValueKind.String:
writer.WriteStringValue(element.GetString());
break;
case JsonValueKind.Number:
writer.WriteNumberValue(element.GetDecimal());
break;
case JsonValueKind.True:
writer.WriteBooleanValue(true);
break;
case JsonValueKind.False:
writer.WriteBooleanValue(false);
break;
case JsonValueKind.Null:
writer.WriteNullValue();
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public decimal?GetFloatValue() => _jsonNode.GetDecimal();
private static void InsertDataTableInternal(DataTable dt, DataRow dr, JsonElement elem, string prefix, string column)
{
if (elem.ValueKind == JsonValueKind.Array)
{
bool firstElem = true;
foreach (var item in elem.EnumerateArray())
{
if (column == null)
{
dr = dt.NewRow();
dt.Rows.Add(dr);
InsertDataTableInternal(dt, dr, item, prefix, column);
}
else
{
if (!firstElem)
{
dr = dt.NewRow();
dt.Rows.Add(dr);
}
firstElem = false;
string fullName = string.Concat(prefix, column, "[]");
InsertDataTableInternal(dt, dr, item, fullName, null);
}
}
}
else if (elem.ValueKind == JsonValueKind.Object)
{
if (dr == null)
{
dr = dt.NewRow();
dt.Rows.Add(dr);
}
foreach (var prop in elem.EnumerateObject())
{
InsertDataTableInternal(dt, dr, prop.Value, prefix, $"{column}.{prop.Name}");
}
}
else if (elem.ValueKind != JsonValueKind.Null && elem.ValueKind != JsonValueKind.Undefined)
{
string fullName = string.Concat(prefix, column);
DataColumn dc = null;
if (dt.Columns.Contains(fullName))
{
dc = dt.Columns[fullName];
}
if (elem.ValueKind == JsonValueKind.False || elem.ValueKind == JsonValueKind.True)
{
if (dc == null)
{
dc = dt.Columns.Add(fullName, typeof(bool));
}
dr[dc] = elem.GetBoolean();
}
if (elem.ValueKind == JsonValueKind.Number)
{
if (dc == null)
{
dc = dt.Columns.Add(fullName, typeof(decimal));
}
dr[dc] = elem.GetDecimal();
}
if (elem.ValueKind == JsonValueKind.String)
{
if (dc == null)
{
dc = dt.Columns.Add(fullName, typeof(string));
}
dr[dc] = elem.GetString();
}
}
}
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);
}
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));
}
}