blocks|key|5802603|text|这是不可能的(另请参阅Monkeypatching+For+Humans)+-也许使用DLR和method_missing。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|5802604|entityMap|0|LINK|mutability|MUTABLE|url|https://blog.codinghorror.com/monkeypatching-for-humans/^0|1B|E|B|P|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]]|D|@$9|Q|A|R|1|S]]|E|$]]|$1|F|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]]]

It's not possible (also see <a href="https://blog.codinghorror.com/monkeypatching-for-humans/" rel="nofollow noreferrer">Monkeypatching For Humans</a>) - maybe with DLR and <code>method_missing</code>.

blocks|key|2459802|text|让我们来看看规范。首先，我们必须了解方法调用的规则。粗略地说，您可以从尝试调用方法的实例所指示的类型开始。你沿着继承链向上走，寻找可访问的方法。然后，执行类型推断和重载解析规则，并在成功时调用该方法。只有当找不到这样的方法时，您才会尝试将该方法作为扩展方法处理。因此，从§7.5.5.2+(扩展方法调用)中可以看到，特别是加粗的语句：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2459803|其中一个表单的方法调用(§7.5.5.1)中的|2459804|blockquote|2459805|2459806|expr.identifier()|offset|length|style|CODE|2459807|expr.identifier(args)|2459808|expr.identifier<typeargs>()|2459809|expr.identifier<typeargs>(args)|2459810|如果调用的正常处理没有找到适用的方法，则会尝试将该构造作为扩展方法调用进行处理。|BOLD|2459811|2459812|除此之外的规则有点复杂，但对于您向我们介绍的简单案例来说，它非常简单。如果没有适用的实例方法，则将调用扩展方法WindowExtensions.Display(Window,+object)。如果Window.Display的参数是一个按钮，或者是可以隐式转换为按钮的，则可以使用instance方法。否则，将调用扩展方法(因为从object派生的所有内容都可以隐式转换为object)。|2459813|所以，除非你遗漏了一些重要的东西，否则你正在尝试做的事情将会奏效。|2459814|因此，考虑以下示例：|2459815|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
++++}
}|code-block|syntax|javascript|2459816|这将打印出来|2459817|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|2459818|在控制台上。|2459819|entityMap^0|0|0|0|0|0|H|0|0|L|0|0|R|0|0|V|0|0|Z|0|0|1J|14|2Q|E|4L|6|56|6|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|E|7|1H|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|1I|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|1J|8|@$I|1K|J|1L|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|1M|8|@$I|1N|J|1O|K|L]]|9|@]|A|$]]|$1|O|3|P|5|6|7|1P|8|@$I|1Q|J|1R|K|L]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1S|8|@$I|1T|J|1U|K|L]]|9|@]|A|$]]|$1|S|3|T|5|6|7|1V|8|@$I|1W|J|1X|K|U]]|9|@]|A|$]]|$1|V|3|-4|5|6|7|1Y|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1Z|8|@$I|20|J|21|K|L]|$I|22|J|23|K|L]|$I|24|J|25|K|L]|$I|26|J|27|K|L]]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|28|8|@]|9|@]|A|$]]|$1|10|3|11|5|6|7|29|8|@]|9|@]|A|$]]|$1|12|3|13|5|14|7|2A|8|@]|9|@]|A|$15|16]]|$1|17|3|18|5|6|7|2B|8|@]|9|@]|A|$]]|$1|19|3|1A|5|14|7|2C|8|@]|9|@]|A|$15|16]]|$1|1B|3|1C|5|6|7|2D|8|@]|9|@]|A|$]]|$1|1D|3|-4|5|6|7|2E|8|@]|9|@]|A|$]]]|1E|$]]

Let's go to the specification. First, we have to understand the rules for method invocations. Roughly, you start with the type indicated by the instance you are trying to invoke a method on. You walk up the inheritance chain looking for an accessible method. Then you do your type inference and overload resolution rules and invoke the method if that succeeds. Only if no such method is found do you try to process the method as an extension method. So from §7.5.5.2 (Extension method invocations) see, in particular, the bolded statement:
<blockquote>
In a method invocation (§7.5.5.1) of one of the forms
<code>expr.identifier()</code>
<code>expr.identifier(args)</code>
<code>expr.identifier&lt;typeargs&gt;()</code>
<code>expr.identifier&lt;typeargs&gt;(args)</code>
if the normal processing of the invocation finds no applicable methods, an attempt is made to process the construct as an extension method invocation.
</blockquote>
The rules beyond that get a little complicated, but for the simple case you've presented to us it's quite simple. If there is no applicable instance method then the extension method <code>WindowExtensions.Display(Window, object)</code> will be invoked. The instance method is applicable if the parameter to <code>Window.Display</code> is a button or is implicitly castable to a button. Otherwise, the extension method will be invoked (because everything that derives from <code>object</code> is implicitly castable to an <code>object</code>).
So, unless there is an important bit that you are leaving out, what you are trying to do will work.
So, consider the following example:
<pre><code>class Button { }
class Window {
 public void Display(Button button) {
 Console.WriteLine(&quot;Window.Button&quot;);
 }
}

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(&quot;WindowExtensions.Button: {0}&quot;, 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 = &quot;Hello, world!&quot;;
 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
 }
}
</code></pre>
This will print
<pre><code>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
</code></pre>
on the console.

blocks|key|2466535|text|这应该是可行的，编译器几乎总是会选择具有可接受签名的实例方法，而不是具有确切签名的扩展方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2466536|根据这个article|offset|length|2466537|使用扩展转换的具有可接受签名的实例方法|2466538|几乎总是优先于具有精确签名匹配的扩展方法。如果这导致在您确实想使用扩展方法时绑定到实例方法，则可以使用共享方法调用约定显式调用扩展方法。当两种方法都不是很具体时，这也是消除两种方法歧义的方法。|blockquote|2466539|2466540|2466541|您确定要显式传递一个Button吗？|2466542|或者void+Display(Button+button)正在递归地调用自己？|style|CODE|2466543|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/magazine/cc163317.aspx#S4^0|0|4|7|0|0|0|0|0|0|0|2|R|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@]|9|@$D|12|E|13|1|14]]|A|$]]|$1|F|3|G|5|6|7|15|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|16|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|17|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|18|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|19|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1A|8|@$D|1B|E|1C|Q|R]]|9|@]|A|$]]|$1|S|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|Z]]]]

That should work, the compiler will almost always pick an instance method with an acceptable signature over an extension method with the exact signature.

According to this <a href="http://msdn.microsoft.com/en-us/magazine/cc163317.aspx#S4" rel="nofollow noreferrer">article</a>:

<blockquote>
 An instance method with an acceptable
 signature using widening conversion
 will almost always be preferred over
 an extension method with an exact
 signature match. If this results in
 binding to the instance method when
 you really want to use the extension
 method, you can explicitly call the
 extension method using the shared
 method calling convention. This is
 also the way to disambiguate two
 methods when neither is more specific.
</blockquote>

Are you sure you're explicitly passing a Button?

Or is <code>void Display(Button button)</code> recursively calling itself?

blocks|key|5802704|text|好吧，我觉得这有点棘手。如果将Button作为方法参数传递：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|5802705|Button+button+=+BlahBlah(o);
window.Display(button);|code-block|syntax|javascript|5802706|然后是适当的类方法，它总是优先于扩展方法。|5802707|但是如果你传递的对象不是Button，那么就没有合适的类方法，扩展方法就会被调用。|5802708|var+o+=+new+object();
window.Display(o);|5802709|因此，在我看来，您的示例应该可以正常工作，并且扩展方法将调用Window实例上的Display方法。无限循环可能是由其他一些代码引起的。|5802710|在您的示例中包含Display方法的Window类和作为扩展方法的参数的Window类实际上是否可能是两个不同的类？|5802711|entityMap^0|F|6|0|0|0|C|6|0|0|U|6|14|7|0|8|7|I|6|10|6|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|10|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|11|8|@$9|12|A|13|B|C]]|D|@]|E|$]]|$1|O|3|P|5|H|7|14|8|@]|D|@]|E|$I|J]]|$1|Q|3|R|5|6|7|15|8|@$9|16|A|17|B|C]|$9|18|A|19|B|C]]|D|@]|E|$]]|$1|S|3|T|5|6|7|1A|8|@$9|1B|A|1C|B|C]|$9|1D|A|1E|B|C]|$9|1F|A|1G|B|C]]|D|@]|E|$]]|$1|U|3|-4|5|6|7|1H|8|@]|D|@]|E|$]]]|V|$]]

Well, I believe this is a little tricky. If you pass <code>Button</code> as a method parameter:

<pre><code>Button button = BlahBlah(o);
window.Display(button);
</code></pre>

then there is suitable class method which always takes precedence over the extension method.

But if you pass object that is not <code>Button</code> then there is no suitable class method and extension method will be invoked.

<pre><code>var o = new object();
window.Display(o);
</code></pre>

So, from what I see, your example should work correctly and extension method will call <code>Display</code> method on the <code>Window</code> instance. The infinite loop might be caused by some other code.

Is there any chance that <code>Window</code> class containing <code>Display</code> method in your example and <code>Window</code> class that is a parameter to the extension method are actually two different classes?

blocks|key|5802735|text|这是可能的，尽管您必须小心重载上的参数-避免使用object类型通常是一个好主意，因为这通常会导致代码混乱。你可能会与C#挑选重载的有趣方式发生冲突。它将选择与可以隐式转换为的类型的“更接近”匹配，而不是具有精确匹配的“进一步”匹配(请参阅this+question)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|5802736|Button+myButton+=+//+get+button
Window+currentWindow+=+//+get+window

//+which+method+is+called+here?
currentWindow.Display(+myButton+);|code-block|syntax|javascript|5802737|您希望您的代码相当清晰，特别是当在一年左右的时间内返回到此代码时，将调用什么重载。|5802738|扩展方法提供了一种非常优雅的方式来扩展对象的功能。您可以添加它最初没有的行为。不过，您必须小心使用它们，因为它们很容易创建令人困惑的代码。最佳实践是避免已经使用的方法名称，即使它们是明确的重载，因为它们不会显示在intellisense中的类之后。|5802739|这里的问题似乎是扩展方法可以隐式地将按钮转换为对象，因此选择自己作为最佳匹配，而不是实际的显示方法。您可以将扩展方法作为普通静态调用显式调用，但不能强制它调用底层类的方法。|5802740|我将更改扩展方法的名称：|5802741|object+somethingToMakeIntoAButton+=+//+get+object
Window+currentWindow+=+//+get+window

//+which+method+is+called+here?
currentWindow.DisplayButton(+somethingToMakeIntoAButton+);|5802742|然后..。|5802743|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);
++++}
}|5802744|或者，如果扩展方法上的第二个参数是不能从Button隐式转换为的类型(比如int或string)，这种混淆也不会发生。|5802745|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/154112^0|O|6|3C|D|0|0|0|0|0|0|0|0|0|0|K|6|11|3|15|6|0^^$0|@$1|2|3|4|5|6|7|18|8|@$9|19|A|1A|B|C]]|D|@$9|1B|A|1C|1|1D]]|E|$]]|$1|F|3|G|5|H|7|1E|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1F|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|1G|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|1H|8|@]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1I|8|@]|D|@]|E|$]]|$1|S|3|T|5|H|7|1J|8|@]|D|@]|E|$I|J]]|$1|U|3|V|5|6|7|1K|8|@]|D|@]|E|$]]|$1|W|3|X|5|H|7|1L|8|@]|D|@]|E|$I|J]]|$1|Y|3|Z|5|6|7|1M|8|@$9|1N|A|1O|B|C]|$9|1P|A|1Q|B|C]|$9|1R|A|1S|B|C]]|D|@]|E|$]]|$1|10|3|-4|5|6|7|1T|8|@]|D|@]|E|$]]]|11|$12|$5|13|14|15|E|$16|17]]]]

It is possible, although you have to be careful with the parameters on overloads - it's usually a good idea to avoid <code>object</code> types as that often causes confusing code. You can fall foul of the funny way C# picks overloads. It will choose a 'closer' match with types that can be implicitly cast to over a 'further' one that has exact matches (see <a href="https://stackoverflow.com/questions/154112">this question</a>).

<pre><code>Button myButton = // get button
Window currentWindow = // get window

// which method is called here?
currentWindow.Display( myButton );
</code></pre>

You want your code to be fairly clear, especially when returning to this code in a year or so, what overload is being called.

Extension methods provide a really elegant way to expand the functionality of objects. You can add behaviour that it didn't have originally. You have to be careful with them though, as they're very prone to creating confusing code. It's best practice to avoid method names already used, even if they are clear overloads, as they don't show up after the class in intellisense.

Here the problem appears to be that the extension method can implicitly convert your button to an object, and so picks itself as the best match, instead of the actual display method. You can explicitly call the extension method as a normal static call, but you can't force it to call the underlying class's method.

I would change the name of the extension method:

<pre><code>object somethingToMakeIntoAButton = // get object
Window currentWindow = // get window

// which method is called here?
currentWindow.DisplayButton( somethingToMakeIntoAButton );
</code></pre>

Then...

<pre><code>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);
 }
}
</code></pre>

Alternatively if the second parameter on the extension method was a type that couldn't be implicitly converted to from <code>Button</code> (say <code>int</code> or <code>string</code>) this confusion wouldn't happen either.

Having a class that has a method, like this:

<pre><code>class Window {
 public void Display(Button button) {
 // ...
 }
}
</code></pre>

is it possible to overload the method with another one that is more broad, like this:

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

What happened when I tried is that I have infinite recursion. Is there a way to make that work? I want the extension method to be called only when the other method can't be called.

Extension methods overloading in C#, does it work?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

拥有一个具有方法的类，如下所示：class Window {    public void Display(Button button) {        // ...    }}是否可以用另一个更宽泛的方法重载该方法，如下所示：class WindowExtensions {    public void Displ...

问C#中的扩展方法重载，它能工作吗？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C#中的扩展方法重载，它能工作吗？EN