首先,我想提一下,Json.Net 有一个内置PreserveReferencesHandling
设置,可以自动为您处理这类事情,而不需要特殊的转换器。PreserveReferencesHandling
设置为 时, Json.NetAll
为每个对象分配内部引用 ID,并将特殊$id
和$ref
属性写入 JSON 以跟踪引用。对于您的示例,JSON 输出如下所示:
{"$id":"1","Id":1,"Field":"Value","NestedObject":{"$ref":"1"}}
您会注意到这与您的问题所需的输出非常相似。这也有一个优点,即它可以很容易地反序列化回原始对象图,并保留所有引用,而无需实现任何特殊的东西。
但是让我们暂时假设您有自己的原因想要实现自定义引用循环处理,并看看为什么您的代码不起作用。
当 Json.Net 遇到JsonConverter
对象的 a 时,它假定转换器将处理写入该对象所需的任何 JSON。所以,如果你想包含某些属性,你必须自己写出来。您可以使用序列化程序来帮助编写对象的一部分,但您不能只是将整个对象交给序列化程序并说“序列化这个”,因为它最终会回调到您的转换器中。
在大多数情况下,这样做会导致无限循环。在您的情况下,它没有,因为您在第一次调用 HashSet 时将表单添加到WriteJson
. 当序列化程序第二次回调时,将采用另一个分支,因为表单已经在集合中。因此,对象的整个 JSON 最终{Id:1}
不是您真正想要的。
防止序列化程序回调到您的转换器的一种方法是在JsonSerializer
转换器内部创建一个新实例,并使用该实例而不是传递给该WriteJson
方法的实例。新实例不会引用您的转换器,因此您Form
将正常序列化。
不幸的是,这个想法也行不通:如果您没有对内部序列化器上的转换器的引用,那么 Json.Net 就无法知道如何对NestedObject
! 相反,它只会被省略,因为我们将被迫设置ReferenceLoopHandling
为Ignore
以避免错误。所以你看,你有一个catch-22。
那么我们怎样才能让它发挥作用呢?好吧,让我们退后一步,重新定义你真正想要在输出方面发生的事情:
- 如果我们遇到我们已经看到的表单,我们只想输出
Id
.
- 否则,将表单添加到我们看到的表单列表中,然后输出
Id
,Field
和NestedObject
。
请注意,在这两种情况下,我们都希望输出Id
,因此我们可以将逻辑简化为:
- 始终输出 Id
- 如果我们遇到一个我们还没有见过的表单,将表单添加到我们见过的表单列表中,然后输出
Field
and NestedObject
。
为方便起见,我们可以使用 aJObject
来收集我们想要输出的属性,然后简单地把它写到writer
最后。
这是修改后的代码:
public class SerializationConverter : JsonConverter
{
public override bool CanRead { get { return false; } }
public override bool CanWrite { get { return true; } }
public override bool CanConvert(Type objectType)
{
return objectType == typeof(Form) || typeof(Form).IsAssignableFrom(objectType);
}
private HashSet<Form> serializedForms = new HashSet<Form>();
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
Form f = (Form)value;
JObject jo = new JObject();
jo.Add("Id", f.Id);
if (serializedForms.Add(f))
{
jo.Add("Field", f.Field);
if (f.NestedObject != null)
{
jo.Add("NestedObject", JToken.FromObject(f.NestedObject, serializer));
}
}
jo.WriteTo(writer);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
throw new NotImplementedException();
}
}
现在让我们测试一下:
class Program
{
static void Main(string[] args)
{
Form form = new Form
{
Id = 1,
Field = "Value",
};
form.NestedObject = form;
JsonSerializerSettings settings = new JsonSerializerSettings
{
Converters = new List<JsonConverter> { new SerializationConverter() },
ReferenceLoopHandling = ReferenceLoopHandling.Serialize,
};
string json = JsonConvert.SerializeObject(form, settings);
Console.WriteLine(json);
}
}
class Form
{
public int Id { get; set; }
public string Field { get; set; }
public Form NestedObject { get; set; }
}
这是输出:
{"Id":1,"Field":"Value","NestedObject":{"Id":1}}
到目前为止看起来不错。更严格的东西怎么样:
class Program
{
static void Main(string[] args)
{
List<Form> forms = new List<Form>
{
new Form
{
Id = 1,
Field = "One",
NestedObject = new Form
{
Id = 2,
Field = "Two"
}
},
new Form
{
Id = 3,
Field = "Three"
},
new Form
{
Id = 4,
Field = "Four"
},
new Form
{
Id = 5,
Field = "Five"
}
};
forms[0].NestedObject.NestedObject = forms[3];
forms[1].NestedObject = forms[0].NestedObject;
forms[2].NestedObject = forms[1];
JsonSerializerSettings settings = new JsonSerializerSettings
{
Converters = new List<JsonConverter> { new SerializationConverter() },
ReferenceLoopHandling = ReferenceLoopHandling.Serialize,
Formatting = Formatting.Indented
};
string json = JsonConvert.SerializeObject(forms, settings);
Console.WriteLine(json);
}
}
输出:
[
{
"Id": 1,
"Field": "One",
"NestedObject": {
"Id": 2,
"Field": "Two",
"NestedObject": {
"Id": 5,
"Field": "Five"
}
}
},
{
"Id": 3,
"Field": "Three",
"NestedObject": {
"Id": 2
}
},
{
"Id": 4,
"Field": "Four",
"NestedObject": {
"Id": 3
}
},
{
"Id": 5
}
]
编辑
如果您的Form
类有大量字段,您可能希望使用反射而不是在转换器中单独列出属性。以下是WriteJson
使用反射的方法:
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
Form f = (Form)value;
JObject jo = new JObject();
if (serializedForms.Add(f))
{
foreach (PropertyInfo prop in value.GetType().GetProperties())
{
if (prop.CanRead)
{
object propVal = prop.GetValue(value);
if (propVal != null)
{
jo.Add(prop.Name, JToken.FromObject(propVal, serializer));
}
}
}
}
else
{
jo.Add("Id", f.Id);
}
jo.WriteTo(writer);
}