我正在使用 JSON.NET 序列化我的一些对象，我想知道是否有一种简单的方法可以仅为特定对象覆盖默认的 json.net 转换器？

目前我有以下类(class):

public class ChannelContext : IDataContext
{
    public int Id { get; set; }
    public string Name { get; set; }
    public IEnumerable<INewsItem> Items { get; set; }
}

JSON.NET 目前将上述序列化为:

{
    "Id": 2,
    "Name": "name value",
    "Items": [ item_data_here ]
}

是否可以仅让特定类以这种方式对其进行格式化:

"Id_2":
{
    "Name": "name value",
    "Items": [ item data here ]
}

我对 JSON.NET 有点陌生。我想知道上面的内容是否与编写自定义转换器有关。我找不到任何关于如何编写的具体示例，如果有人能指出我的具体来源，我将不胜感激。

我需要找到一种解决方案，使特定类始终转换相同，因为上述上下文是 JSON.NET 默认转换器可以很好地转换的更大上下文的一部分。

希望我的问题足够清楚......

更新:

我找到了如何创建一个新的自定义转换器(通过创建一个继承自 JsonConverter 的新类并覆盖它的抽象方法)，我覆盖了 WriteJson 方法，如下所示:

public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        ChannelContext contextObj = value as ChannelContext;

        writer.WriteStartObject();
        writer.WritePropertyName("id_" + contextObj.Id);
        writer.WriteStartObject();
        writer.WritePropertyName("Name");
        serializer.Serialize(writer, contextObj.Name);

        writer.WritePropertyName("Items");
        serializer.Serialize(writer, contextObj.Items);
        writer.WriteEndObject();
        writer.WriteEndObject();
    }

这确实成功地完成了这项工作，但是...... 如果有一种方法可以通过重用默认的 JsonSerializer(或就此而言的转换器)而不是使用 jsonwriter 方法手动“写入”对象来序列化其余对象属性，我很感兴趣。

更新 2: 我正在尝试获得更通用的解决方案并提出以下建议:

public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        writer.WriteStartObject();

        // Write associative array field name
        writer.WritePropertyName(m_FieldNameResolver.ResolveFieldName(value));

        // Remove this converter from serializer converters collection
        serializer.Converters.Remove(this);

        // Serialize the object data using the rest of the converters
        serializer.Serialize(writer, value);

        writer.WriteEndObject();
    }

当手动将转换器添加到序列化器时，这可以正常工作，如下所示:

jsonSerializer.Converters.Add(new AssociativeArraysConverter<DefaultFieldNameResolver>());
jsonSerializer.Serialize(writer, channelContextObj);

但是在 ChannelContext 类上方使用设置为我的自定义转换器的 [JsonConverter()] 属性时不起作用，因为执行时会发生自引用循环:

serializer.Serialize(writer, value)

这显然是因为我的自定义转换器现在被认为是该类的默认转换器，一旦它设置了 JsonConverterAttribute，所以我得到了一个无限循环。 为了解决这个问题，我唯一能想到的就是从一个基本的 jsonconverter 类继承，然后调用 base.serialize() 方法...... 但是这样的 JsonConverter 类真的存在吗？

非常感谢!

米奇

最佳答案

如果有人对我的解决方案感兴趣:

在序列化某些集合时，我想创建一个关联 json 数组而不是标准 json 数组，因此我的同事客户端开发人员可以使用它们的名称(或相关的键)有效地访问这些字段，而不是遍历它们.

考虑以下几点:

public class ResponseContext
{
    private List<ChannelContext> m_Channels;

    public ResponseContext()
    {
        m_Channels = new List<ChannelContext>();
    }

    public HeaderContext Header { get; set; }

    [JsonConverter(
        typeof(AssociativeArraysConverter<ChannelContextFieldNameResolver>))]
    public List<ChannelContext> Channels
    {
        get { return m_Channels; }
    }

}

[JsonObject(MemberSerialization = MemberSerialization.OptOut)]
public class ChannelContext : IDataContext
{
    [JsonIgnore]
    public int Id { get; set; }

    [JsonIgnore]
    public string NominalId { get; set; }

    public string Name { get; set; }

    public IEnumerable<Item> Items { get; set; }
}

响应上下文包含写回客户端的整个响应，如您所见，它包括一个名为“ channel ”的部分，而不是在普通数组中输出 channel 上下文，我希望能够输出方式如下:

"Channels"
{
"channelNominalId1":
{
  "Name": "name value1"
  "Items": [ item data here ]
},
"channelNominalId2":
{
  "Name": "name value2"
  "Items": [ item data here ]
}
}

由于我也想将上述内容用于其他上下文，因此我可能决定使用不同的属性作为它们的“键”，或者甚至可能选择创建我自己的唯一名称，这与任何属性，我都需要某种通用解决方案，因此我编写了一个名为 AssociativeArraysConverter 的通用类，它以以下方式从 JsonConverter 继承:

public class AssociativeArraysConverter<T> : JsonConverter
    where T : IAssociateFieldNameResolver, new()
{
    private T m_FieldNameResolver;

    public AssociativeArraysConverter()
    {
        m_FieldNameResolver = new T();
    }

    public override bool CanConvert(Type objectType)
    {
        return typeof(IEnumerable).IsAssignableFrom(objectType) &&
                !typeof(string).IsAssignableFrom(objectType);
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        IEnumerable collectionObj = value as IEnumerable;

        writer.WriteStartObject();

        foreach (object currObj in collectionObj)
        {
            writer.WritePropertyName(m_FieldNameResolver.ResolveFieldName(currObj));
            serializer.Serialize(writer, currObj);
        }

        writer.WriteEndObject();
    }
}

并声明如下接口(interface):

public interface IAssociateFieldNameResolver
{
    string ResolveFieldName(object i_Object);
}

现在剩下要做的就是创建一个实现 IAssociateFieldNameResolver 的单个函数的类，该函数接受集合中的每个项目，并基于该对象返回一个字符串，该字符串将充当该项目的关联对象的键。

此类的示例是:

public class ChannelContextFieldNameResolver : IAssociateFieldNameResolver
{
    public string ResolveFieldName(object i_Object)
    {
        return (i_Object as ChannelContext).NominalId;
    }
}

关于c# - JSON.NET 中特定对象的自定义转换，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/6404881/