带有 System.Text.Json 的可选属性的自定义 JSON 序列化程序

Question

带有 System.Text.Json 的可选属性的自定义 JSON 序列化程序

Max*_*ini 8 c# json .net-core system.text.json

我正在尝试实现一个 JSON 序列化机制，它处理nullJSON 值和丢失的 JSON 值，以便能够在需要时执行部分更新（这样当值丢失时它不会触及数据库中的字段，但它会在该值显式设置为null)。

我创建了一个从 RoslynOptional<T>类型复制的自定义结构：

public readonly struct Optional<T>
{
    public Optional(T value)
    {
        this.HasValue = true;
        this.Value = value;
    }

    public bool HasValue { get; }
    public T Value { get; }
    public static implicit operator Optional<T>(T value) => new Optional<T>(value);
    public override string ToString() => this.HasValue ? (this.Value?.ToString() ?? "null") : "unspecified";
}

Run Code Online (Sandbox Code Playgroud)

现在我希望能够对 JSON 进行序列化/反序列化，以便在通过Optional<T>对象往返时保留 JSON 中的任何缺失字段：

public class CustomType
{
    [JsonPropertyName("foo")]
    public Optional<int?> Foo { get; set; }

    [JsonPropertyName("bar")]
    public Optional<int?> Bar { get; set; }

    [JsonPropertyName("baz")]
    public Optional<int?> Baz { get; set; }
}

Run Code Online (Sandbox Code Playgroud)

然后：

var options = new JsonSerializerOptions();
options.Converters.Add(new OptionalConverter());

string json = @"{""foo"":0,""bar"":null}";
CustomType parsed = JsonSerializer.Deserialize<CustomType>(json, options);
string roundtrippedJson = JsonSerializer.Serialize(parsed, options);

// json and roundtrippedJson should be equivalent
Console.WriteLine("json:             " + json);
Console.WriteLine("roundtrippedJson: " + roundtrippedJson);

Run Code Online (Sandbox Code Playgroud)

我开始了一个基于的实现JsonConverterFactory，但如果可选的HasValue是false：

public class OptionalConverter : JsonConverterFactory
{
    public override bool CanConvert(Type typeToConvert)
    {
        if (!typeToConvert.IsGenericType) { return false; }
        if (typeToConvert.GetGenericTypeDefinition() != typeof(Optional<>)) { return false; }
        return true;
    }

    public override JsonConverter CreateConverter(Type typeToConvert, JsonSerializerOptions options)
    {
        Type valueType = typeToConvert.GetGenericArguments()[0];

        return (JsonConverter)Activator.CreateInstance(
            type: typeof(OptionalConverterInner<>).MakeGenericType(new Type[] { valueType }),
            bindingAttr: BindingFlags.Instance | BindingFlags.Public,
            binder: null,
            args: null,
            culture: null
        );
    }

    private class OptionalConverterInner<T> : JsonConverter<Optional<T>>
    {
        public override Optional<T> Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            T value = JsonSerializer.Deserialize<T>(ref reader, options);
            return new Optional<T>(value);
        }

        public override void Write(Utf8JsonWriter writer, Optional<T> value, JsonSerializerOptions options)
        {
            // Does not work (produces invalid JSON).
            // Problem: the object's key has already been written in the JSON writer at this point.
            if (value.HasValue)
            {
                JsonSerializer.Serialize(writer, value.Value, options);
            }
        }
    }
}

Run Code Online (Sandbox Code Playgroud)

问题：这会产生以下输出，这是无效的：

json:             {"foo":0,"bar":null}
roundtrippedJson: {"foo":0,"bar":null,"baz":}

Run Code Online (Sandbox Code Playgroud)

我该如何解决这个问题？

Answer 1

dbc*_*dbc 9

自定义JsonConverter<T>无法阻止转换器应用的值的序列化，请参阅[System.Text.Json] 转换器级条件序列化 #36275以进行确认。

在 .Net 5 中有一个选项可以忽略默认值，这应该可以满足您的需要，请参阅如何使用 System.Text.Json 忽略属性。此版本介绍JsonIgnoreCondition.WhenWritingDefault：

public enum JsonIgnoreCondition
{
    // Property is never ignored during serialization or deserialization.
    Never = 0,
    // Property is always ignored during serialization and deserialization.
    Always = 1,
    // If the value is the default, the property is ignored during serialization.
    // This is applied to both reference and value-type properties and fields.
    WhenWritingDefault = 2,
    // If the value is null, the property is ignored during serialization.
    // This is applied only to reference-type properties and fields.
    WhenWritingNull = 3,
}

Run Code Online (Sandbox Code Playgroud)

您将能够[JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingDefault)]通过设置或全局将条件应用于特定属性JsonSerializerOptions.DefaultIgnoreCondition。

因此，在 .Net 5 中，您的课程将如下所示：

public class CustomType
{
    [JsonPropertyName("foo")]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingDefault)]
    public Optional<int?> Foo { get; set; }

    [JsonPropertyName("bar")]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingDefault)]
    public Optional<int?> Bar { get; set; }

    [JsonPropertyName("baz")]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingDefault)]
    public Optional<int?> Baz { get; set; }
}

Run Code Online (Sandbox Code Playgroud)

并且HasValue应该从OptionalConverterInner<T>.Write()以下位置删除检查：

public override void Write(Utf8JsonWriter writer, Optional<T> value, JsonSerializerOptions options) =>
    JsonSerializer.Serialize(writer, value.Value, options);

Run Code Online (Sandbox Code Playgroud)

演示小提琴 #1在这里。

在 .Net 3 中，由于没有条件序列化机制System.Text.Json，因此有条件地省略没有值的可选属性的唯一选择是为包含可选属性的所有类编写自定义JsonConverter<T> 。由于不提供对其内部合约信息的任何访问，所以这并不容易，因此我们需要为每种类型手工制作一个转换器，或者通过反射编写我们自己的通用代码。JsonSerializer

这是创建此类通用代码的一种尝试：

public interface IHasValue { bool HasValue { get; } object GetValue(); } public readonly struct Optional<T> : IHasValue { public Optional(T value) { this.HasValue = true; this.Value = value; } public bool HasValue { get; } public T Value { get; } public object GetValue() => Value; public static implicit operator Optional<T>(T value) => new Optional<T>(value); public override string ToString() => this.HasValue ? (this.Value?.ToString() ?? "null") : "unspecified"; } public class TypeWithOptionalsConverter<T> : JsonConverter<T> where T : class, new() { class TypeWithOptionalsConverterContractFactory : JsonObjectContractFactory<T> { protected override Expression CreateSetterCastExpression(Expression e, Type t) { // (Optional<Nullable<T>>)(object)default(T) does not work, even though (Optional<Nullable<T>>)default(T) does work. // To avoid the problem we need to first cast to Nullable<T>, then to Optional<Nullable<T>> if (t.IsGenericType && t.GetGenericTypeDefinition() == typeof(Optional<>)) return Expression.Convert(Expression.Convert(e, t.GetGenericArguments()[0]), t); return base.CreateSetterCastExpression(e, t); } } static readonly TypeWithOptionalsConverterContractFactory contractFactory = new TypeWithOptionalsConverterContractFactory(); public override T Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) { var properties = contractFactory.GetProperties(typeToConvert); if (reader.TokenType == JsonTokenType.Null) return null; if (reader.TokenType != JsonTokenType.StartObject) throw new JsonException(); var value = new T(); while (reader.Read()) { if (reader.TokenType == JsonTokenType.EndObject) return value; if (reader.TokenType != JsonTokenType.PropertyName) throw new JsonException(); string propertyName = reader.GetString(); if (!properties.TryGetValue(propertyName, out var property) || property.SetValue == null) { reader.Skip(); } else { var type = property.PropertyType.IsGenericType && property.PropertyType.GetGenericTypeDefinition() == typeof(Optional<>) ? property.PropertyType.GetGenericArguments()[0] : property.PropertyType; var item = JsonSerializer.Deserialize(ref reader, type, options); property.SetValue(value, item); } } throw new JsonException(); } public override void Write(Utf8JsonWriter writer, T value, JsonSerializerOptions options) { writer.WriteStartObject(); foreach (var property in contractFactory.GetProperties(value.GetType())) { if (options.IgnoreReadOnlyProperties && property.Value.SetValue == null) continue; var item = property.Value.GetValue(value); if (item is IHasValue hasValue) { if (!hasValue.HasValue) continue; writer.WritePropertyName(property.Key); JsonSerializer.Serialize(writer, hasValue.GetValue(), options); } else { if (options.IgnoreNullValues && item == null) continue; writer.WritePropertyName(property.Key); JsonSerializer.Serialize(writer, item, property.Value.PropertyType, options); } } writer.WriteEndObject(); } } public class JsonPropertyContract<TBase> { internal JsonPropertyContract(PropertyInfo property, Func<Expression, Type, Expression> setterCastExpression) { this.GetValue = ExpressionExtensions.GetPropertyFunc<TBase>(property).Compile(); if (property.GetSetMethod() != null) this.SetValue = ExpressionExtensions.SetPropertyFunc<TBase>(property, setterCastExpression).Compile(); this.PropertyType = property.PropertyType; } public Func<TBase, object> GetValue { get; } public Action<TBase, object> SetValue { get; } public Type PropertyType { get; } } public class JsonObjectContractFactory<TBase> { protected virtual Expression CreateSetterCastExpression(Expression e, Type t) => Expression.Convert(e, t); ConcurrentDictionary<Type, ReadOnlyDictionary<string, JsonPropertyContract<TBase>>> Properties { get; } = new ConcurrentDictionary<Type, ReadOnlyDictionary<string, JsonPropertyContract<TBase>>>(); ReadOnlyDictionary<string, JsonPropertyContract<TBase>> CreateProperties(Type type) { if (!typeof(TBase).IsAssignableFrom(type)) throw new ArgumentException(); var dictionary = type .GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.FlattenHierarchy) .Where(p => p.GetIndexParameters().Length == 0 && p.GetGetMethod() != null && !Attribute.IsDefined(p, typeof(System.Text.Json.Serialization.JsonIgnoreAttribute))) .ToDictionary(p => p.GetCustomAttribute<System.Text.Json.Serialization.JsonPropertyNameAttribute>()?.Name ?? p.Name, p => new JsonPropertyContract<TBase>(p, (e, t) => CreateSetterCastExpression(e, t)), StringComparer.OrdinalIgnoreCase); return dictionary.ToReadOnly(); } public IReadOnlyDictionary<string, JsonPropertyContract<TBase>> GetProperties(Type type) => Properties.GetOrAdd(type, t => CreateProperties(t)); } public static class DictionaryExtensions { public static ReadOnlyDictionary<TKey, TValue> ToReadOnly<TKey, TValue>(this IDictionary<TKey, TValue> dictionary) => new ReadOnlyDictionary<TKey, TValue>(dictionary ?? throw new ArgumentNullException()); } public static class ExpressionExtensions { public static Expression<Func<T, object>> GetPropertyFunc<T>(PropertyInfo property) { // (x) => (object)x.Property; var arg = Expression.Parameter(typeof(T), "x"); var getter = Expression.Property(arg, property); var cast = Expression.Convert(getter, typeof(object)); return Expression.Lambda<Func<T, object>>(cast, arg); } public static Expression<Action<T, object>> SetPropertyFunc<T>(PropertyInfo property, Func<Expression, Type, Expression> setterCastExpression) { //(x, y) => x.Property = (TProperty)y var arg1 = Expression.Parameter(typeof(T), "x"); var arg2 = Expression.Parameter(typeof(object), "y"); var cast = setterCastExpression(arg2, property.PropertyType); var setter = Expression.Call(arg1, property.GetSetMethod(), cast); return Expression.Lambda<Action<T, object>>(setter, arg1, arg2); } }
Run Code Online (Sandbox Code Playgroud)
笔记：

CustomType 仍然如您的问题所示。

没有尝试处理JsonSerializerOptions.PropertyNamingPolicy. TypeWithOptionalsConverter<T>如有必要，您可以在其中实施。

我添加了一个非通用接口IHasValue，以便Optional<T>在序列化期间更轻松地访问盒装。

演示小提琴 #2在这里。

或者，您可以坚持使用在属性和联系人级别支持此功能的 Json.NET。看：

可选择根据其运行时值序列化属性（基本上是您问题的副本）。

如何根据用户授权动态jsonignore？

归档时间：	5 年前
查看次数：	5485 次
最近记录：	4 年，6 月前