public static void CombiningSingleResolverProducesSameAnswersAsInputResolver()
{
JsonSerializerOptions options = new();
JsonTypeInfo t1 = JsonTypeInfo.CreateJsonTypeInfo(typeof(int), options);
JsonTypeInfo t2 = JsonTypeInfo.CreateJsonTypeInfo(typeof(uint), options);
JsonTypeInfo t3 = JsonTypeInfo.CreateJsonTypeInfo(typeof(string), options);
// we return same instance for easier comparison
TestResolver resolver = new((t, o) =>
{
Assert.Same(o, options);
if (t == typeof(int))
{
return(t1);
}
if (t == typeof(uint))
{
return(t2);
}
if (t == typeof(string))
{
return(t3);
}
return(null);
});
IJsonTypeInfoResolver combined = JsonTypeInfoResolver.Combine(resolver);
Assert.Same(t1, combined.GetTypeInfo(typeof(int), options));
Assert.Same(t2, combined.GetTypeInfo(typeof(uint), options));
Assert.Same(t3, combined.GetTypeInfo(typeof(string), options));
Assert.Null(combined.GetTypeInfo(typeof(char), options));
Assert.Null(combined.GetTypeInfo(typeof(StringBuilder), options));
}
internal static JsonSerializerOptions CreateSerializerOptions(JsonContext context, bool isStreamingOptions = false)
{
// Streaming is line delimited between messages. That means JSON can't be indented as it adds new lines.
// For streaming to work, indenting must be disabled when streaming.
var writeIndented = !isStreamingOptions ? context.Settings.WriteIndented : false;
var typeInfoResolver = JsonTypeInfoResolver.Combine(
new MessageTypeInfoResolver(context),
new DefaultJsonTypeInfoResolver());
var options = new JsonSerializerOptions
{
WriteIndented = writeIndented,
NumberHandling = JsonNumberHandling.AllowNamedFloatingPointLiterals,
Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
TypeInfoResolver = typeInfoResolver
};
options.Converters.Add(new NullValueConverter());
options.Converters.Add(new ByteStringConverter());
options.Converters.Add(new Int64Converter(context));
options.Converters.Add(new UInt64Converter(context));
options.Converters.Add(new BoolConverter());
options.Converters.Add(new JsonConverterFactoryForEnum(context));
options.Converters.Add(new JsonConverterFactoryForWrappers(context));
options.Converters.Add(new JsonConverterFactoryForWellKnownTypes(context));
return(options);
}
public static void CombiningZeroResolversProducesValidResolver()
{
IJsonTypeInfoResolver resolver = JsonTypeInfoResolver.Combine();
Assert.NotNull(resolver);
// calling twice to make sure we get the same answer
Assert.Null(resolver.GetTypeInfo(null, null));
Assert.Null(resolver.GetTypeInfo(null, null));
}
public static void GetTypeInfoNullArguments()
{
IJsonTypeInfoResolver[] resolvers = null;
Assert.Throws <ArgumentNullException>(() => JsonTypeInfoResolver.Combine(resolvers));
DefaultJsonTypeInfoResolver nonNullResolver1 = new();
DefaultJsonTypeInfoResolver nonNullResolver2 = new();
Assert.Throws <ArgumentNullException>(() => JsonTypeInfoResolver.Combine(null));
Assert.Throws <ArgumentNullException>(() => JsonTypeInfoResolver.Combine(null, null));
Assert.Throws <ArgumentNullException>(() => JsonTypeInfoResolver.Combine(nonNullResolver1, null));
Assert.Throws <ArgumentNullException>(() => JsonTypeInfoResolver.Combine(nonNullResolver1, nonNullResolver2, null));
Assert.Throws <ArgumentNullException>(() => JsonTypeInfoResolver.Combine(nonNullResolver1, null, nonNullResolver2));
}
public static void CombiningUsesAndRespectsAllResolversInOrder()
{
JsonSerializerOptions options = new();
JsonTypeInfo t1 = JsonTypeInfo.CreateJsonTypeInfo(typeof(int), options);
JsonTypeInfo t2 = JsonTypeInfo.CreateJsonTypeInfo(typeof(uint), options);
JsonTypeInfo t3 = JsonTypeInfo.CreateJsonTypeInfo(typeof(string), options);
int resolverId = 1;
// we return same instance for easier comparison
TestResolver r1 = new((t, o) =>
{
Assert.Equal(1, resolverId);
Assert.Same(o, options);
if (t == typeof(int))
{
return(t1);
}
resolverId++;
return(null);
});
TestResolver r2 = new((t, o) =>
{
Assert.Equal(2, resolverId);
Assert.Same(o, options);
if (t == typeof(uint))
{
return(t2);
}
resolverId++;
return(null);
});
TestResolver r3 = new((t, o) =>
{
Assert.Equal(3, resolverId);
Assert.Same(o, options);
if (t == typeof(string))
{
return(t3);
}
resolverId++;
return(null);
});
IJsonTypeInfoResolver combined = JsonTypeInfoResolver.Combine(r1, r2, r3);
resolverId = 1;
Assert.Same(t1, combined.GetTypeInfo(typeof(int), options));
Assert.Equal(1, resolverId);
resolverId = 1;
Assert.Same(t2, combined.GetTypeInfo(typeof(uint), options));
Assert.Equal(2, resolverId);
resolverId = 1;
Assert.Same(t3, combined.GetTypeInfo(typeof(string), options));
Assert.Equal(3, resolverId);
resolverId = 1;
Assert.Null(combined.GetTypeInfo(typeof(char), options));
Assert.Equal(4, resolverId);
resolverId = 1;
Assert.Null(combined.GetTypeInfo(typeof(StringBuilder), options));
Assert.Equal(4, resolverId);
}
public static void CombineCustomResolverWithDefault()
{
TestResolver resolver = new TestResolver((Type type, JsonSerializerOptions options) =>
{
if (type != typeof(TestClass))
{
return(null);
}
JsonTypeInfo <TestClass> ti = JsonTypeInfo.CreateJsonTypeInfo <TestClass>(options);
ti.CreateObject = () => new TestClass()
{
TestField = string.Empty,
TestProperty = 42,
};
JsonPropertyInfo field = ti.CreateJsonPropertyInfo(typeof(string), "MyTestField");
field.Get = (o) =>
{
TestClass obj = (TestClass)o;
return(obj.TestField ?? string.Empty);
};
field.Set = (o, val) =>
{
TestClass obj = (TestClass)o;
string value = (string?)val ?? string.Empty;
obj.TestField = value;
};
field.ShouldSerialize = (o, val) => (string)val != string.Empty;
JsonPropertyInfo prop = ti.CreateJsonPropertyInfo(typeof(int), "MyTestProperty");
prop.Get = (o) =>
{
TestClass obj = (TestClass)o;
return(obj.TestProperty);
};
prop.Set = (o, val) =>
{
TestClass obj = (TestClass)o;
obj.TestProperty = (int)val;
};
prop.ShouldSerialize = (o, val) => (int)val != 42;
ti.Properties.Add(field);
ti.Properties.Add(prop);
return(ti);
});
JsonSerializerOptions options = new JsonSerializerOptions {
TypeInfoResolver = new DefaultJsonTypeInfoResolver()
};
options.IncludeFields = true;
options.TypeInfoResolver = JsonTypeInfoResolver.Combine(resolver, options.TypeInfoResolver);
TestClass originalObj = new TestClass()
{
TestField = "test value",
TestProperty = 45,
};
string json = JsonSerializer.Serialize(originalObj, options);
Assert.Equal(@"{""MyTestField"":""test value"",""MyTestProperty"":45}", json);
TestClass deserialized = JsonSerializer.Deserialize <TestClass>(json, options);
Assert.Equal(originalObj.TestField, deserialized.TestField);
Assert.Equal(originalObj.TestProperty, deserialized.TestProperty);
originalObj.TestField = null;
json = JsonSerializer.Serialize(originalObj, options);
Assert.Equal(@"{""MyTestProperty"":45}", json);
originalObj.TestField = string.Empty;
json = JsonSerializer.Serialize(originalObj, options);
Assert.Equal(@"{""MyTestProperty"":45}", json);
deserialized = JsonSerializer.Deserialize <TestClass>(json, options);
Assert.Equal(originalObj.TestField, deserialized.TestField);
Assert.Equal(originalObj.TestProperty, deserialized.TestProperty);
originalObj.TestField = "test value";
originalObj.TestProperty = 42;
json = JsonSerializer.Serialize(originalObj, options);
Assert.Equal(@"{""MyTestField"":""test value""}", json);
deserialized = JsonSerializer.Deserialize <TestClass>(json, options);
Assert.Equal(originalObj.TestField, deserialized.TestField);
Assert.Equal(originalObj.TestProperty, deserialized.TestProperty);
}
