C# 中的扩展方法重载有效吗？

Question

拥有一个具有方法的类，如下所示：

class Window {
    public void Display(Button button) {
        // ...
    }
}

是否可以用另一个更广泛的方法重载该方法，如下所示：

class WindowExtensions {
    public void Display(this Window window, object o) {
        Button button = BlahBlah(o);
        window.Display(button);
    }
}

当我尝试时发生的情况是我有无限递归。有办法让它发挥作用吗？我希望仅当无法调用其他方法时才调用扩展方法。

Answer 1

让我们看看规格。首先，我们要了解方法调用的规则。粗略地说，您从尝试调用方法的实例指示的类型开始。您沿着继承链向上寻找可访问的方法。然后，您执行类型推断和重载解析规则，并在成功时调用该方法。仅当未找到此类方法时，您才会尝试将该方法作为扩展方法进行处理。因此，从 §7.5.5.2（扩展方法调用）中可以看到，特别是粗体语句：

在其中一种形式的方法调用（§7.5.5.1）中

expr.identifier()

expr.identifier(args)

expr.identifier()

expr.identifier(args)

如果调用的正常处理没有找到适用的方法，则会尝试将该构造作为扩展方法调用进行处理。

除此之外的规则有点复杂，但对于您向我们展示的简单情况来说，它非常简单。如果没有适用的实例方法，则将调用扩展方法WindowExtensions.Display(Window, object)。如果 Window.Display 的参数是按钮或者可以隐式转换为按钮，则实例方法适用。否则，将调用扩展方法（因为从 object 派生的所有内容都可以隐式转换为 object）。

因此，除非您遗漏了重要的部分，否则您尝试做的事情将会起作用。

因此，请考虑以下示例：

class Button { }
class Window {
    public void Display(Button button) {
        Console.WriteLine("Window.Button");
    }
}

class NotAButtonButCanBeCastedToAButton {
    public static implicit operator Button(
        NotAButtonButCanBeCastedToAButton nab
    ) {
        return new Button();
    }
}

class NotAButtonButMustBeCastedToAButton {
    public static explicit operator Button(
        NotAButtonButMustBeCastedToAButton nab
    ) {
        return new Button();
    }
}

static class WindowExtensions {
    public static void Display(this Window window, object o) {
        Console.WriteLine("WindowExtensions.Button: {0}", o.ToString());
        Button button = BlahBlah(o);
        window.Display(button);
    }
    public static Button BlahBlah(object o) {
        return new Button();
    }
}

class Program {
    static void Main(string[] args) {
        Window w = new Window();
        object o = new object();
        w.Display(o); // extension
        int i = 17;
        w.Display(i); // extension
        string s = "Hello, world!";
        w.Display(s); // extension
        Button b = new Button();
        w.Display(b); // instance
        var nab = new NotAButtonButCanBeCastedToAButton();
        w.Display(b); // implicit cast so instance
        var nabexplict = new NotAButtonButMustBeCastedToAButton();
        w.Display(nabexplict); // only explicit cast so extension
        w.Display((Button)nabexplict); // explictly casted so instance
    }
}

这将打印

WindowExtensions.Button: System.Object
Window.Button
WindowExtensions.Button: 17
Window.Button
WindowExtensions.Button: Hello, world!
Window.Button
Window.Button
Window.Button
WindowExtensions.Button: NotAButtonButMustBeCastedToAButton
Window.Button
Window.Button

在控制台上。

Answer 2

这是可能的，尽管您必须小心重载的参数 - 通常最好避免 object 类型，因为这通常会导致代码混乱。您可能会犯下 C# 选择重载的有趣方式。它将选择一种“更接近”的匹配类型，该类型可以隐式转换为具有完全匹配的“进一步”匹配类型（请参阅此问题）。

Button myButton = // get button
Window currentWindow = // get window

// which method is called here?
currentWindow.Display( myButton );

您希望您的代码相当清晰，尤其是在一年左右返回此代码时，正在调用什么重载。

扩展方法提供了一种非常优雅的方式来扩展对象的功能。您可以添加它最初没有的行为。不过，您必须小心使用它们，因为它们很容易创建令人困惑的代码。最佳实践是避免已使用的方法名称，即使它们是明显的重载，因为它们不会出现在智能感知中的类之后。

这里的问题似乎是扩展方法可以隐式地将按钮转换为对象，因此选择自身作为最佳匹配，而不是实际的显示方法。您可以像普通静态调用一样显式调用扩展方法，但不能强制它调用基础类的方法。

我会更改扩展方法的名称：

object somethingToMakeIntoAButton = // get object
Window currentWindow = // get window

// which method is called here?
currentWindow.DisplayButton( somethingToMakeIntoAButton );

然后...

class WindowExtensions 
{
    public void DisplayButton(this Window window, object o) 
    {
        Button button = BlahBlah(o);

        // now it's clear to the C# compiler and human readers
        // that you want the instance method
        window.Display(button);
    }
}

或者，如果扩展方法上的第二个参数是无法从 Button 隐式转换为的类型（例如 int< /code> 或 string）这种混乱也不会发生。

Answer 3

这应该可行，编译器几乎总是会选择具有可接受签名的实例方法，而不是具有确切签名的扩展方法。

根据这篇文章：

具有可接受的实例方法
使用加宽转换的签名
几乎总是会优先于
具有精确的扩展方法
签名匹配。如果这导致
绑定到实例方法时
您确实想使用该扩展程序
方法，您可以显式调用
使用共享的扩展方法
方法调用约定。这是
也是消除两个歧义的方法
方法，当两者都不更具体时。

您确定要明确传递一个按钮吗？

或者是 void Display(Button button) 递归调用自身？

Answer 4

嗯，我相信这有点棘手。如果您将 Button 作为方法参数传递：

Button button = BlahBlah(o);
window.Display(button);

那么就有合适的类方法，该方法始终优先于扩展方法。

但是，如果您传递的对象不是 Button，则没有合适的类方法，并且将调用扩展方法。

var o = new object();
window.Display(o);

因此，从我看来，您的示例应该可以正常工作，并且扩展方法将调用 Window 实例上的 Display 方法。无限循环可能是由其他一些代码引起的。

示例中包含 Display 方法的 Window 类和作为扩展方法参数的 Window 类是否有可能实际上是两个不同的类？

Answer 5

这是不可能的（另请参阅 Monkeypatching For Humans） - 也许使用 DLR 和 method_missing。