具体代码

下面是优化后的代码：

// 缓存查询结果的字典
private static Dictionary<string, decimal> _cache = new Dictionary<string, decimal>();

public List<DepartDto> TreeListCount(int year, int? month, List<DepartDto> allList, int parentID = 0, int depth = 0)
{
    // 如果递归深度超过 10 层，直接返回空列表，以防止栈溢出
    if (depth > 10) return new List<DepartDto>();

    // 将所有部门对象转换为字典，以便快速查找
    var dict = allList.ToDictionary(a => a.DepartName);

    // 查找当前父部门的所有子部门
    var list = allList.Where(a => a.ParentID == parentID).ToList();

    foreach (var parentItem in list)
    {
        // 查找父部门的总人数、采购金额和出差金额，如果已经缓存了查询结果则直接使用缓存值
        parentItem.total = GetCacheValue($"{year}-{month}-true-{parentItem.DepartName}", () => pareChilTotal(true).FirstOrDefault(a => a.DepartName == parentItem.DepartName)?.total ?? 0);
        parentItem.procurementMoney = GetCacheValue($"{year}-{month}-true-{parentItem.DepartName}-2", () => money(year, month, 2, true).FirstOrDefault(a => a.DepartName == parentItem.DepartName)?.procurementMoney ?? 0);
        parentItem.travelMoney = GetCacheValue($"{year}-{month}-true-{parentItem.DepartName}-3", () => money(year, month, 3, true).FirstOrDefault(a => a.DepartName == parentItem.DepartName)?.travelMoney ?? 0);

        // 递归查找子部门，并计算子部门的总人数、采购金额和出差金额
        parentItem.children = TreeListCount(year, month, allList, parentItem.DepartID, depth + 1);
        parentItem.total += parentItem.children.Sum(a => a.total);
        parentItem.procurementMoney += parentItem.children.Sum(a => a.procurementMoney);
        parentItem.travelMoney += parentItem.children.Sum(a => a.travelMoney);
    }

    return list;
}

// 获取缓存值，如果缓存中不存在则执行指定的查询函数
private decimal GetCacheValue(string key, Func<decimal> query)
{
    if (_cache.TryGetValue(key, out decimal value))
    {
        return value;
    }
    else
    {
        value = query();
        _cache[key] = value;
        return value;
    }
}

这个优化版本中，我们添加了一个 `_cache` 字段来缓存查询结果，并且使用 `GetCacheValue` 方法来获取缓存值或执行查询函数。此外，我们将 `AllList` 列表转换为字典，以便快速查找部门对象。在计算子部门的总人数、采购金额和出差金额时，我们使用了 LINQ 的 `Sum` 方法来简化代码。最后，我们还添加了一个 `depth` 参数来限制递归深度，防止栈溢出。