C# 自定义通用式递归函数，实现 无限级 递归过滤 递归筛选

using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class MemberA
    {
        public bool State { get; set; }
        public string Name { get; set; }
        public int Stock { get; set; }
        public MemberA[] Childs { get; set; }
    }
    class MemberB
    {
        public string Name { get; set; }
        public int Stock { get; set; }
        public MemberB[] Childs { get; set; }
    }

    class Program
    {
        static void Main()
        {
            // 使用递归实现：将A集合数据同步到B集合中、并实现部分排除。（类似多层嵌套的文件夹复制效果，可用于过滤已停用的菜单项）

            // 定义原始数据
            MemberA[] before =
            #region
            {
                new MemberA() 
                { 
                    State = true,
                    Name = "广东省",
                    Stock = 556436,
                    Childs = new MemberA[]
                    {
                        new MemberA()
                        {
                            State = true,
                            Name = "广州市",
                            Stock = 56754,
                            Childs = new MemberA[]
                            {
                                new MemberA()
                                {
                                    State = true,
                                    Name = "荔湾区",
                                    Stock = 0,
                                    Childs = null,
                                },
                                new MemberA()
                                {
                                    State = true,
                                    Name = "越秀区",
                                    Stock = 0,
                                    Childs = null,
                                },
                            }
                        },
                        new MemberA()
                        {
                            State = true,
                            Name = "深圳市",
                            Stock = 765473,
                            Childs = new MemberA[]
                            {
                                new MemberA()
                                {
                                    State = true,
                                    Name = "南山区",
                                    Stock = 574763,
                                    Childs = null,
                                },
                                new MemberA()
                                {
                                    State = true,
                                    Name = "福田区",
                                    Stock = 473442,
                                    Childs = null,
                                },
                            }
                        },
                    }
                },
                new MemberA()
                {
                    State = true,
                    Name = "福建省",
                    Stock = 85657,
                    Childs = new MemberA[]
                    {
                        new MemberA()
                        {
                            State = false,
                            Name = "福州市",
                            Stock = 735463,
                            Childs = new MemberA[]
                            {
                                new MemberA()
                                {
                                    State = true,
                                    Name = "鼓楼区",
                                    Stock = 5633,
                                    Childs = null,
                                },
                                new MemberA()
                                {
                                    State = true,
                                    Name = "台江区",
                                    Stock = 2325,
                                    Childs = null,
                                },
                            }
                        },
                        new MemberA()
                        {
                            State = true,
                            Name = "厦门市",
                            Childs = new MemberA[]
                            {
                                new MemberA()
                                {
                                    State = true,
                                    Name = "思明区",
                                    Stock = 5646,
                                    Childs = null,
                                },
                                new MemberA()
                                {
                                    State = true,
                                    Name = "海沧区",
                                    Stock = 2345,
                                    Childs = null,
                                },
                            }
                        },
                    }
                },
            };
            #endregion

            // 使用递归过滤之后
            MemberB[] after = before.Recursion<MemberA, MemberB>((memberA, filter) =>
            #region
            {
                // 此处用于实现排除不满足需求的子成员
                if (!memberA.State)
                    return (false, null);

                // 通过 memberA 的数据来建立一个新的 memberB
                var memberB = new MemberB();

                memberB.Name = memberA.Name;
                memberB.Stock = memberA.Stock;
                memberB.Childs = memberA.Childs?.Recursion(filter).ToArray(); // 继续递归子成员

                // 此处用于实现排除无可用子项的空组
                if (memberA.Stock == 0 && (memberB.Childs == null || memberB.Childs.Length <= 0))
                    return (false, null);

                // 转换成功，返回转换之后的结果
                return (true, memberB);
            }).ToArray();
            #endregion

            var json1 = JsonConvert.SerializeObject(before);    // 所有成员信息
            var json2 = JsonConvert.SerializeObject(after);     // 筛选出未停用、且还有库存剩余的成员信息

            Console.ReadKey();
        }
    }
    static class Helper
    {
        /// <summary>
        /// 通用式递归过滤与递归转换函数 - 委托参数 (用于接收单成员的过滤实现)
        /// </summary>
        /// <typeparam name="TOldItem">转换之前的成员类型</typeparam>
        /// <typeparam name="TNewItem">转换之后的成员类型</typeparam>
        /// <param name="item">单个成员对象</param>
        /// <param name="filter">定义为单个成员的过滤实现</param>
        /// <returns>返回单个成员的处理结果 (是否保留, 在需要保留时返回转换后的结果)</returns>
        public delegate (bool, TNewItem) RecursionDelegate<TOldItem, TNewItem>(TOldItem item, RecursionDelegate<TOldItem, TNewItem> filter);
        /// <summary>
        /// 通用式递归过滤与递归转换函数
        /// </summary>
        /// <typeparam name="TOldItem">转换之前的成员类型</typeparam>
        /// <typeparam name="TNewItem">转换之后的成员类型</typeparam>
        /// <param name="list">树形成员集合</param>
        /// <param name="filter">定义为单个成员的过滤实现</param>
        /// <returns></returns>
        public static List<TNewItem> Recursion<TOldItem, TNewItem>(this IEnumerable<TOldItem> list, RecursionDelegate<TOldItem, TNewItem> filter)
        {
            if (list == null)
                return null;

            var newList = new List<TNewItem>();

            foreach (var item in list)
            {
                // 执行过滤操作
                var filterResult = filter(item, filter);

                // 如果当前成员不满足条件则直接排除
                if (!filterResult.Item1)
                    continue;

                // 反之说明转换成功，返回转换之后的结果
                newList.Add(filterResult.Item2);
            }

            return newList;
        }
    }
}