public static object ReadValue(System.Text.Json.JsonElement elem)
{
if (elem.ValueKind == System.Text.Json.JsonValueKind.Object)
{
KeyValue[] vals = elem.EnumerateObject().ToList().SelectMany(v => DeSerializeOne(v)).ToArray();
KeyValues valv = new KeyValues(); valv.AddRange(vals);
return(valv);
}
else if (elem.ValueKind == System.Text.Json.JsonValueKind.Array)
{
// déja géré par DeSerializeOne
//KeyValue[] vals = elem.Value.EnumerateArray().ToList().Select(v => DeSerializeOne(v)).ToArray();
//KeyValues valv = new KeyValues(); valv.AddRange(vals);
//retour = new KeyValue(realname, valv);
return(null);
}
else if (elem.ValueKind == System.Text.Json.JsonValueKind.Null || elem.ValueKind == System.Text.Json.JsonValueKind.Undefined)
{
return(null);
}
else if (elem.ValueKind == System.Text.Json.JsonValueKind.False)
{
return(false);
}
else if (elem.ValueKind == System.Text.Json.JsonValueKind.True)
{
return(true);
}
else if (elem.ValueKind == System.Text.Json.JsonValueKind.Number)
{
int i = 0;
if (elem.TryGetInt32(out i))
{
return(i);
}
long li = 0;
if (elem.TryGetInt64(out li))
{
return(li);
}
double di = 0;
if (elem.TryGetDouble(out di))
{
return(di);
}
return(elem.GetRawText()); // !!!
}
else if (elem.ValueKind == System.Text.Json.JsonValueKind.String)
{
return(elem.GetString());
}
else
{
return(elem.GetRawText());
}
}
public static Object DeepClone(JSONELEMENT element)
{
if (element.ValueKind == JsonValueKind.Null)
{
return(null);
}
if (element.ValueKind == JsonValueKind.False)
{
return(false);
}
if (element.ValueKind == JsonValueKind.True)
{
return(true);
}
if (element.ValueKind == JsonValueKind.String)
{
return(element.GetString());
}
if (element.ValueKind == JsonValueKind.Number)
{
return(element.GetRawText()); // use IConvertible interface when needed.
}
if (element.ValueKind == JsonValueKind.Array)
{
return(new JsonList(element));
}
if (element.ValueKind == JsonValueKind.Object)
{
return(new JsonDictionary(element));
}
throw new NotImplementedException();
}
public static T ToObject <T>(this JsonElement element)
{
var json = element.GetRawText();
return(JsonSerializer.Deserialize <T>(json));
}
public static async Task <T> ToObjectAsync <T>(this JsonElement element, JsonSerializerOptions?options = null)
{
string json = element.GetRawText();
return(JsonSerializer.Deserialize <T>(json, options) !);
}
private static void AssertJsonEqualCore(JsonElement expected, JsonElement actual, Stack <object> path)
{
JsonValueKind valueKind = expected.ValueKind;
AssertTrue(passCondition: valueKind == actual.ValueKind);
switch (valueKind)
{
case JsonValueKind.Object:
var expectedProperties = new List <string>();
foreach (JsonProperty property in expected.EnumerateObject())
{
expectedProperties.Add(property.Name);
}
var actualProperties = new List <string>();
foreach (JsonProperty property in actual.EnumerateObject())
{
actualProperties.Add(property.Name);
}
foreach (var property in expectedProperties.Except(actualProperties))
{
AssertTrue(passCondition: false, $"Property \"{property}\" missing from actual object.");
}
foreach (var property in actualProperties.Except(expectedProperties))
{
AssertTrue(passCondition: false, $"Actual object defines additional property \"{property}\".");
}
foreach (string name in expectedProperties)
{
path.Push(name);
AssertJsonEqualCore(expected.GetProperty(name), actual.GetProperty(name), path);
path.Pop();
}
break;
case JsonValueKind.Array:
JsonElement.ArrayEnumerator expectedEnumerator = expected.EnumerateArray();
JsonElement.ArrayEnumerator actualEnumerator = actual.EnumerateArray();
int i = 0;
while (expectedEnumerator.MoveNext())
{
AssertTrue(passCondition: actualEnumerator.MoveNext(), "Actual array contains fewer elements.");
path.Push(i++);
AssertJsonEqualCore(expectedEnumerator.Current, actualEnumerator.Current, path);
path.Pop();
}
AssertTrue(passCondition: !actualEnumerator.MoveNext(), "Actual array contains additional elements.");
break;
case JsonValueKind.String:
AssertTrue(passCondition: expected.GetString() == actual.GetString());
break;
case JsonValueKind.Number:
case JsonValueKind.True:
case JsonValueKind.False:
case JsonValueKind.Null:
AssertTrue(passCondition: expected.GetRawText() == actual.GetRawText());
break;
default:
Debug.Fail($"Unexpected JsonValueKind: JsonValueKind.{valueKind}.");
break;
}
void AssertTrue(bool passCondition, string?message = null)
{
if (!passCondition)
{
message ??= "Expected JSON does not match actual value";
Assert.Fail($"{message}\nExpected JSON: {expected}\n Actual JSON: {actual}\n in JsonPath: {BuildJsonPath(path)}");
}
