省略动态属性的类型而不修改类

Question

我有一堆域对象，我序列化，发送给其他应用程序，然后使用Json.Net反序列化。这些对象的属性可以是

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

我使用了TypeNameHandling.Auto，它将$type属性添加到不同于声明类型的类型中。然而，这个设置对我的动态属性有一个不想要的副作用，即它们的类型也被声明了。

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

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

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

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

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

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

我不拥有域对象，所以我不能用属性修饰它们或它们的属性，也不能允许它们实现接口等。我正在寻找的是在序列化器中省略dynamics类型的某种设置。

IMHO这应该是通过设置可配置的，我只是没有找到它。

Answer 1

Json。Net没有提供特定的设置来关闭仅针对动态类型的类型名称处理。如果您不能(或不想)用[JsonProperty(TypeNameHandling = TypeNameHandling.None)]标记相关的动态属性，那么您唯一的其他选择(除了修改Json)。Net源代码本身)是实现自定义契约解析器以编程方式应用该行为。但是不要担心，如果您从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)