Get all children in Tree

Question

There is a class that stores the tree of elements. Child elements are stored in

public List<BaseTreeData> Child { get; set; }

I want to display this tree as a "flat" (linear) list of all elements. After the class is divided into two (base and heir), the GetChildren method generates an error about the type mismatch. Most likely everything is logical, but how to fix it?

Error CS1503 Argument 1: cannot convert from 'ConsoleApplication1.BaseTreeData' to 'ConsoleApplication1.TreeData'

namespace ConsoleApplication1
{
    class Program
    {        
        static void Main(string[] args)
        {
            var data = new List<TreeData>();
            for (int i = 0; i < 5; i++)
            {
                var item = new TreeData() { Name = i.ToString() };
                for (int j = 0; j < 3; j++)
                {
                    var number = (i + 1) * 10 + j;
                    item.Child.Add(new TreeData() { ID = number, Name = number.ToString(), Parent = item });                    
                }
                data.Add(item);
            }

            foreach (var item in data.SelectMany(x => GetChildren(x)))
            {
                Console.WriteLine(item.ID + " " + item.Name + " " + item.IsChecked);
            }
        }

        static IEnumerable<TreeData> GetChildren(TreeData d)
        {
            return new[] { d }.Concat(d.Child).SelectMany(x => GetChildren(x));
        }
    }

    class BaseTreeData
    {
        public bool IsChecked { get; set; }
        public BaseTreeData Parent { get; set; }
        public List<BaseTreeData> Child { get; set; }

        public BaseTreeData()
        {
            Child = new List<BaseTreeData>();
        }
    }

    class TreeData : BaseTreeData
    {
        public int ID { get; set; }
        public string Name { get; set; }
    }
}

Answer 1

Error CS1503 Argument 1: cannot convert from 'ConsoleApplication1.BaseTreeData' to 'ConsoleApplication1.TreeData'

This error occurs because the child nodes are BaseTreeData instead of TreeData.

Using the BaseTreeData class definition you posted, child and parent will always return the base type.

Instead you can solve this with generics so that child nodes will be the same type as the parent class:

class BaseTreeData<T> where T : BaseTreeData<T>
{
    public bool IsChecked { get; set; }
    public T Parent { get; set; }
    public List<T> Children { get; set; }

    public BaseTreeData()
    {
        Children = new List<T>();
    }

    public IEnumerable<T> GetAncestors()
    {
        if (Parent == null)
            yield break;

        T relative = Parent;
        while (relative != null)
        {
            yield return relative;
            relative = relative.Parent;
        }
    }

    public IEnumerable<T> GetDescendants()
    {
        var nodes = new Stack<T>();
        nodes.Push(this as T);

        while (nodes.Any())
        {
            var current = nodes.Pop();
            yield return current;

            foreach (var childNode in current.Children)
                nodes.Push(childNode);
        }
    }
}

class TreeData : BaseTreeData<TreeData>
{
    public int ID { get; set; }
    public string Name { get; set; }
}

Answer 2

Your base class property Child is of type List<BaseTreeData> but you are attempting to call static method GetChildren which expects an object of type TreeData. You are essentially trying to upcast your object. How would the compiler know what to populate ID and Name with?

A more elegant approach would be to let each class decide what its string representation looks like. This eliminates the need for a GetChildren method, since you can just use the base class' Child property:

foreach (var item in data.SelectMany(x => x.Child))
{
    Console.WriteLine(item.ToString());
}

You then override the ToString implementations so that the base class provides its values and the derived class builds upon that:

class BaseTreeData
{
    //Other stuff here
    //...
    public override string ToString()
    {
        return IsChecked.ToString();
    }
}

class TreeData : BaseTreeData
{
    //Other stuff here
    //...
    public override string ToString()
    {
        var format = "{0} {1} {2}";
        var stringRepresentation = string.Format(format, ID, Name, base.ToString());
        return stringRepresentation;
    }
}

Notice the call to base.ToString() in the parameters.

Output:

10 10 False

11 11 False