c# - 省略动态属性的类型而不修改类？

Question

我有一堆域对象，我将它们序列化，发送到其他应用程序，然后使用 Json.Net 反序列化。这些对象可能具有以下属性

• 定义为具有多个派生类的抽象基类
• 动态属性

我使用了 TypeNameHandling.Auto，它将 $type 属性添加到与声明类型不同的类型。但是，此设置对我的动态属性产生了不必要的副作用，即它们的类型也被声明。

在下面的示例中，model 是一个动态属性，定义为 public dynamic Model { get;放; } 在我的 C# 代码中。

"model":{"$type":"<>f__AnonymousType0`3[[System.String, mscorlib],[System.String, mscorlib],[System.String, mscorlib]], ExampleAssembly","link":"http://www.google.com","name":"John"}

当尝试在另一个程序集中反序列化此字符串时，Json.Net(当然)无法找到ExampleAssembly。使用 TypeNameHandling.None 属性可提供以下属性序列化

"model": {"link":"http://www.google.com","name":"John"}

可以成功反序列化为动态。但是，这会破坏派生类型的反序列化。

关于如何在不实现自定义 IContractResolver 和可能的其他自定义代码的情况下使其工作的任何想法？

我不拥有域对象，因此我无法用属性装饰它们或其属性或允许它们实现接口(interface)等。我正在寻找的是序列化器中省略类型的某种设置动态。

恕我直言，这应该可以通过设置进行配置，我只是还没有找到它。

Answer 1

Json.Net 不提供特定设置来仅关闭动态类型的类型名称处理。如果您不能(或不想)使用 [JsonProperty(TypeNameHandling = TypeNameHandling.None)] 标记相关动态属性，那么您唯一的其他选择(除了修改 Json.Net源代码本身)的目的是实现自定义契约(Contract)解析器以编程方式应用行为。但不用担心，如果您从 Json.Net 提供的解析器之一(例如 DefaultContractResolver 或 CamelCasePropertyNamesContractResolver)派生解析器，那么这并不难。

这是您需要的所有代码:

using System;
using System.Reflection;
using Newtonsoft.Json;
using Newtonsoft.Json.Serialization;

public class OmitTypeNamesOnDynamicsResolver : DefaultContractResolver
{
    public static readonly OmitTypeNamesOnDynamicsResolver Instance = new OmitTypeNamesOnDynamicsResolver();

    protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)
    {
        JsonProperty prop = base.CreateProperty(member, memberSerialization);
        if (member.GetCustomAttribute<System.Runtime.CompilerServices.DynamicAttribute>() != null)
        {
            prop.TypeNameHandling = TypeNameHandling.None;
        }
        return prop;
    }
}

然后，只需将解析器添加到 JsonSerializerSettings 中即可。

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

string json = JsonConvert.SerializeObject(foo, settings);

这是一个证明这个概念的往返演示:

public class Program
{
    public static void Main(string[] args)
    {
        Foo foo = new Foo
        {
            Model = new { link = "http://www.google.com", name = "John" },
            Widget1 = new Doodad { Name = "Sprocket", Size = 10 },
            Widget2 = new Thingy { Name = "Coil", Strength = 5 }
        };

        JsonSerializerSettings settings = new JsonSerializerSettings
        {
            TypeNameHandling = TypeNameHandling.Auto,
            ContractResolver = OmitTypeNamesOnDynamicsResolver.Instance,
            Formatting = Formatting.Indented
        };

        string json = JsonConvert.SerializeObject(foo, settings);
        Console.WriteLine(json);
        Console.WriteLine();

        Foo foo2 = JsonConvert.DeserializeObject<Foo>(json, settings);
        Console.WriteLine(foo2.Model.link);
        Console.WriteLine(foo2.Model.name);
        Console.WriteLine(foo2.Widget1.Name + " (" + foo2.Widget1.GetType().Name + ")");
        Console.WriteLine(foo2.Widget2.Name + " (" + foo2.Widget2.GetType().Name + ")");
    }
}

public class Foo
{
    public dynamic Model { get; set; }
    public AbstractWidget Widget1 { get; set; }
    public AbstractWidget Widget2 { get; set; }
}

public class AbstractWidget
{
    public string Name { get; set; }
}

public class Thingy : AbstractWidget
{
    public int Strength { get; set; }
}

public class Doodad : AbstractWidget
{
    public int Size { get; set; }
}

输出:

{
  "Model": {
    "link": "http://www.google.com",
    "name": "John"
  },
  "Widget1": {
    "$type": "Doodad, JsonTest",
    "Size": 10,
    "Name": "Sprocket"
  },
  "Widget2": {
    "$type": "Thingy, JsonTest",
    "Strength": 5,
    "Name": "Coil"
  }
}

http://www.google.com
John
Sprocket (Doodad)
Coil (Thingy)