将类别转换为人类可读的面包屑 C#

Question

I need a function that converts categories into flats (see code bellow). I get categories from the database and then I want to convert them into a breadcrumbs format so I can later display them in a combobox.

using System.Collections.Generic;

namespace ConsoleApp4
{
    class Program
    {
        static void Main(string[] args)
        {
            var categories = new List<ProductCategory>
            {
                new ProductCategory { ProductCategoryId = 1, ParentId = null, Name = "Drinks" },
                new ProductCategory { ProductCategoryId = 2, ParentId = null, Name = "Food" },
                new ProductCategory { ProductCategoryId = 3, ParentId = 1, Name = "Beers" },
                new ProductCategory { ProductCategoryId = 4, ParentId = 1, Name = "Wines" },
                new ProductCategory { ProductCategoryId = 5, ParentId = 3, Name = "Local beers" },
                new ProductCategory { ProductCategoryId = 6, ParentId = 3, Name = "Foreign beers" },
                new ProductCategory { ProductCategoryId = 7, ParentId = 4, Name = "Red wines" },
                new ProductCategory { ProductCategoryId = 8, ParentId = 4, Name = "White wines" },
            };

            // todo to get below structure...

            var flats = new List<ProductCategoryFlatItem>
            {
                new ProductCategoryFlatItem { NameWithAncestors = "Drinks",                          ProductCategoryId = 1 },
                new ProductCategoryFlatItem { NameWithAncestors = "Drinks / Beers",                  ProductCategoryId = 3 },
                new ProductCategoryFlatItem { NameWithAncestors = "Drinks / Beers / Local beers",    ProductCategoryId = 5 },
                new ProductCategoryFlatItem { NameWithAncestors = "Drinks / Beers / Foreingn beers", ProductCategoryId = 6 },
                new ProductCategoryFlatItem { NameWithAncestors = "Drinks / Wines",                  ProductCategoryId = 4 },
                new ProductCategoryFlatItem { NameWithAncestors = "Drinks / Wines / Red wines",      ProductCategoryId = 7 },
                new ProductCategoryFlatItem { NameWithAncestors = "Drinks / Wines / White wines",    ProductCategoryId = 8 },
                new ProductCategoryFlatItem { NameWithAncestors = "Food",                            ProductCategoryId = 2 },
            };
        }
    }

    public class ProductCategory
    {
        public int ProductCategoryId { get; set; }
        public int? ParentId { get; set; }
        public string Name { get; set; }
    }

    public class ProductCategoryFlatItem
    {
        public int ProductCategoryId { get; set; }
        public string NameWithAncestors { get; set; }
    }
}

UPDATE: I successfully build a tree, and then I am trying to use tree to build breadcrumbs by searching for ancestors, see my code bellow (this is work in progress...)

 public interface IProductCategoryExtensions
    {
        List<ProductCategoryTreeItem> BuildTreeAndGetRoots(List<ProductCategory> allCategories);
        List<ProductCategoryFlatItem> CreateComboboxItems(List<ProductCategory> categories);
    }

    public class ProductCategoryExtensions : IProductCategoryExtensions
    { 
        public List<ProductCategoryTreeItem> BuildTreeAndGetRoots(List<ProductCategory> allCategories)
        {
            var treeItems = new List<ProductCategoryTreeItem>();
            var rootItems = allCategories.Where(x => x.ParentId == null);

            foreach (var rootItem in rootItems)
            {
                treeItems.Add(new ProductCategoryTreeItem
                {
                    Item = rootItem,
                    Disabled = false,
                    Parent = null,
                    Children = GetChildren(allCategories, rootItem)
                });
            }

            return treeItems;
        }

        private List<ProductCategoryTreeItem> GetChildren(List<ProductCategory> allCategories, ProductCategory productCategory)
        {
            var children = new List<ProductCategoryTreeItem>();
            var childrenTemp = allCategories.Where(x => x.ParentId == productCategory.ProductCategoryId);
            foreach (var childTemp in childrenTemp)
            {
                var child = new ProductCategoryTreeItem
                {
                    Disabled = false,
                    Item = childTemp,
                    Children = GetChildren(allCategories, childTemp),
                };

                children.Add(child);
            }

            return children;
        }

        public List<ProductCategoryFlatItem> CreateComboboxItems(List<ProductCategory> categories)
        {
            var flats = new List<ProductCategoryFlatItem>();
            var tree = BuildTreeAndGetRoots(categories);

            foreach (var treeItem in tree)
            {
                flats.Add(CreateFlatItem(treeItem, categories));

                if (treeItem.HasChildren)
                {
                    flats.AddRange(GetChildrenFlats(treeItem.Children));
                }
            }

            return flats;
        }

        private List<ProductCategoryFlatItem> GetChildrenFlats(List<ProductCategoryTreeItem> children)
        {

            var flatChildren = new List<ProductCategoryFlatItem>();

            foreach (var child in children)
            {



                //if (child.Children != null && child.Children.Count > 0)
                //    Get
            }

            return flatChildren;
        }

        private ProductCategoryFlatItem CreateFlatItem(ProductCategoryTreeItem treeItem, List<ProductCategory> allCategories)
        {
            var flat = new ProductCategoryFlatItem();

            if (treeItem.Parent == null)
            {
                flat.Description = treeItem.Item.Description;
                flat.ProductCategoryId = treeItem.Item.ProductCategoryId;
            }
            else
            {

            }


            return flat;
        }

        public List<ProductCategoryTreeItem> BuildTreeAndGetRoots(List<ProductCategory> allCategories)
        {
            var treeItems = new List<ProductCategoryTreeItem>();
            var rootItems = allCategories.Where(x => x.ParentId == null);

            foreach (var rootItem in rootItems)
            {
                treeItems.Add(new ProductCategoryTreeItem
                {
                    Item = rootItem,
                    Disabled = false,
                    Parent = null,
                    Children = GetChildren(allCategories, rootItem)
                });
            }

            return treeItems;
        }

    }

public class ProductCategoryTreeItem
    {
        public ProductCategory Item { get; set; }
        public bool Disabled { get; set; }
        public ProductCategoryTreeItem Parent { get; set; }
        public List<ProductCategoryTreeItem> Children { get; set; } = new List<ProductCategoryTreeItem>();

        public bool HasChildren
        {
            get
            {
                return Children != null && Children.Count > 0;
            }
        }
    }

Answer 1

Sorry this is kinda messy code, but I'll leave the refactoring to you. Assuming we have two classes:

public class ProductCategory
{
    public int ProductCategoryId { get; set; }
    public int? ParentId { get; set; }
    public string Name { get; set; }

    public Dictionary<ProductCategory, int> AncestorsWithHierarchy { get; set; } = new Dictionary<ProductCategory, int>();
}

public class ProductCategoryFlatItem
{
    public string NameWithAncestors { get; set; }
    public int ProductCategoryId { get; set; }
}

I added AncestorsWithHierarchy to ProductCategory to be able to set up breadcrumb order right.

Then you can do setup a continuous search backwards among ancestors in a recursive way, while adding the hierarchy level to use it for .OrderBy()

var result = new List<ProductCategoryFlatItem>();

Func<ProductCategory, ProductCategory> FindParent = null;
FindParent = thisItem =>
{
    var parent = categories.Find(c => c.ProductCategoryId == thisItem.ParentId);
    return parent;
};

foreach (var category in categories)
{
    int hierarchyLevel = 0;

    var parent = FindParent(category);
    while (parent != null)
    {
        category.AncestorsWithHierarchy.Add(parent, hierarchyLevel);
        hierarchyLevel++;
        parent = FindParent(parent);
    }

    // Add self since we want it in the breadcrumb
    category.AncestorsWithHierarchy.Add(category, -1);

    result.Add(new ProductCategoryFlatItem()
    {
        NameWithAncestors = string.Join(" / ", category.AncestorsWithHierarchy.OrderByDescending(x => x.Value).Select(anc => anc.Key.Name)),
        ProductCategoryId = category.ProductCategoryId
    });
}

Which gives you your desired result:

However , I would never do this kind of operation during every read. I'm assuming this data will be read much more than it'll be written. So, what I would really do is, to move this logic where you are CRUD'ing to the database and build your breadcrumb there as a new field, and only recalculate if a category changes. This is much better than calculating on every single read request for every single user.