模棱两可的构造函数调用错误

Question

我有一个名为Test 的类，它有一个constructor 接受Action<T>，另一个接受Func<T,T>。请看下面的sn-p。

public class Test<T>
{
    //constructors
    public Test() { }
    public Test(Action<T> action) { }
    public Test(Func<T, T> action) { }

    //methods with same signature of constructor
    public void MyMethod1(Action<T> action) { }
    public void MyMethod2(Func<T, T> action) { }
}


public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();
        Test<string> t1 = new Test<string>(this.MyMethod1);
        Test<string> t2 = new Test<string>(this.MyMethod2);

        Test<string> t = new Test<string>();
        t.MyMethod1(MyMethod1);
        t.MyMethod2(MyMethod2);
    }

    public void MyMethod1(string value) { }
    public string MyMethod2(string value) { return string.Empty; }

}

但下面的行会引发一个模棱两可的调用错误

Test<string> t1 = new Test<string>(this.MyMethod1);
Test<string> t2 = new Test<string>(this.MyMethod2);

有趣的是，我有两个方法与我的 Test 类 constructor 的签名相同，它们不会引发任何模棱两可的错误

Test<string> t = new Test<string>();
t.MyMethod1(MyMethod1);
t.MyMethod2(MyMethod2);

谁能帮我确定并解决问题。

Answer 1

方法的返回值不是其签名的一部分。只考虑参数。因此，编译器无法区分Action<T> 和Func<T,T>。详细的解释和解决方法可以找到in this StackOverflow question

Answer 2

您可以尝试重命名每个构造函数的参数，如下所示：

public class Test<T>
{
    public Test() { }
    public Test(Action<T> action) { }
    public Test(Func<T,T> function) { }
}

所以当你实例化你的类时，你可以像这样指定参数的名称：

var objectWithAction = new Test<string>(action: Method1);
var objectWithFunction = new Test<string>(function: Method2);

Answer 3

事实

方法/构造函数重载可以通过参数类型识别正确的方法但不包括返回类型。

原因

并且由于在问题中提到的两个构造函数调用中，参数都是 MethodGroup 类型，因此编译器无法确定正确的重载。其次，对方法的调用是成功的，因为在不重载的情况下。

分辨率

这里是解决问题的可能选项

将方法调用封装成匿名方法调用，让隐式转换来区分自己。

    Test<string> t1 = new Test<string>(s => this.MyMethod1(s));
    Test<string> t2 = new Test<string>(s => { return this.MyMethod2(s); });

结果

---

替代方法

其他选项是显式转换方法组

    Test<string> t1 = new Test<string>((Action<string>)this.MyMethod1);
    Test<string> t2 = new Test<string>((Func<string, string>)this.MyMethod2);

如果参数较少，这比第一种方法要长一些

Answer 4

这里是一个工作控制台应用程序示例

class Program
    {
        static void Main(string[] args)
        {
            Test<string> t1 = new Test<string>(action: MyMethod1);
            Test<string> t2 = new Test<string>(function: MyMethod2);


            Test<string> t = new Test<string>();
            t.MyMethod1(MyMethod1);
            t.MyMethod2(MyMethod2);
        }
        public static void MyMethod1(string value)
        {
            Console.WriteLine("my method1 {0}", value);
        }
        public static string MyMethod2(string value)
        {
            Console.WriteLine("my method2 {0}", value);
            return string.Empty;
        }
    }
    public class Test<T>
    {
        //constructors
        public Test() { }
        public Test(Action<T> action)
        {

            object args = "action";
            action.Invoke((T)args); // here you should invoke the method in order to execute it
        }
        public Test(Func<T, T> function)
        {
            object args = "function";
            function.Invoke((T)args);
        }

        //methods with same signature of constructor
        public void MyMethod1(Action<T> action)
        {
            object args = "Method 3";
            action.Invoke((T)args);
        }
        public void MyMethod2(Func<T, T> action)
        {
            object args = "Method 4";
            action.Invoke((T)args);
        }
    }

希望对你有帮助

问候