Question

我很擅长使用linq表达式并尝试重构一些旧代码。有没有办法将以下方法转换为简洁干净的Linq表达式？

public int GetParentCount(object o)
{ 
    int count = 0;
    object parent = GetParentObject(o);
    while (parent != null)
    {
        count++;
        parent = GetParentObject(parent);
    }
    return count;
}

我试过搜索但没有得到令人满意的结果

Answer 1

您可以像这样枚举祖先：

public IEnumerable<MyClass> AncestorsOf(MyClass obj)
{
   var parent = GetParentObject(obj);
   if (parent != null)
   { 
       yield return parent;
       foreach(var grandparent in AncestorsOf(parent))
          yield return grandparent;
   }
}

获得总计数将是一个简单的AncestorsOf(obj).Count()

Answer 2

作为Ander解决方案的替代方案，非递归方法：

using System;
using System.Linq;
using System.Collections.Generic;

namespace Demo
{
    static class Program
    {
        static void Main()
        {
            var obj = new object();
            int count = AllParents(obj).Count(); // Using Linq only here.
            Console.WriteLine(count);
        }

        public static IEnumerable<object> AllParents(object obj)
        {
            while (true)
            {
                obj = GetParentObject(obj);

                if (obj == null)
                    yield break;

                yield return obj;
            }
        }

        // This is merely a hacky test implementation.
        public static object GetParentObject(object obj)
        {
            if (--count == 0)
                return null;

            return obj;
        }

        private static int count = 10;
    }
}

Answer 3

这是一个泛型函数，可以处理任何类型的对象，任何对象名称都包含父对象（使用Func<T,T>）：

public static class MyExtensions {

  /// <summary>Gets an enumerable of all ancestors.</summary>
  public static IEnumerable<T> Ancestors<T>(this T obj, Func<T, T> expr) where T : class {
    obj = expr.Invoke(obj);
    while(obj != null) {
      yield return obj;
      obj = expr.Invoke(obj);
  }
}

以下是使用该功能的示例应用程序：

class MyClass {
    public MyClass Parent { get; set; }
}

void Main()
{
    MyClass a = new MyClass();
    a.Parent = new MyClass();
    a.Parent.Parent = new MyClass();

    a.Ancestors(myObj => myObj.Parent).Count(); // Result: 2
}

使用Linq计算父对象

3 个答案: