时间戳

首页 > 解决方案 > c#中json文件的嵌套值的连接名称ex：`“obj_nested1_nested2”：“text”

c# - c#中json文件的嵌套值的连接名称ex：`“obj_nested1_nested2”：“text”

问题描述

我正在寻找一种方法来转换这个 c# 对象：

class BaseClass
{
    public string Value1 {get; set;}
    public NestedObject nestedObject {get;set;}
}

class NestedObject
{
    public string NestedValue1 {get; set;}
}

进入这个json：

{
    "Value1": "value1",
    "NestedObject_NestedValue1": "nestedValue1"
}

通过将嵌套参数的名称连接到它们的父级名称

使用正常的序列化，这段代码： var json= JsonConvert.SerializeObject(baseClass);

而是返回一个像这样的 json：

{
    "Value1": "value1",
    "NestedObject": {
        "NestedValue1": "nestedValue1"
    }
}

我怀疑是否有一种方法可以将这样的 json 反序列化回对象。

更新：

正如有人问我为什么要这样做：我问这个问题的原因是因为我序列化这个对象以作为 json 元数据发送到一个只允许以类似于这样的方式引用顶级属性的服务：

[Metadata_Value1]将返回“value1”

但是[Metadata_NestedObject_NestedValue1]不起作用，并且没有任何迹象表明存在引用嵌套属性的方法。

考虑到这一点，我希望有一些解决方案允许将嵌套对象保留在我的程序中，但在将它们发送到此服务时将它们全部转换为顶级属性。

在服务中，我可以做到：[NestedObject_NestedValue1]并获得值“nestedValue1”

标签： c#jsonjson-deserializationjson-serialization

解决方案

您可以使用如下所示的自定义转换器：

public class NestedJsonConverter : JsonConverter
    {
        private readonly Type[] _types;
        public NestedJsonConverter(params Type[] types)
        {
            _types = types;
        }

        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            JToken t = JToken.FromObject(value);
            if (t.Type != JTokenType.Object)
            {
                t.WriteTo(writer);
            }
            else
            {
                JObject o = (JObject)t;
                writer.WriteStartObject();
                void writeNested(JObject target, object source, string prefix)
                {
                    target.Properties().ToList().ForEach(p =>
                    {
                        var prop = source.GetType().GetProperty(p.Name);
                        var value = prop.GetValue(source);
                        var prefixed = string.IsNullOrEmpty(prefix) ? p.Name : $"{prefix}_{p.Name}";
                        if (p.Value.Type == JTokenType.Object)
                        {
                            writeNested((JObject)p.Value, value, prefixed);
                        }
                        else if (p.Value.Type == JTokenType.Array)
                        {
                            // you may need a more advanced handling in array scenarios
                            var arr = (JArray)p.Value;
                            writer.WritePropertyName(prefixed);
                            arr.WriteTo(writer);
                        }
                        else
                        {
                            writer.WritePropertyName(prefixed);
                            writer.WriteValue(value);
                        }
                    }

                    );
                }

                writeNested(o, value, "");
                writer.WriteEndObject();
            }
        }

        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            throw new NotImplementedException("Unnecessary because CanRead is false. The type will skip the converter.");
        }

        public override bool CanRead
        {
            get
            {
                return false;
            }
        }

        public override bool CanConvert(Type objectType)
        {
            return _types.Any(t => t == objectType);
        }
    }

点网小提琴

推荐阅读