JSON.net（解）序列化未类型化属性

Question

Suppose I have a class like this:

public class Example {
    public int TypedProperty { get; set; }
    public object UntypedProperty { get; set; }
}

假设有人过来写下以下内容：

var example = new Example
{
    TypedProperty = 5,
    UntypedProperty = Guid.NewGuid()
}

如果我使用 JsonConvert.SerializeObject(example) 进行序列化，得到的结果是：

{
  "TypedProperty": 5,
  "UntypedProperty": "24bd733f-2ade-4374-9db6-3c9f3d97b12c"
}

理想情况下，我希望得到类似于这样的东西：

{
  "TypedProperty": 5,
  "UntypedProperty":
    {
      "$type": "System.Guid,mscorlib",
      "$value": "24bd733f-2ade-4374-9db6-3c9f3d97b12c"
    }
 }

但是在这种情况下，TypeNameHandling 不起作用。我该如何对一个未知类型的属性进行序列化和反序列化？

- Alex Reinking

---

如果您知道要序列化它，为什么不将其保存为字符串呢？ - Jeroen van Langen

抱歉，这个类不是我可以更改的。 - Alex Reinking

我知道对象的实际类型将是Json.net可序列化的某些类型之一。它只会是其中的几种之一。 - Alex Reinking

也许这可以帮助你：http://blog.maskalik.com/asp-net/json-net-implement-custom-serialization/ - whymatter

也许可以使用来自C#中反序列化带有枚举值的Dictionary<string, object>的UntypedToTypedValueConverter。 - dbc

Answer 1

如果您使用 TypeNameHandling.All 或 TypeNameHandling.Auto对您的类进行序列化，那么当 UntypedProperty 属性被序列化为 JSON 容器（对象或数组）时，Json.NET 应该通过在 JSON 文件中存储类型信息到 "$type" 属性来正确序列化和反序列化它。然而，在 UntypedProperty 被序列化为 JSON 原始类型（字符串、数字或布尔值）的情况下，这种方法行不通，因为正如您所提到的，JSON 原始类型没有机会包含一个 "$type" 属性。

解决办法是，当序列化具有 object 类型属性的类型时，可以沿着此答案所示的方式，为可以封装类型信息的原始值创建包装类。以下是一个自定义 JSON 转换器，可以注入此类包装器：

public class UntypedToTypedValueConverter : JsonConverter
{
    public override bool CanConvert(Type objectType)
    {
        throw new NotImplementedException("This converter should only be applied directly via ItemConverterType, not added to JsonSerializer.Converters");
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        if (reader.TokenType == JsonToken.Null)
            return null;
        var value = serializer.Deserialize(reader, objectType);
        if (value is TypeWrapper)
        {
            return ((TypeWrapper)value).ObjectValue;
        }
        return value;
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        if (serializer.TypeNameHandling == TypeNameHandling.None)
        {
            Console.WriteLine("ObjectItemConverter used when serializer.TypeNameHandling == TypeNameHandling.None");
            serializer.Serialize(writer, value);
        }
        // Handle a couple of simple primitive cases where a type wrapper is not needed
        else if (value is string)
        {
            writer.WriteValue((string)value);
        }
        else if (value is bool)
        {
            writer.WriteValue((bool)value);
        }
        else
        {
            var contract = serializer.ContractResolver.ResolveContract(value.GetType());
            if (contract is JsonPrimitiveContract)
            {
                var wrapper = TypeWrapper.CreateWrapper(value);
                serializer.Serialize(writer, wrapper, typeof(object));
            }
            else
            {
                serializer.Serialize(writer, value);
            }
        }
    }
}

abstract class TypeWrapper
{
    protected TypeWrapper() { }

    [JsonIgnore]
    public abstract object ObjectValue { get; }

    public static TypeWrapper CreateWrapper<T>(T value)
    {
        if (value == null)
            return new TypeWrapper<T>();
        var type = value.GetType();
        if (type == typeof(T))
            return new TypeWrapper<T>(value);
        // Return actual type of subclass
        return (TypeWrapper)Activator.CreateInstance(typeof(TypeWrapper<>).MakeGenericType(type), value);
    }
}

sealed class TypeWrapper<T> : TypeWrapper
{
    public TypeWrapper() : base() { }

    public TypeWrapper(T value)
        : base()
    {
        this.Value = value;
    }

    public override object ObjectValue { get { return Value; } }

    public T Value { get; set; }
}

然后使用 [JsonConverter(typeof(UntypedToTypedValueConverter))] 将其应用于您的类型：

public class Example
{
    public int TypedProperty { get; set; }
    [JsonConverter(typeof(UntypedToTypedValueConverter))]
    public object UntypedProperty { get; set; }
}

如果您无法修改Example类以添加此属性（您的评论这个类不是我的，我不能修改它表明了这一点），则可以使用自定义合同解析器来注入转换器：

public class UntypedToTypedPropertyContractResolver : DefaultContractResolver
{
    readonly UntypedToTypedValueConverter converter = new UntypedToTypedValueConverter();

    // As of 7.0.1, Json.NET suggests using a static instance for "stateless" contract resolvers, for performance reasons.
    // http://www.newtonsoft.com/json/help/html/ContractResolver.htm
    // http://www.newtonsoft.com/json/help/html/M_Newtonsoft_Json_Serialization_DefaultContractResolver__ctor_1.htm
    // "Use the parameterless constructor and cache instances of the contract resolver within your application for optimal performance."
    // See also https://dev59.com/OVwX5IYBdhLWcg3wpw1h
    static UntypedToTypedPropertyContractResolver instance;

    // Explicit static constructor to tell C# compiler not to mark type as beforefieldinit
    static UntypedToTypedPropertyContractResolver() { instance = new UntypedToTypedPropertyContractResolver(); }

    public static UntypedToTypedPropertyContractResolver Instance { get { return instance; } }

    protected override JsonObjectContract CreateObjectContract(Type objectType)
    {
        var contract = base.CreateObjectContract(objectType);

        foreach (var property in contract.Properties.Concat(contract.CreatorParameters))
        {
            if (property.PropertyType == typeof(object)
                && property.Converter == null)
            {
                property.Converter = property.MemberConverter = converter;
            }
        }
        return contract;
    }
}

并按以下方式使用：

var settings = new JsonSerializerSettings 
{
    TypeNameHandling = TypeNameHandling.Auto,
    ContractResolver = UntypedToTypedPropertyContractResolver.Instance,
};

var json = JsonConvert.SerializeObject(example, Formatting.Indented, settings);

var example2 = JsonConvert.DeserializeObject<Example>(json, settings);

在两种情况下，创建的JSON格式如下：

{
  "TypedProperty": 5,
  "UntypedProperty": {
    "$type": "Question38777588.TypeWrapper`1[[System.Guid, mscorlib]], Tile",
    "Value": "e2983c59-5ec4-41cc-b3fe-34d9d0a97f22"
  }
}

- dbc

Answer 2

查找使用JsonConverters进行序列化.htm和读写JSON。 调用：JsonConvert.SerializeObject(example, new ObjectConverter());

class ObjectConverter : JsonConverter
{
public override bool CanConvert(Type objectType)
{
  return objectType == typeof(Example);
}

public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
  throw new NotImplementedException();
}

public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
  Example e = (Example)value;

  writer.WriteStartObject();

  writer.WritePropertyName("TypedProperty");
  writer.WriteValue(e.TypedProperty);

  writer.WritePropertyName("UntypedProperty");
  writer.WriteStartObject();

  writer.WritePropertyName("$type");
  writer.WriteValue(e.UntypedProperty.GetType().FullName);

  writer.WritePropertyName("$value");
  writer.WriteValue(e.UntypedProperty.ToString());

  writer.WriteEndObject();

  writer.WriteEndObject();
}
}

- andrei.ciprian

---

谢谢，但我已经看过这些文档了。这并没有解决反序列化的问题。 - Alex Reinking

显然，ReadJson没有被实现，尽管它非常简单。问题是关于序列化而不是反序列化的。 - andrei.ciprian

我问题的最后一句是：“如何对一个未定义类型的属性进行序列化和反序列化？” - Alex Reinking