Построить дерево

 public class BaseTreeModel
    {
 
        void BaseTreeModel(ModelFromCSV model)
        {
            SetDText(model);
            Children   = new List<BaseTreeModel>();
        }
        
        public List<BaseTreeModel> Children { get; }
       
        public string ParentName { get; set; } = string.Empty;
 
        public string DisplayText { get; private set; } = string.Empty;
 
        public BaseTreeModel Parent { get; set; }      
 
        public void SetDText(ModelFromCSV model)
        {
            DisplayText = $"Имя: {model.Name}, Обозначение: {model.Designation}, Уровень: {model.Level}";
        }
 
        public virtual void AddChild(BaseTreeModel child)
        {
            child.Parent = this;
            Children.Add(child);
        }
    }

public class ModelFromCSV
    {
        public string Designation { get; private set; }
        public string Level { get; private set; }   
        public string Name { get; private set; }   
     }

var itemsList = new List<ModelFromCSV>()
                {
                    new ModelFromCSV("ABC", "0", "Item21"),
                    new ModelFromCSV("ABC", "1", "Item21"),
                    new ModelFromCSV("ABD", "2", "Item22"),
                    new ModelFromCSV("ABC", "1.1", "Item31"),
                    new ModelFromCSV("ABC", "1.2", "Item11"),
                    new ModelFromCSV("ABC", "3", "Item1"),
                    new ModelFromCSV("ABC", "3.1", "Item34"),
                    new ModelFromCSV("ABC", "3.1.2", "Item55"),
                };

var newTree = new BaseTreeModel(list.FirstOrDefault(r => r.Level == "0"));
var resultList = list.Where(x=>x.Level != "0").ToList();
 
Regex regex2 = new Regex(@"^[1-99]$");
var firstLevel2 = resultList.Where(ind => regex2.IsMatch(ind.Level)).ToArray();
 
foreach (ModelFromCSV modelFromCsv in firstLevel2)
 {
     CreateTree(modelFromCsv.Level, list, newTree);
 }
 
 
....
 
private void CreateTree(string v, List<ModelFromCSV> list, PLMTree newTree)
        {
            var curLevel = v + ".";
            var arr = "1-99";
            string currentRegex = $"^{curLevel}[{arr}]$";
 
            Regex regex = new Regex(currentRegex);
            var firstLevel = list.Where(ind => regex.IsMatch(ind.Level)).ToList();
 
            foreach (ModelFromCSV modelFromCsv in firstLevel)
            {
             ????
            }
        }

class Node
{
    // данные
    List<Node> children; // потомки
    Node parent; // родитель
}
 
class Tree
{
    List<Node> roots; // корни
}

using System;
using System.Collections.Generic;
using System.Linq;
 
class Node
{
    public string Name;
    public List<Node> Children = new List<Node>();
 
    public Node(string name)
    {
        Name = name;
    }
 
    public override string ToString()
    {
        return Name;
    }
}
 
class Tree
{
    List<Node> Roots = new List<Node>();
 
    public void AddRoot(Node node)
    {
        Roots.Add(node);
    }
 
    // Можно сделать перегрузку через params int[]
    public Node SearchByLevel(string level)
    {
        int[] arr = level.Split('.').Select(x => int.Parse(x)).ToArray();
        return Search(Roots, 1);
 
        Node Search(List<Node> nodes, int lvl)
        {
            if (lvl == arr.Length)
                return nodes[arr[lvl - 1] - 1];
            return Search(nodes[arr[lvl - 1] - 1].Children, lvl + 1);
        }
    }
 
    public override string ToString()
    {
        string result = "";
 
        for (int i = 0; i < Roots.Count; i++)
            result += (i + 1).ToString() + ")" + Roots[i] + "\n" + Foo(Roots[i], i + 1);
 
        string Foo(Node node, params int[] arr)
        {
            string str = "";
            int level = 1;
            foreach (var currentNode in node.Children)
            {
                str += string.Join(".", arr) + "." + level + ")" + currentNode + "\n";
                if (currentNode.Children.Count > 0)
                {
                    int[] newArr = new int[arr.Length + 1];
                    arr.CopyTo(newArr, 0);
                    newArr[newArr.Length - 1] = level;
                    str += Foo(currentNode, newArr);
                }
                level++;
            }
            return str;
        }
        return result;
    }
}
 
class Program
{
    static void Main()
    {
        Tree tree = new Tree();
 
        tree.AddRoot(new Node("Автомобили"));
        tree.SearchByLevel("1").Children.Add(new Node("ВАЗ"));
        tree.SearchByLevel("1").Children.Add(new Node("Камаз"));
 
        tree.AddRoot(new Node("Компьютеры"));
        tree.SearchByLevel("2").Children.Add(new Node("Оперативка"));
        tree.SearchByLevel("2").Children.Add(new Node("HDD"));
        tree.SearchByLevel("2.1").Children.Add(new Node("Samsung"));
        tree.SearchByLevel("2.1").Children.Add(new Node("G.SKILL"));
        tree.SearchByLevel("2.1.1").Children.Add(new Node("Samsung-1"));
        tree.SearchByLevel("2.1.1").Children.Add(new Node("Samsung-2"));
 
        Console.WriteLine(tree);
 
        tree.SearchByLevel("2.1.1").Children.Clear();
        Console.WriteLine(tree);
 
        Console.ReadKey();
    }
}

tree.SearchByLevel("2.2.1").Children.Add(new Node("Samsung-22"));

        List<string> lst = new List<string>()
        {
            "1",
            "1.1",
            "2.1",
            "1.1.2",
            "1.2.1",
            "4.8.7"
        };
 
        lst.Sort();
 
        foreach(var str in lst)
            Console.WriteLine(str);

    class ModelFromCSV : TreeNode
    {
        public string Designation { get; private set; }
        public string Level { get; private set; }
        public string Name { get; private set; }
 
        public ModelFromCSV(string desig, string level, string name)
        {
            Designation = desig;
            Level = level;
            Name = name;
 
            base.Text = Level; // Свойство Text отображается в дереве
        }
    }

    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
 
        List<ModelFromCSV> itemsList = new List<ModelFromCSV>()
        {
            new ModelFromCSV("ABC", "3.1.2", "Item55"),
            new ModelFromCSV("ABC", "1", "Item21"),
            new ModelFromCSV("ABD", "2", "Item22"),
            new ModelFromCSV("ABC", "1.1", "Item31"),
            new ModelFromCSV("ABC", "1.2", "Item11"),
            new ModelFromCSV("ABC", "3", "Item1"),
            new ModelFromCSV("ABC", "3.1", "Item34")
        };
 
        private void button1_Click(object sender, EventArgs e)
        {
            // Сортировка по уровню по возрастанию
            var models = from u in itemsList
                         orderby u.Level
                         select u;
 
            foreach (var m in models)
                AddNodeInTree(m);
        }
 
        void AddNodeInTree(ModelFromCSV model)
        {
            int[] arr = model.Level.Split('.').Select(x => int.Parse(x)).ToArray();
            if (arr.Length == 1)
            {
                treeView1.Nodes.Add(model);
                return;
            }
            Search(1, treeView1.Nodes[arr[0] - 1]);
 
            void Search(int lvl, TreeNode node)
            {
                if (lvl == arr.Length - 1)
                {
                    node.Nodes.Add(model);
                    return;
                }
                Search(lvl + 1, node.Nodes[arr[lvl] - 1]);
            }
        }
    }

    public class Node : IList<Node>
    {
        public ReadOnlyCollection<int> Address { get; }
        public int Level { get; }
 
        public Node(int level = 0, IEnumerable<int> address = null)
        {
            if (level < 0)
                throw new ArgumentOutOfRangeException("Уровень не может быть отрицательным", nameof(level));
 
            Level = level;
            if (Level == 0)
            {
                Address = new ReadOnlyCollection<int>(new int[0]);
                return;
            }
 
            if (address == null)
                throw new ArgumentNullException(nameof(address));
 
            Address = Array.AsReadOnly(address.Take(level).ToArray());
            if (level != Address.Count)
                throw new ArgumentException("Не хватает длины адреса для уровня", nameof(level));
 
            Nodes = nodes.AsReadOnly();
        }
 
        public Node(int level, params int[] address)
            : this(level, (IEnumerable<int>)address)
        { }
 
        private readonly List<Node> nodes = new List<Node>();
        public ReadOnlyCollection<Node> Nodes { get; }
        public int Count => Nodes.Count;
 
        public bool IsReadOnly { get; }
 
        Node IList<Node>.this[int index] { get => Nodes[index]; set => throw new NotImplementedException(); }
 
        public Node this[int index] => Nodes[index];
 
        public IEnumerator<Node> GetEnumerator()
            => Nodes.GetEnumerator();
        IEnumerator IEnumerable.GetEnumerator()
            => Nodes.GetEnumerator();
 
        public int IndexOf(Node item)
            => nodes.IndexOf(item);
 
        public void Insert(int index, Node item)
        {
            if (item.Level <= Level)
                throw new ArgumentOutOfRangeException($"Уровень добавляемого элемента должен быть больше {Level}", nameof(item));
 
            if (!ArrayEquals(Address, item.Address))
                throw new ArgumentOutOfRangeException($"Адрес узла не корректный {string.Join(".", item.Address)}", nameof(item));
 
            if (item.Level == Level + 1)
            {
                nodes.Insert(index, item);
                return;
            }
 
            Node nested = nodes.FirstOrDefault(it => it.Address[Level] == item.Address[Level]);
            if (nested == null)
            {
                nested = new Node(Level + 1, item.Address);
                nodes.Insert(index, nested);
            }
            nested.Add(item);
        }
 
        public void RemoveAt(int index)
            => nodes.RemoveAt(index);
 
        public void Add(Node item)
            => Insert(nodes.Count, item);
 
        public void Clear()
            => nodes.Clear();
 
        public bool Contains(Node item)
            => nodes.Contains(item);
 
        public void CopyTo(Node[] array, int arrayIndex = 0)
            => nodes.Skip(arrayIndex).ToArray();
 
        public bool Remove(Node item)
            => nodes.Remove(item);
 
        public static bool ArrayEquals<T>(IReadOnlyList<T> left, IReadOnlyList<T> right)
        {
            if (left == null || right == null || left.Count > right.Count)
                return false;
 
            for (int i = 0; i < left.Count; i++)
                if (!left[i].Equals(left[i]))
                    return false;
 
            return true;
        }
 
        public static Node Parse(string source)
        {
            var addr = source.Split('.', ',').Select(it => int.Parse(it.Trim()));
            return new Node(addr.Count(), addr);
        }
 
        public static bool TryParse(string source, out Node node)
        {
            try
            {
                node = Parse(source);
                return true;
            }
            catch (Exception)
            {
                node = null;
                return false;
            }
        }
 
        public static Node Parse(IEnumerable<string> source)
        {
            Node main = new Node();
            foreach (string item in source)
                main.Add(Parse(item));
 
            return main;
        }
        public static bool TryParse(IEnumerable<string> source, out Node node)
        {
            try
            {
                node = Parse(source);
                return true;
            }
            catch (Exception)
            {
                node = null;
                return false;
            }
        }
 
        public override string ToString()
        {
 
            StringBuilder builder = new StringBuilder();
 
            toString(this);
 
 
            return builder.ToString();
 
            void toString(Node node, int level = 0)
            {
                builder.Append('-', level);
                builder.AppendLine(string.Join(".", node.Address));
                node.nodes.ForEach(nd => toString(nd, level + 1));
            }
        }
    }

        static void Main(string[] args)
        {
            string[] treeSource = { "1", "1.1", "2.1", "1.1.2", "1.2.1", "4.8.7"};
 
            Node tree = Node.Parse(treeSource);
 
            Console.WriteLine(tree);
        }