Как я могу преобразовать список имен файлов в древовидную структуру?

Question

У меня есть строковый массив с некоторыми путями к файлам:

path/to/folder/file.xxx
path/to/other/
path/to/file/file.xx
path/file.x
path/

Как я могу преобразовать этот список в древовидную структуру? Пока у меня есть следующее:

/// <summary>
/// Enumerates types of filesystem nodes.
/// </summary>
public enum FilesystemNodeType
{
    /// <summary>
    /// Indicates that the node is a file.
    /// </summary>
    File,

    /// <summary>
    /// Indicates that the node is a folder.
    /// </summary>
    Folder
}

/// <summary>
/// Represents a file or folder node.
/// </summary>
public class FilesystemNode
{
    private readonly ICollection<FilesystemNode> _children; 

    /// <summary>
    /// Initializes a new instance of the <see cref="FilesystemNode"/> class.
    /// </summary>
    public FilesystemNode()
    {
        _children = new LinkedList<FilesystemNode>();
    }

    /// <summary>
    /// Gets or sets the name of the file or folder.
    /// </summary>
    public string Name { get; set; }

    /// <summary>
    /// Gets or sets the full path to the file or folder from the root.
    /// </summary>
    public string Path { get; set; }

    /// <summary>
    /// Gets or sets a value indicating whether the node is a file or folder.
    /// </summary>
    public FilesystemNodeType Type { get; set; }

    /// <summary>
    /// Gets a list of child nodes of this node. The node type must be a folder to have children.
    /// </summary>
    public ICollection<FilesystemNode> Children
    {
        get
        {
            if (Type == FilesystemNodeType.Folder)
                return _children;

            throw new InvalidOperationException("File nodes cannot have children");
        }
    }
}

Я просто в недоумении от того, как на самом деле разделить пути и все такое. Любой путь, который заканчивается на /, является каталогом, любой, который не имеет, не является.

Кроме того, хотя мой ввод всегда будет содержать путь к папке, как бы я учел эту ситуацию, если бы ее не было?

Например, если бы у меня был ввод:

path/to/file.c
path/file.c
path/

Как бы я учел тот факт, что path/to/ отсутствует на входе?

Answer 1

Вот решение, которое генерирует вложенный словарь элементов NodeEntry (при необходимости вы можете заменить класс информации о файле):

public class NodeEntry
{
    public NodeEntry()
    {
        this.Children = new NodeEntryCollection();
    }

    public string Key { get; set; }
    public NodeEntryCollection Children { get; set; }

}

public class NodeEntryCollection : Dictionary<string, NodeEntry>
{
    public void AddEntry(string sEntry, int wBegIndex)
    {
        if (wBegIndex < sEntry.Length)
        {
            string sKey;
            int wEndIndex;

            wEndIndex = sEntry.IndexOf("/", wBegIndex);
            if (wEndIndex == -1)
            {
                wEndIndex = sEntry.Length;
            }
            sKey = sEntry.Substring(wBegIndex, wEndIndex - wBegIndex);
            if (!string.IsNullOrEmpty(sKey)) {
                NodeEntry oItem;

                if (this.ContainsKey(sKey)) {
                    oItem = this[sKey];
                } else {
                    oItem = new NodeEntry();
                    oItem.Key = sKey;
                    this.Add(sKey, oItem);
                }
                // Now add the rest to the new item's children
                oItem.Children.AddEntry(sEntry, wEndIndex + 1);
            }
        }
    }
}

Чтобы использовать вышеизложенное, создайте новую коллекцию:

        NodeEntryCollection cItems = new NodeEntryCollection();

затем для каждой строки в вашем списке:

        cItems.AddEntry(sLine, 0);

Answer 2

Я был вдохновлен ответом компетентного_техника и заменил Dictionary<string, NodeEntry> на "простой" ObservableCollection<NodeEntry>, так как информация "Ключ" будет храниться дважды в этом словаре: один раз как ключ словаря и один раз как публичное свойство в NodeEntry класс.

Таким образом, мой пример, основанный на коде "компетентный_технологии", выглядит следующим образом:

public class NodeEntryObservableCollection : ObservableCollection<NodeEntry>
{
    public const string DefaultSeparator = "/";

    public NodeEntryObservableCollection(string separator = DefaultSeparator)
    {
        Separator = separator; // default separator
    }

    /// <summary>
    /// Gets or sets the separator used to split the hierarchy.
    /// </summary>
    /// <value>
    /// The separator.
    /// </value>
    public string Separator { get; set; }

    public void AddEntry(string entry)
    {
        AddEntry(entry, 0);
    }

    /// <summary>
    /// Parses and adds the entry to the hierarchy, creating any parent entries as required.
    /// </summary>
    /// <param name="entry">The entry.</param>
    /// <param name="startIndex">The start index.</param>
    public void AddEntry(string entry, int startIndex)
    {
        if (startIndex >= entry.Length)
        {
            return;
        }

        var endIndex = entry.IndexOf(Separator, startIndex);
        if (endIndex == -1)
        {
            endIndex = entry.Length;
        }
        var key = entry.Substring(startIndex, endIndex - startIndex);
        if (string.IsNullOrEmpty(key))
        {
            return;
        }

        NodeEntry item;
        item = this.FirstOrDefault(n => n.Key == key);
        if (item == null)
        {
            item = new NodeEntry(Separator) { Key = key };
            Add(item);
        }
        // Now add the rest to the new item's children
        item.Children.AddEntry(entry, endIndex + 1);
    }
}

public class NodeEntry
{
    public string Key { get; set; }

    public NodeEntryObservableCollection Children { get; set; }

    public NodeEntry(string separator = NodeEntryObservableCollection.DefaultSeparator)
    {
        Children = new NodeEntryObservableCollection(separator);
    }
}

Это помогает мне связывать данные в TreeView следующим образом:

<TreeView Name="trvMyTreeView">
    <TreeView.ItemTemplate>
        <HierarchicalDataTemplate DataType="{x:Type local:NodeEntry}" ItemsSource="{Binding Children}">
            <TextBlock Text="{Binding Key}"/>
        </HierarchicalDataTemplate>
    </TreeView.ItemTemplate>
</TreeView>

Пример кода:

IList<string> pathes = new List<string>
{
    "localhost",
    "remotehost.levelD.levelDB",
    "localhost.level1.level11",
    "localhost.level1",
    "remotehost.levelD.levelDA",
    "localhost.level2.level22",
    "remotehost.levelA",
    "remotehost",
    "remotehost.levelB",
    "remotehost.levelD",
    "localhost.level2",
    "remotehost.levelC"
};
SortedSet<string> sortedPathes = new SortedSet<string>(pathes);

var obsCollection = new NodeEntryObservableCollection(".");
foreach (var p in sortedPathes) { obsCollection.AddEntry(p); }

trvMyTreeView.ItemsSource = obsCollection;

Answer 3

Разделить каждую строку на символ '/'. Если строковый массив имеет длину 5, то первые четыре элемента должны быть каталогами, и вы должны проверить последний для расширения:

string.IsNullOrEmpty(new FileInfo("test").Extension)

Если, как и в вашем случае, всегда есть '/' даже для последнего каталога, то последний элемент массива разделенной строки будет пустым.

Остальное - только про обход вашего дерева. При анализе элемента проверьте, существует ли первый каталог в свойстве Children вашего корневого узла. Если он не существует, добавьте его, если он есть, используйте этот и идите дальше.