多播委托总是执行最后一个操作

Question

所以我有以下代码：

namespace ConsoleApplication1
{
    public delegate int Transformer(int x);

    class Test
    {
        public static void Transform(int[] values, Transformer t)
        {
            for (int i = 0; i < values.Length; i++)
            {
                values[i] = t(values[i]);
            }
        }

       static int Square(int x)
        {
            return x * x;
        }

        static int Minus(int x)
       {
           return x - 1;
       }

        static void Main()
        {
            int[] values = { 1, 2, 3 };
            Transformer t = Test.Minus;
            t += Test.Square;

            Test.Transform(values, t);

            foreach (int i in values)
            {
                Console.Write(i + " ");
            }
        }
    }
}

为什么它总是只对数组执行最后一个操作（在我的例子中是 Square ）。我应该改变什么才能同时实现 Minus 和 Square ？

Answer 1

多播委托始终返回链中最后一个委托的值。由于您不修改 Test.Minus 和 Test.Square 中的值，而是返回新值，因此仅应用后者。解决这个问题最简单的方法是让你的变压器通过引用获取值并修改它们。例如：

namespace ConsoleApplication1
{
    public delegate void Transformer(ref int x);

    class Test
    {
        public static void Transform(int[] values, Transformer t)
        {
            for (int i = 0; i < values.Length; i++)
            {
                t(ref values[i]);
            }
        }

       static void Square(ref int x)
       {
           x = x * x;
       }

       static void Minus(ref int x)
       {
           x = x - 1;
       }

        static void Main()
        {
            int[] values = { 1, 2, 3 };
            Transformer t = Test.Minus;
            t += Test.Square;

            Test.Transform(values, t);

            foreach (int i in values)
            {
                Console.Write(i + " ");
            }
        }
    }
}

Answer 2

因为结果并未链接到所有委托，

所以代码就相当于

 Minus(1);
 return Square(1);

更改代码以更改变量。

 public delegate void Transformer(ref int x);

    public static void Transform(int[] values, Transformer t)
    {
        for (int i = 0; i < values.Length; i++)
        {
            t(ref values[i]);
        }
    }

   static void Square(ref int x)
    {
        x*= x;
    }

    static void Minus(ref int x)
   {
       x--;
   }

更好的解决方案是使用 linq 聚合，因为您可以在不影响源的情况下转换解决方案。

public static int[] Transform(int[] values, params Func<int,int>[] t){
  return values.Select(v=>t.Aggregate(v,(x,f)=>f(x))).ToArray();
}

然后你可以只调用

values=Transform(values,new[] { Minus,Square });

或

int[] values = {1,2,3};
int[] result = Transform(values,Minus,Square);

在此调用值之后！=结果，因此源不变