PIbd-33_Abazov_A.A._KOP_29/AbazovApp/AbazovViewComponents/Components/AbazovTreeView.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace AbazovViewComponents.Components
{
    public partial class AbazovTreeView : UserControl
    {
        public AbazovTreeView()
        {
            InitializeComponent();
        }
        private List<(string, bool)> hierarchy = new List<(string, bool)>();

        public int SelectedNodeIndex
        {
            get
            {
                return treeView.SelectedNode?.Index ?? -1;
            }
            set
            {
                if (treeView.SelectedNode == null) treeView.SelectedNode = value >= 0 && value < treeView.Nodes.Count ? treeView.Nodes[value] : treeView.SelectedNode;
                else treeView.SelectedNode = value >= 0 && value < treeView.SelectedNode.Nodes.Count ? treeView.SelectedNode.Nodes[value] : treeView.SelectedNode;
            }
        }

        public T? getSelecetedNodeValue<T>()
        {
            if (treeView.SelectedNode == null || treeView.SelectedNode.Nodes.Count > 0) return default(T);

            List<object> values = new List<object>();
            List<string> fieldNames = new List<string>();

            TreeNode? node = treeView.SelectedNode;

            var type = typeof(T);
            var fields = type.GetFields();
            List<Type> types = new List<Type>();

            while (node != null)
            {
                var field = fields.FirstOrDefault(x => x.Name == node.Name);
                if (field != null)
                {
                    Type typeOfField = field.FieldType;
                    types.Add(typeOfField);
                    values.Add(Convert.ChangeType(node.Text, typeOfField));
                    fieldNames.Add(field.Name);
                }
                node = node.Parent;
            }

            var constructor = type.GetConstructor(types.ToArray());
            if (constructor == null) return default(T);
            var parameters = constructor.GetParameters();

            List<object> valuesForInvoking = new List<object>();
            foreach (var param in parameters)
            {
                int index = fieldNames.IndexOf(param.Name);
                valuesForInvoking.Add(values[index]);
            }
            return (T) constructor.Invoke(valuesForInvoking.ToArray());
        }

        public void setHierarchy(List<(string, bool)> fields)
        {
            hierarchy = fields;
        }

        public void addItems<T>(List<T> items)
        {
            var type = typeof(T);
            var fields = type.GetFields();
            foreach (T item in items)
            {
                TreeNodeCollection nodes = treeView.Nodes;
                for (int i = 0; i < hierarchy.Count; i++)
                {
                    var field = fields.FirstOrDefault(x => x.Name.Equals(hierarchy[i].Item1));
                    if (field is not null)
                    {
                        var node = nodes.Find(field.Name, false).FirstOrDefault(x => x.Text == field.GetValue(item).ToString());
                        if (node is not null && !hierarchy[i].Item2)
                        {
                            nodes = node.Nodes;
                        }
                        else
                        {
                            TreeNode newNode = nodes.Add(field.Name, field.GetValue(item).ToString());
                            nodes = newNode.Nodes;
                        }
                    }
                }
            }
        }
    }
}