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

Просто.

Создайте список объектов OutlineObject, по одному для каждого уровня, они будут служить родительскими объектами.

Итак, алгоритм:

1. Создайте объект из строки
2. Найдите уровень отступа (который будет равен 0 для корневых объектов)
3. Если в списке родителей меньше уровня + 1 количество элементов, добавляйте «нулевые» элементы до тех пор, пока их не будет достаточно (что означает, что для первого корневого объекта добавьте «нулевой» элемент, чтобы он имел 1 элемент)
4. Замените элемент #level в этом списке новым созданным вами объектом в 1. (поскольку список основан на 0, корневые объекты будут первыми)
5. Если уровень> 0, добавить его как дочерний элемент к родителям [уровень-1], если уровень == 0, добавить это как корневой объект

Это должно дать вам древовидную структуру. Вам нужно будет вести дочерний список в каждом объекте.

Также обратите внимание, что в приведенном выше списке потребуется дополнительная проверка ошибок, если вы хотите, чтобы он обрабатывал ошибки в файле, например:

root
-child 1
--child 2
another root
--child 3 (note that we skipped a level)

В этом случае последний дочерний элемент будет добавлен как дочерний элемент «child 1» , а не "другого корня".

Шаблон Composite - это первое, что приходит мне на ум...

Вот моя попытка, которая представляет собой комбинацию ваших оригинальных усилий и подхода Диамандиева. Я также добавил рекурсивный метод Output (), который эффективно воспроизводит исходный входной файл.

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

Обратите внимание, что это позволяет только для данного примера узлов, вложенных на 3 уровня в глубину. Любое большее, чем это, потребует модификации проверки else if ((oo.Indent - lastItem.Indent) <0) .

using System;
using System.Collections.Generic;
using System.Text;

namespace TestRecursive2342
{
    class Program
    {
        static void Main(string[] args)
        {
            List<OutlineObject> outlineObjects = new List<OutlineObject>();

            //convert file contents to object collection 
            List<string> lines = Helpers.GetFileAsLines();

            OutlineObject lastItem = new OutlineObject();
            bool processOk = true;

            foreach (var line in lines)
            {
                OutlineObject oo = new OutlineObject(line);

                if (lastItem.Indent != -1)
                {
                    if (oo.Indent == 0 && lastItem.Indent != 0)
                    {
                        // we've got a new root node item, so add the last item's top level parent to the list
                        while (lastItem.parent != null)
                            lastItem = lastItem.parent;

                        outlineObjects.Add(lastItem);
                    }
                    else if ((oo.Indent - lastItem.Indent) == 1)
                    {
                        // new item is one level lower than the last item
                        oo.parent = lastItem;
                        lastItem.OutlineObjects.Add(oo);
                    }
                    else if (oo.Indent == lastItem.Indent)
                    {
                        // new item is at the same level as the last item
                        oo.parent = lastItem.parent;
                        lastItem.parent.OutlineObjects.Add(oo);
                    }
                    else if ((oo.Indent - lastItem.Indent) < 0)
                    {
                        // new item is above the last item, but not a root node
                        // NB: this only allows for an item to be two levels above the last item
                        oo.parent = lastItem.parent.parent;
                        lastItem.parent.parent.OutlineObjects.Add(oo);
                    }
                    else if ((oo.Indent - lastItem.Indent) > 1)
                    {
                        // missing node check
                        Console.WriteLine("ERROR: missing node in input file between \"{0}\" and \"{1}\"", lastItem.Line, oo.Line);
                        processOk = false;
                        break;
                    }
                }

                lastItem = oo;
            }

            if (processOk)
            {
                // flush the last item
                while (lastItem.parent != null)
                    lastItem = lastItem.parent;

                outlineObjects.Add(lastItem);

                outlineObjects.ForEach(oo => oo.Output());
            }

            Console.ReadLine();
        }
    }

    public class OutlineObject
    {
        public OutlineObject parent { get; set; }
        public List<OutlineObject> OutlineObjects { get; set; }

        public string Line { get; set; }
        public int Indent { get; set; }

        public void Output()
        {
            StringBuilder sb = new StringBuilder();
            sb.Append('-', this.Indent);
            sb.Append(this.Line);

            Console.WriteLine(sb);

            foreach (OutlineObject oChild in this.OutlineObjects)
            {
                oChild.Output();
            }
        }

        public OutlineObject()
        {
            parent = null;
            OutlineObjects = new List<OutlineObject>();
            Line = "";
            Indent = -1;
        }

        public OutlineObject(string rawLine)
        {
            OutlineObjects = new List<OutlineObject>();
            Indent = rawLine.CountPrecedingDashes();
            Line = rawLine.Trim(new char[] { '-', ' ', '\t' });
        }
    }

    public static class Helpers
    {
        public static List<string> GetFileAsLines()
        {
            return new List<string> { 
                "countries", 
                "-france", 
                "--paris", 
                "--bordeaux", 
                "-germany", 
                "-italy", 
                "subjects", 
                "-math", 
                "--algebra", 
                "--calculus", 
                "-science", 
                "--chemistry", 
                "--biology", 
                "other", 
                "-this", 
                "-that"};
        }

        public static int CountPrecedingDashes(this string line)
        {
            int tabs = 0;

            foreach (var c in line)
            {
                if (c == '-')
                    tabs++;
                else
                    break;
            }
            return tabs;
        }
    }
}