Question

所以，假设我有一些已经为类定义的数字方法。

例如：

private int X(int a, int b)
{
    return a + b;
}

private int Y(int a, int b)
{
    return a - b;
}

private int Z(int a, int b)
{
    return a * b;
}

现在，在类主体中输入并通过所有函数运行它的标准方法显然是只调用这样的每个函数：

public void processNormal(int a, int b)
{
    //accumulate results
    int acc = 0;
    if (true)
    {
        //if want to add to current
        acc += X(a, b);
        acc += Y(a, b);
        acc += Z(a, b);
    }
    else
    {
        //if want to replace current if larger
        int k = X(a, b);
        if (k > acc)
            acc = k;

        k = Y(a, b);
        if (k > acc)
            acc = k;

        k = Z(a, b);
        if (k > acc)
            acc = k;
    }
}

现在我很好奇，因为随着函数数量的增加，取决于你可能想要用函数结果做多少事情，如果这不会变得有点麻烦。而你可以创建一个你想要运行的函数的静态列表，然后在for循环中使用它来缩短内容，我想这会是这样的：

//List with all methods
List<Object> methods = new List<Object>();
//add all methods to list

public void processWithList(int a, int b)
{
    //accumulate results
    int acc = 0;
    foreach (Object j in methods)
    {
        if (true)
        {
            //if want to add to current
            acc += j(a, b);
        }
        else
        {
            //if want to replace current if larger
            int k = j(a, b);
            if (k > acc)
                acc = k;
        }
    }
}

现在有了第二个过程，你仍然需要在某个地方定义列表，但我想在事情发展时更容易跟踪。所有函数都将采用相同的输入，并返回相同的对象，因此在这方面它不是问题。

我基本上想知道是否

A）我愚蠢地过度复杂化事情，如果这将是一件有用的事情。

B）C＃中会出现这样的情况？我可以在列表中使用预定义的类方法，还是必须使用一堆委托函数在类初始化中生成列表？

感谢您的时间。

Answer 1

我是否愚蠢地过度复杂化，如果这将是一件有用的事情？

不，你做得很好。这是一种常见的方法。

在C＃中会出现这样的情况？

我认为与您的示例代码匹配的最简单选项是使用List<Func<int, int, int>>。

以下是一个示例实现：

public class YourClass
{
    private List<Func<int, int, int>> methods;

    public yourClass()
    {
        methods = new List<Func<int, int, int>>()
        {
            (a,b) => X(a,b),
            (a,b) => Y(a,b),
            (a,b) => Z(a,b)
        };

    }

    public int SumMethods(int a, int b)
    {
        var result = 0;
        foreach(var m in methods)
        {
            result += m(a, b);
        }

        return result;
    }

    private int X(int a, int b) { throw new NotImplementedException(); }
    private int Y(int a, int b) { throw new NotImplementedException(); }
    private int Z(int a, int b) { throw new NotImplementedException(); }

}

Answer 2

我首先将其转向更多面向对象的方法。创建一个界面。然后为您要执行的每个操作实现该接口。然后，您可以将每个操作存储为接口。在运行操作时，它们或多或少地变得不可知：

class Program
{
    interface IIntOperation
    {
        int Execute(int a, int b);
    }

    class AddOperation : IIntOperation
    {
        public int Execute(int a, int b) => a + b;
    }

    class SubtractOperation : IIntOperation
    {
        public int Execute(int a, int b) => a - b;
    }

    static void Main(string[] args)
    {
        var lst = new List<IIntOperation>()
        {
            new AddOperation(),
            new SubtractOperation()
        };

        foreach(var op in lst)
        {
            op.Execute(1, 2);
        }

    }
}

创建要在动态对象上运行的方法列表

2 个答案: