任意成员变量的任意计算

Question

考虑这个简单的例子：

class Foo
{
    public int a;
    public int b;
    public int c;
    public List<Foo> foos; // This complicates matters a bit
}

现在我想计算任何成员(包括Foo子成员(的sum/min/max/me均值等。我想为此制作一个通用函数，这样我就不必重复代码了。

我想象这样的函数调用：

double sum = Calculate<double>(someFoo, sum => (f => f.a));
int count = Calculate<int>(someFoo, count => (f => 1 + foo.Length));

因此，对于Foo的任意成员，是一个任意运算。这可以在C#4.0中完成吗？例如，使用Actions？

Answer 1

编写一个助手函数，为您提供所有Foo s:

IEnumerable<Foo> SelfAndDescendants
{
  get
  {
    yield return this;
    foreach(var child in foos)
      foreach(var descendant in SelfAndDescendants(child)
        yield return descendant;
  }
}

然后您可以简单地使用普通LINQ来进行聚合：root.SelfAndDescendents.Sum(f=>f.a)

---

如果你想进一步提高可重用性，你可以使用一个通用的帮助函数：

public static IEnumerable<T> DepthFirstTopDownTraversal(T root, Func<T, IEnumerable<T>> children)
{
    Stack<T> s=new Stack<T>();
    s.Push(root);
    while(s.Count>0)
    {
      T current = s.Pop();
      yield return current;
      foreach(var child in children(current))
        s.Push(child);
    }
}

然后将CCD_ 5实现为CCD_。

Answer 2

您可以这样做。不过，您的语法有点错误。它看起来是这样的：

double sum = Calculate<double>(someFoo, f => f.a);
int count = Calculate<int>(someFoo, f => 1 + f.Length);

方法看起来是这样的：

public T Calculate<T>(Foo foo, Func<Foo, T> calculator)
{
    return calculator(foo);
}

然而，所有这些对于Foo的一个实例来说并没有真正意义。更有可能的是，someFoo实际上应该是someFoos，即多个对象。此外，我想您也希望能够指定聚合方法
这将把Calculate改为：

public T Calculate<T>(IEnumerable<Foo> foo, Func<Foo, T> calculator,
                      Func<IEnumerable<T>, T> aggregate)
{
    return aggregate(foo.Select(calculator));
}

用法：

List<Foo> someFoos = ...;
var sum = Calculate(someFoos, x => x.a, Enumerable.Sum)
var count = Calculate(someFoos, x => 1 + x.Length, Enumerable.Count)

要使其全部递归，最简单的方法是使用一个方法将Foo对象及其所有子对象作为平面列表返回：

public IEnumerable<Foo> Flatten(Foo foo)
{
    yield return foo;
    foreach(var child in foo.Children.SelectMany(Flatten))
        yield return child;
}

在Calculate中使用此方法将导致以下结果：

public T Calculate<T>(IEnumerable<Foo> foo, Func<Foo, T> calculator,
                      Func<IEnumerable<T>, T> aggregate)
{
    return aggregate(Flatten(foo).Select(calculator));
}

---

说了这些，写了这些，我不得不问：你为什么不使用普通的LINQ？

Flatten(foo).Select(f => f.a).Sum();
Flatten(foo).Select(f => 1 + f.Length).Count();

Answer 3

是的，你可以做到。根据您想要调用Calculate方法的方式，可以定义如下：

private T Calculate<T>(Foo foo, Func<Foo, Func<Foo, T>> func) {
    //do something here...
}

编辑：也许这没有太大意义，所以如果您能为我们提供一个预期输入/输出的示例，那将非常有用。