为什么我们需要在 od 扩展方法中进行显式转换,而不是在静态方法中进行转换?

发布于 2025-01-06 05:47:58 字数 63 浏览 1 评论 0原文

为什么扩展方法不使用隐式转换,而静态方法却使用隐式转换?有人可以用一个正确的例子来解释吗?

谢谢

Why Extension methods do not use implicit conversions but static methods do? Can anybody explain with a proper example?

Thanks

如果你对这篇内容有疑问,欢迎到本站社区发帖提问 参与讨论,获取更多帮助,或者扫码二维码加入 Web 技术交流群。

扫码二维码加入Web技术交流群

发布评论

需要 登录 才能够评论, 你可以免费 注册 一个本站的账号。

评论(1

孤独患者 2025-01-13 05:47:58

因为 C# 规范规定:

扩展方法 Ci.Mj 符合条件,如果:

· Ci 是一个非泛型、非嵌套类

· Mj 的名字是标识符

· Mj 在应用于
参数作为静态方法,如上所示

· 存在隐式标识、引用或装箱转换
从 expr 到 Mj 第一个参数的类型。

就 C# 规范而言,用户定义的转换运算符不同于隐式引用转换,当然也不同于标识或装箱转换。

有关原因的提示:

public static class Extensions
{
    public static void DoSomething(this Bar b)
    {
        Console.Out.WriteLine("Some bar");
    }

    public static void DoSomething(this Boo b)
    {
        Console.Out.WriteLine("Some boo");
    }
}

public class Foo
{
    public static implicit operator Bar(Foo f)
    {
        return new Bar();
    }
    public static implicit operator Boo(Foo f)
    {
        return new Boo();
    }
}

public class Bar { }
public class Boo { }

public class Application
{
    private Foo f;
    public void DoWork()
    {
        // What would you expect to happen here?
        f.DoSomething();

        // Incidentally, this doesn't compile either:
        Extensions.DoSomething(f);
    }
}

C# 无法明确选择要执行的隐式转换。

Because the C# spec states:

An extension method Ci.Mj is eligible if:

· Ci is a non-generic, non-nested class

· The name of Mj is identifier

· Mj is accessible and applicable when applied to the
arguments as a static method as shown above

· An implicit identity, reference or boxing conversion exists
from expr to the type of the first parameter of Mj.

As far as the C# spec is concerned, a user-defined conversion operator is different than an implicit reference conversion, and certainly different than an identity or boxing conversion.

For a hint on why:

public static class Extensions
{
    public static void DoSomething(this Bar b)
    {
        Console.Out.WriteLine("Some bar");
    }

    public static void DoSomething(this Boo b)
    {
        Console.Out.WriteLine("Some boo");
    }
}

public class Foo
{
    public static implicit operator Bar(Foo f)
    {
        return new Bar();
    }
    public static implicit operator Boo(Foo f)
    {
        return new Boo();
    }
}

public class Bar { }
public class Boo { }

public class Application
{
    private Foo f;
    public void DoWork()
    {
        // What would you expect to happen here?
        f.DoSomething();

        // Incidentally, this doesn't compile either:
        Extensions.DoSomething(f);
    }
}

C# could not unambiguously choose which implicit conversion to execute.

~没有更多了~
我们使用 Cookies 和其他技术来定制您的体验包括您的登录状态等。通过阅读我们的 隐私政策 了解更多相关信息。 单击 接受 或继续使用网站,即表示您同意使用 Cookies 和您的相关数据。
原文