Json.NET - 序列化没有属性名称的泛型类型包装器

Json.NET - Serialize generic type wrapper without property name(Json.NET - 序列化没有属性名称的泛型类型包装器)
本文介绍了Json.NET - 序列化没有属性名称的泛型类型包装器的处理方法,对大家解决问题具有一定的参考价值,需要的朋友们下面随着跟版网的小编来一起学习吧!

问题描述

我有一个泛型类型,它包装了一个原始类型以赋予它值相等语义

I have a generic type that wraps a single primitive type to give it value equality semantics

public class ValueObject<T>
{
    public T Value { get; }
    public ValueObject(T value) => Value = value;

    // various other equality members etc...
}

它的用法如下:

public class CustomerId : ValueObject<Guid>
{
    public CustomerId(Guid value) : base(value) { }
}

public class EmailAddress : ValueObject<string>
{
    public EmailAddress(string value) : base(value) { }
}

问题是在序列化如下类型时:

The issue is when serializing a type like:

public class Customer
{
    public CustomerId Id { get; }
    public EmailAddress Email { get; }

    public Customer(CustomerId id, EmailAddress email) 
    { 
        Id = id;
        Email = email;
    }
}

ValueObject<T> 继承的每个对象都包装在 Value 属性中(如预期的那样).例如

Each object the inherits from ValueObject<T> is wrapped in a Value property (as expected). For example

var customerId = new CustomerId(Guid.NewGuid());
var emailAddress = new EmailAddress("some@email.com");

var customer = new Customer(customerId, emailAddress);

var customerAsJson = JsonConvert.SerializeObject(customer, Formatting.Indented, new JsonSerializerSettings
{
    ContractResolver = new CamelCasePropertyNamesContractResolver() 
})

结果

{
  "id": {
    "value": "f5ce21a5-a0d1-4888-8d22-6f484794ac7c"
  },
  "email": {
    "value": "some@email.com"
  }
}

有没有办法编写自定义 JsonConverter 以便将 Value 属性排除在子类化 ValueObject 的类型中,以便上面的例子会输出

Is there a way to write a custom JsonConverter so the the Value property is excluded for types subclassing ValueObject<T> so that the above example would output

{
  "id": "f5ce21a5-a0d1-4888-8d22-6f484794ac7c",
  "email": "some@email.com"
}

我希望有一个可以处理所有 ValueObject 的单个 JsonConverter 而不必为每个单独的 JsonConverterValueObject 子类

I would prefer to have a single JsonConverter that can handle all ValueObject<T> rather than having to define a separate JsonConverter for each ValueObject<T> subclass

我的第一次尝试是

public class ValueObjectOfTConverter : JsonConverter
{
    private static readonly Type ValueObjectGenericType = typeof(ValueObject<>);
    private static readonly string ValuePropertyName = nameof(ValueObject<object>.Value);

    public override bool CanConvert(Type objectType) =>
        IsSubclassOfGenericType(objectType, ValueObjectGenericType);

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        // converts "f5ce21a5-a0d1-4888-8d22-6f484794ac7c" => "value": "f5ce21a5-a0d1-4888-8d22-6f484794ac7c"
        var existingJsonWrappedInValueProperty = new JObject(new JProperty(ValuePropertyName, JToken.Load(reader)));
        return existingJsonWrappedInValueProperty.ToObject(objectType, serializer);
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        // to implement
    }

    private static bool IsSubclassOfGenericType(Type typeToCheck, Type openGenericType)
    {
        while (typeToCheck != null && typeToCheck != typeof(object))
        {
            var cur = typeToCheck.IsGenericType ? typeToCheck.GetGenericTypeDefinition() : typeToCheck;
            if (openGenericType == cur) return true;

            typeToCheck = typeToCheck.BaseType;
        }

        return false;
    }
}

推荐答案

您可以使用 自定义 JsonConverter 类似于 Json.Net 中显示的:将属性序列化/反序列化为值,而不是对象.但是,由于 ValueObject<T> 没有非泛型方法来获取和设置 Value 为对象,因此您需要使用反射.

You can do this with a custom JsonConverter similar to the ones shown in Json.Net: Serialize/Deserialize property as a value, not as an object. However, since ValueObject<T> does not have a non-generic method to get and set the Value as an object, you will need to use reflection.

这是一种方法:

class ValueConverter : JsonConverter
{
    static Type GetValueType(Type objectType)
    {
        return objectType
            .BaseTypesAndSelf()
            .Where(t => t.IsGenericType && t.GetGenericTypeDefinition() == typeof(ValueObject<>))
            .Select(t => t.GetGenericArguments()[0])
            .FirstOrDefault();
    }

    public override bool CanConvert(Type objectType)
    {
        return GetValueType(objectType) != null;
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        // You need to decide whether a null JSON token results in a null ValueObject<T> or 
        // an allocated ValueObject<T> with a null Value.
        if (reader.SkipComments().TokenType == JsonToken.Null)
            return null;
        var valueType = GetValueType(objectType);
        var value = serializer.Deserialize(reader, valueType);

        // Here we assume that every subclass of ValueObject<T> has a constructor with a single argument, of type T.
        return Activator.CreateInstance(objectType, value);
    }

    const string ValuePropertyName = nameof(ValueObject<object>.Value);

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        var contract = (JsonObjectContract)serializer.ContractResolver.ResolveContract(value.GetType());
        var valueProperty = contract.Properties.Where(p => p.UnderlyingName == ValuePropertyName).Single();
        // You can simplify this to .Single() if ValueObject<T> has no other properties:
        // var valueProperty = contract.Properties.Single();
        serializer.Serialize(writer, valueProperty.ValueProvider.GetValue(value));
    }
}

public static partial class JsonExtensions
{
    public static JsonReader SkipComments(this JsonReader reader)
    {
        while (reader.TokenType == JsonToken.Comment && reader.Read())
            ;
        return reader;
    }
}

public static class TypeExtensions
{
    public static IEnumerable<Type> BaseTypesAndSelf(this Type type)
    {
        while (type != null)
        {
            yield return type;
            type = type.BaseType;
        }
    }
}

然后您可以将转换器直接应用于 ValueType<T>,如下所示:

You could then apply the converter directly to ValueType<T> like so:

[JsonConverter(typeof(ValueConverter))]
public class ValueObject<T>
{
    // Remainder unchanged
}

或者在设置中应用它:

var settings = new JsonSerializerSettings
{
    Converters = { new ValueConverter() },
    ContractResolver = new CamelCasePropertyNamesContractResolver() 
};
var customerAsJson = JsonConvert.SerializeObject(customer, Formatting.Indented, settings);

工作示例 .Net fiddle #1 这里.

Working sample .Net fiddle #1 here.

或者,您可以考虑添加一个非泛型方法以将值作为 object 访问,例如像这样:

Alternatively, you might consider adding a non-generic method to access the value as an object, e.g. like so:

public interface IHasValue
{
    object GetValue(); // A method rather than a property to ensure the non-generic value is never serialized directly.
}

public class ValueObject<T> : IHasValue
{
    public T Value { get; }
    public ValueObject(T value) => Value = value;

    // various other equality members etc...

    #region IHasValue Members

    object IHasValue.GetValue() => Value;

    #endregion
}

有了这个添加,WriteJson() 变得更加简单:

With this addition, WriteJson() becomes much simpler:

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        serializer.Serialize(writer, ((IHasValue)value).GetValue());
    }

工作示例 .Net fiddle #2 这里.

Working sample .Net fiddle #2 here.

注意事项:

  • ReadJson() 假定 Value<T> 的每个子类都有一个公共构造函数,该构造函数采用 T 类型的单个参数.

  • ReadJson() assumes that every subclass of Value<T> has a public constructor taking a single argument of type T.

使用 ValueType<T>"noreferrer">[JsonConverter(typeof(ValueConverter))] 的性能会稍好一些,因为 CanConvert 永远不需要被调用.请参阅性能提示:JsonConverters详情.

Applying the converter directly to ValueType<T> using [JsonConverter(typeof(ValueConverter))] will have slightly better performance, since CanConvert need never get called. See Performance Tips: JsonConverters for details.

您需要决定如何处理 null JSON 令牌.它应该导致一个空的 ValueType<T>,还是一个分配的 ValueType 和一个空的 Value?

You need to decide how to handle a null JSON token. Should it result in a null ValueType<T>, or an allocated ValueType<T> with a null Value?

ValueType<T> 的第二个版本中,我明确实现了 IHasValue.GetValue() 以阻止在 实例的情况下使用它ValueType<T> 用于静态类型代码.

In the second version of ValueType<T> I implemented IHasValue.GetValue() explicitly to discourage its use in cases where an instance of ValueType<T> is used in statically typed code.

如果您真的只想将转换器应用于 类型 子类化 ValueObject<T> 而不是 ValueObject<T> 本身,在 GetValueType(Type objectType) 添加对 .Skip(1) 的调用:

If you really only want to apply the converter to types subclassing ValueObject<T> and not ValueObject<T> itself, in GetValueType(Type objectType) add a call to .Skip(1):

static Type GetValueType(Type objectType)
{
    return objectType
        .BaseTypesAndSelf()
        .Skip(1) // Do not apply the converter to ValueObject<T> when not subclassed
        .Where(t => t.IsGenericType && t.GetGenericTypeDefinition() == typeof(ValueObject<>))
        .Select(t => t.GetGenericArguments()[0])
        .FirstOrDefault();
}

然后将转换器应用到 JsonSerializerSettings.Converters 而不是直接应用到 ValueObject<T>.

And then apply the converter in JsonSerializerSettings.Converters rather than directly to ValueObject<T>.

这篇关于Json.NET - 序列化没有属性名称的泛型类型包装器的文章就介绍到这了,希望我们推荐的答案对大家有所帮助,也希望大家多多支持跟版网!

本站部分内容来源互联网,如果有图片或者内容侵犯了您的权益,请联系我们,我们会在确认后第一时间进行删除!

相关文档推荐

Force JsonConvert.SerializeXmlNode to serialize node value as an Integer or a Boolean(强制 JsonConvert.SerializeXmlNode 将节点值序列化为整数或布尔值)
Using JSON to Serialize/Deserialize TimeSpan(使用 JSON 序列化/反序列化 TimeSpan)
Could not determine JSON object type for type quot;Classquot;(无法确定类型“Class的 JSON 对象类型.)
How to deserialize a JSONP response (preferably with JsonTextReader and not a string)?(如何反序列化 JSONP 响应(最好使用 JsonTextReader 而不是字符串)?)
how to de-serialize JSON data in which Timestamp it-self contains fields?(如何反序列化时间戳本身包含字段的JSON数据?)
JSON.Net custom contract serialization and Collections(JSON.Net 自定义合约序列化和集合)