如何将文件路径数组转换为分层 JSON 结构答案

【问题标题】：How to transform an array of file paths into a hierarchical JSON structure如何将文件路径数组转换为分层 JSON 结构
【发布时间】：2014-10-31 18:51:43
【问题描述】：

在给定所有文件和路径的数组的情况下，我正在尝试创建机器目录结构的 JSON。

数组看起来像这样：

string[] dirArray = {
"./proc/15/task/15/exe",
"./proc/15/task/15/mounts/mounts.xml",
"./proc/15/task/15/mountinfo/mountinfo.xml",
"./proc/15/task/15/clear_refs/clear_ref.xml",
"./proc/14/loginuid/loginuid.xml",
"./proc/14/sessionid/sessionid.xml",
"./proc/14/coredump_filter/coredump_filter.xml",
"./proc/14/io/io.xml"
}

我的目标 JSON 是这样的：

{
   ".":
   {
        "file":
        {
            "name":"fileInRoot.xml"
        },
        "proc":
        {
            "file":
            {
                "name":"fileInProc.xml"
            },
            "15":
            {
                "file":
                {
                    "name":"fileIn15.xml"
                },
                "task":
                {
                    "file":
                    {
                        "name":"fileInTask.xml"
                    },
                    "15":
                    {
                        "file":
                        {
                            "name":"fileInTask.xml"
                        },
                        "mounts":
                        {
                            "file":
                            {
                                "name":"fileInMounts.xml"
                            }
                        },
                        "mountsInfo":
                        {
                            "file":
                            {
                                "name":"fileInMountsInfo.xml"
                            }
                        },
                        "clear_refs":
                        {
                            "file":
                            {
                                "name":"fileInClear_Refs.xml"
                            }
                        }                   
                    }
                }
            },
            "14":
            {
                "file":
                {
                    "name":"fileIn14.xml"
                },
                "task":
                {
                    "file":
                    {
                        "name":"fileInTask.xml"
                    },
                    "loginUid":
                    {
                        "file":
                        {
                            "name":"fileInloginUid.xml"
                        }                   
                    },
                    "sessionid":
                    {
                        "file":
                        {
                            "name":"fileInsessionid.xml"
                        }                   
                    },
                    "coreDump_filter":
                    {
                        "file":
                        {
                            "name":"fileIncoreDump_filter.xml"
                        }                   
                    },
                    "io":
                    {
                        "file":
                        {
                            "name":"fileInIo.xml"
                        }                   
                    }
                }
            }
        }
    }
}

我想创建一个 JSON 文件，允许 JSON 的消费者组件在此目录结构中导航。我一直在尝试使用 Directory、File 和 Path 类，但也许最好的方法是使用 java.serializor(?) 类在我循环遍历数组、解析其目录和我去的文件？

【问题讨论】：

您能否编辑您的问题以显示您想要创建的 JSON 输出示例，给定上面显示的字符串数组？
当然，见上文，这将是一个很好的输出。
文件名从何而来？它们只是从目录名称（每个目录一个文件）中假设的吗？
它们是示例文件名。我把它们放进去，因为我注意到该示例没有提到任何文件。示例已更新
OK，所以文件名将成为dirArray 的一部分。我可以假设每个目录总是只有一个文件吗？如果没有，那么 JSON 将需要更改（您需要一个数组来存储每个目录级别的 JSON 中的文件）。另外，我可以假设没有名为“文件”的目录吗？如果任何目录都可以称为“文件”，那么您也需要更改 JSON 以解决此问题，因为 JSON 中的同一级别不能有两个具有相同名称的键。

标签： c# json directory

【解决方案1】：

我想我会通过把它分成两部分来解决这个问题。首先，我们需要一种方法来解析目录/文件路径数组并将其放入层次结构中。其次，我们需要采用该结构并将其转换为 JSON。（从你的问题中我不能完全确定你想使用哪个序列化程序，所以对于这个答案，我假设Json.Net 是可以的。）

对于第一部分，我将创建一个 Dir 类，它有一个名称、一个子目录字典（便于查找）和一组文件。我们可以在这个类中创建一个方法来解析路径并找到或添加适当的子对象。

class Dir
{
    public string Name { get; set; }
    public Dictionary<string, Dir> Dirs { get; set; }
    public HashSet<string> Files { get; set; }

    public Dir(string name)
    {
        Name = name;
        Dirs = new Dictionary<string, Dir>();
        Files = new HashSet<string>();
    }

    public Dir FindOrCreate(string path, bool mightBeFile = true)
    {
        int i = path.IndexOf('/');
        if (i > -1)
        {
            Dir dir = FindOrCreate(path.Substring(0, i), false);
            return dir.FindOrCreate(path.Substring(i + 1), true);
        }

        if (path == "") return this;

        // if the name is at the end of a path and contains a "." 
        // we assume it is a file (unless it is "." by itself)
        if (mightBeFile && path != "." && path.Contains("."))
        {
            Files.Add(path);
            return this;
        }

        Dir child;
        if (Dirs.ContainsKey(path))
        {
            child = Dirs[path];
        }
        else
        {
            child = new Dir(path);
            Dirs.Add(path, child);
        }
        return child;
    }
}

使用这个类，我们可以轻松地遍历您问题中给出的dirArray 并制作目录层次结构：

Dir root = new Dir("");
foreach (string dir in dirArray)
{
    root.FindOrCreate(dir);
}

所以此时，root 现在拥有整个目录层次结构。如果你愿意，你可以简单地用 Json.Net 直接序列化这个对象以获得一个合理的 JSON 结构。但是，它会比您在问题中描述的更冗长。这是将生成的 JSON：

{
  "Name": "",
  "Dirs": {
    ".": {
      "Name": ".",
      "Dirs": {
        "proc": {
          "Name": "proc",
          "Dirs": {
            "15": {
              "Name": "15",
              "Dirs": {
                "task": {
                  "Name": "task",
                  "Dirs": {
                    "15": {
                      "Name": "15",
                      "Dirs": {
                        "exe": {
                          "Name": "exe",
                          "Dirs": {},
                          "Files": []
                        },
                        "mounts": {
                          "Name": "mounts",
                          "Dirs": {},
                          "Files": [
                            "mounts.xml"
                          ]
                        },
                        "mountinfo": {
                          "Name": "mountinfo",
                          "Dirs": {},
                          "Files": [
                            "mountinfo.xml",
                            "moremountinfo.xml"
                          ]
                        },
                        "clear_refs": {
                          "Name": "clear_refs",
                          "Dirs": {},
                          "Files": [
                            "clear_ref.xml"
                          ]
                        }
                      },
                      "Files": []
                    }
                  },
                  "Files": []
                }
              },
              "Files": []
            },
            "14": {
              "Name": "14",
              "Dirs": {
                "loginuid": {
                  "Name": "loginuid",
                  "Dirs": {},
                  "Files": [
                    "loginuid.xml"
                  ]
                },
                "sessionid": {
                  "Name": "sessionid",
                  "Dirs": {},
                  "Files": [
                    "sessionid.xml"
                  ]
                },
                "coredump_filter": {
                  "Name": "coredump_filter",
                  "Dirs": {},
                  "Files": [
                    "coredump_filter.xml"
                  ]
                },
                "io": {
                  "Name": "io",
                  "Dirs": {},
                  "Files": [
                    "io.xml"
                  ]
                }
              },
              "Files": []
            }
          },
          "Files": []
        }
      },
      "Files": []
    }
  },
  "Files": []
}

要获得您想要的 JSON，我们需要一个 JsonConverter 类：

class DirConverter : JsonConverter
{
    public override bool CanConvert(Type objectType)
    {
        return (objectType == typeof(Dir));
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        Dir dir = (Dir)value;
        JObject obj = new JObject();
        if (dir.Files.Count > 0)
        {
            JArray files = new JArray();
            foreach (string name in dir.Files)
            {
                files.Add(new JValue(name));
            }
            obj.Add("list_of_files", files);
        }
        foreach (var kvp in dir.Dirs)
        {
            obj.Add(kvp.Key, JToken.FromObject(kvp.Value, serializer));
        }
        obj.WriteTo(writer);
    }

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

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        throw new NotImplementedException();
    }
}

我们可以像这样使用转换器序列化目录层次结构：

JsonSerializerSettings settings = new JsonSerializerSettings();
settings.Converters.Add(new DirConverter());
settings.Formatting = Formatting.Indented;

string json = JsonConvert.SerializeObject(root, settings);

这是输出。请注意，我将原始 JSON 中的“文件”属性更改为数组，并将其重命名为“list_of_files”，以适应每个目录、每个 cmets 多个文件的可能性。我还假设永远不会有一个名为“list_of_files”的实际目录。如果这是可能的，您需要将文件数组的名称更改为不会与您的任何目录名称冲突的其他名称。（如果您遇到“Can not add property list_of_files to Newtonsoft.Json.Linq.JObject. Property with the same name already exists on object”的错误，这意味着您的数据中有一个名为“list_of_files”的目录。）

{
  ".": {
    "proc": {
      "15": {
        "task": {
          "15": {
            "exe": {},
            "mounts": {
              "list_of_files": [
                "mounts.xml"
              ]
            },
            "mountinfo": {
              "list_of_files": [
                "mountinfo.xml"
              ]
            },
            "clear_refs": {
              "list_of_files": [
                "clear_ref.xml"
              ]
            }
          }
        }
      },
      "14": {
        "loginuid": {
          "list_of_files": [
            "loginuid.xml"
          ]
        },
        "sessionid": {
          "list_of_files": [
            "sessionid.xml"
          ]
        },
        "coredump_filter": {
          "list_of_files": [
            "coredump_filter.xml"
          ]
        },
        "io": {
          "list_of_files": [
            "io.xml"
          ]
        }
      }
    }
  }
}

小提琴：https://dotnetfiddle.net/ConJiu

【讨论】：

哇，这看起来很棒，我会花一些时间来查看它并整合它并进行测试。我完成后会回复你:)
嗨，Brian，我在 JSON.Convert.Serialize(root, settings - Can not add property files to Newtonsoft.Json.Linq.JObject. 对象上已存在同名的属性时收到以下错误.) 我猜它的 json 有 2 个同名对象？
事实上它必须是数组中的实际数据，因为您的示例工作......
我似乎找不到问题，如果有办法将我的数组列表发送给您，请告诉我。
从错误中，我猜你的数组中有一个名为“files”的目录。还记得当我问我是否可以假设没有这样的目录时，你说我可以做出这个假设吗？要解决此问题，请更改转换器中的代码，使其写入属性名称 _files（或您选择的其他名称）。我已经编辑了我的答案。