C# 高级动态a的论证职业；“委托转换”；

上下文

class Program
{
    static int theYes = 0;

    delegate void operate();
    static void Main(string[] args)
    {
        int i = 0;
        OperatorOnFilter myOperators = new OperatorOnFilter();
        myOperators.AddOrReplace(0, (operate)delegate() { Console.Write("a"); theYes++; }); //1
        myOperators.AddOrReplace(1, (operate)delegate() { Console.Write("b"); theYes++; }); //2
        myOperators.AddOrReplace(2, (operate)delegate() { Console.Write("c"); theYes++; }); //4

        myOperators.ApplyOperations(new FilterManager(7));      //"abc" 7 = 1 + 2 + 4
        myOperators.ApplyOperations(new FilterManager(3));     //"ab" 3 = 1 + 2
        myOperators.ApplyOperations(new FilterManager(6));    //"bc" 6 = 2 + 4

        Console.WriteLine(theYes); // 7

        Console.ReadKey();
    }

}
// FINAL RESULT :
// abcabbc
// 7

在我的空闲时间，我想开发一种能够满足以下需求的工具：

• 循环一个位[]值，为每个True执行一个确定的方法
• 易于实现新方法，并且在出现新筛选器或向位[]值添加长度时易于整体调用

我把这种需求称为“委托转换”，但它们与

转换没有真正的关系


需要

class Program
{
    static int theYes = 0;

    delegate void operate1();
    delegate void operate2(string a);
    delegate void operate3(string a, uint x);
    static void Main(string[] args)
    {
        int i = 0;
        OperatorOnFilter myOperators = new OperatorOnFilter();
        myOperators.AddOrReplace(0, (operate1)delegate() { Console.Write("a"); theYes++; }); //1
        myOperators.AddOrReplace(1, (operate2)delegate(string a) { Console.Write(a); theYes++; }, "b"); //2
        myOperators.AddOrReplace(2, (operate3)delegate(string a, uint x) { for (uint j = 0U; j < x; j++) { Console.Write(a); theYes++; } }, "c", 3U); //4

        myOperators.ApplyOperations(new FilterManager(7));      //"abccc" 7 = 1 + 2 + 4
        myOperators.ApplyOperations(new FilterManager(3));     //"ab" 3 = 1 + 2
        myOperators.ApplyOperations(new FilterManager(6));    //"bccc" 6 = 2 + 4

        Console.WriteLine(theYes); // 11

        Console.ReadKey();
    }

}

我意识到我还想为我的方法提供参数（不同的方法可能不同）。因此，我搜索了解决方案并找到了一些技巧，使用
OperatorOnFilter
的继承来避免参数

我想知道的是：


是否存在一种无需继承（更改
OperatorOnFilter
）即可实现此目的的方法
（可选，如果没有，任何架构建议？）
（可选地，Delegate.DynamicInvoke（）有点慢。有更好的主意吗？）


现有代码

public class OperatorOnFilter
{
    Dictionary<int, Delegate> Operations;
    public OperatorOnFilter() { Operations = new Dictionary<int, Delegate>(); }

    public void AddOrReplace(int numTraitement, Delegate Action)
    {
        if (Operations.ContainsKey(numTraitement))
            Operations[numTraitement] = Action;
        else
            Operations.Add(numTraitement, Action);
    }

    public void ApplyOperations(FilterManager Filter)
    {
        for (int i = 0; i < Filter.Values.Count(); i++)
            if (Operations.ContainsKey(i) && Filter.Values[i])
                Operations[i].DynamicInvoke();
    }
}

public class FilterManager
{
    public bool[] Values;
    public FilterManager(int filtre)
    {
        List<bool> tmpList = new List<bool>();
        int i = 0;
        while (filtre >> i > 0)
        {
            tmpList.Add((filtre & (1 << i)) == (1 << i));
            i++;
        }
        Values = tmpList.ToArray();
    }
}

如果我正确理解了您的问题，那么您正在寻找一种在不指定传入参数数量的情况下编写函数的方法

有一种方法可以做到这一点，使用。还有一个很好的（可能更好的）例子

这可能要求您至少声明要传入的参数的类型。但是，您可以将该类型设置为对象或泛型，甚至可以使用您已经熟悉的委托类型传入其他函数

如果执行此操作，函数签名将类似于：
public void AddOrReplace（委托操作，参数int[]列表）{…}

你可以这样称呼它：
添加或替换（（操作）委托（）{Console.Write（“a”）；theYes++；}，1,2,3,4,5）
 基于@Erk的评论和一些自我改进。我在委托和AddOrReplace方法中使用显式参数找到了答案

最终代码（元组是在我使用.NET 3.5时添加的）

公共类运算符onfilter
{
字典操作=新建字典（）；
列表操作=新列表（）；
公共运算符onfilter（）{}
public void AddOrReplace（整数属性、委托操作、参数对象[]参数）
{
如果（！lstOperations.Contains（操作））
添加（操作）；
if（操作容器（numTraitement））
Operations[numTraitement]=新元组（lstOperations.IndexOf（Action），参数）；
其他的
Add（numTraitement，新元组（lstOperations.IndexOf（Action），Arguments））；
}
公共无效应用程序操作（筛选器管理器筛选器）
{
对于（int i=0；i>i>0）
{
tmpList.Add（（过滤器和（1）我添加了一个独立的FilterManager，可能会改变我在数学上寻找操作的方式。可能是为了以后使用接口/泛型进行抽象。仍然不太清楚您想要什么。使用参数调用？这些参数将来自何处？参数值和调用的委托来自独立项目（这里是
程序
）。其思想是，您可以存储这些委托，并使用在
ApplyOperations
之前在
Program
中设置的参数调用它们，然后在
ApplyOperations
中调用。因此，只需将您的参数与委托一起存储并调用即可。仍然不确定确切的问题是什么。例如，我们可以存储在
字典中le…对于我来说，使用测试部件是很清楚的。这意味着对于一般用途来说，
委托无效操作（）；
被
委托无效操作（params object[]args）；
是否不可能使强制转换
（operative）委托（）{/*blabla*/}
？只需选中…
参数
，即使在编译时正确，也不适用于
委托
class Program
{
    static int theYes = 0;

    delegate void operate1();
    delegate void operate2(string a);
    delegate void operate3(string a, uint x);
    static void Main(string[] args)
    {
        int i = 0;
        OperatorOnFilter myOperators = new OperatorOnFilter();
        myOperators.AddOrReplace(0, (operate1)delegate() { Console.Write("a"); theYes++; }); //1
        myOperators.AddOrReplace(1, (operate2)delegate(string a) { Console.Write(a); theYes++; }, "b"); //2
        myOperators.AddOrReplace(2, (operate3)delegate(string a, uint x) { for (uint j = 0U; j < x; j++) { Console.Write(a); theYes++; } }, "c", 3U); //4

        myOperators.ApplyOperations(new FilterManager(7));      //"abccc" 7 = 1 + 2 + 4
        myOperators.ApplyOperations(new FilterManager(3));     //"ab" 3 = 1 + 2
        myOperators.ApplyOperations(new FilterManager(6));    //"bccc" 6 = 2 + 4

        Console.WriteLine(theYes); // 11

        Console.ReadKey();
    }

}