C＃中json文件的嵌套值的连续名称，例如：`“ 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”

解决方法

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

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,"");
                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);
        }
    }

Dotnetfiddle