使用 Func<> 将 Delegate 对象传递给方法范围

发布于 2024-08-09 14:43:47 字数 638 浏览 5 评论 0 原文

我有一个方法 Foo4,它接受 Func<> 类型的参数。如果我传递匿名类型的参数,则不会出现错误。但是,如果我创建并传递引用具有正确签名的方法的“委托”类型的对象,则会出现编译器错误。我无法理解为什么在这种情况下会出现错误。

class Learn6
    {
        delegate string Mydelegate(int a);
        public void Start()
        {
            Mydelegate objMydelegate = new Mydelegate(Foo1);

            //No Error
            Foo4(delegate(int s) { return s.ToString(); });

            //This line gives compiler error.
            Foo4(objMydelegate);

        }

        public string Foo1(int a) { return a.ToString();}



        public void Foo4(Func<int, string> F) { Console.WriteLine(F(42)); }
    }

I have a method Foo4 that accepts a parameter of the type Func<>. If I pass a parameter of anonymous type , I get no error. But if I create and pass an object of the type 'delegate' that references to a Method with correct signature, I get compiler error. I am not able to understand why I am getting error in this case.

class Learn6
    {
        delegate string Mydelegate(int a);
        public void Start()
        {
            Mydelegate objMydelegate = new Mydelegate(Foo1);

            //No Error
            Foo4(delegate(int s) { return s.ToString(); });

            //This line gives compiler error.
            Foo4(objMydelegate);

        }

        public string Foo1(int a) { return a.ToString();}



        public void Foo4(Func<int, string> F) { Console.WriteLine(F(42)); }
    }

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

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

发布评论

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

评论(4

烏雲後面有陽光 2024-08-16 14:43:47

如果直接传递对该方法的引用,它会起作用:

Foo4(Foo1);

这是因为具有相同形状的实际委托本质上并不被认为是兼容的。如果契约是隐式的,编译器会推断契约并将它们匹配。如果它们是显式的(例如声明的类型),则不会执行任何推断 - 它们只是不同的类型。

它类似于:

public class Foo
{
    public string Property {get;set;}
}

public class Bar
{
    public string Property {get;set;}
}

我们可以看到两个类具有相同的签名并且“兼容”,但编译器将它们视为两种不同的类型,仅此而已。

It works if you pass a reference to the method directly:

Foo4(Foo1);

This is because actual delegates with the same shape are not inherently considered compatible. If the contracts are implicit, the compiler infers the contract and matches them up. If they are explicit (e.g. declared types) no inference is performed - they are simply different types.

It is similar to:

public class Foo
{
    public string Property {get;set;}
}

public class Bar
{
    public string Property {get;set;}
}

We can see the two classes have the same signature and are "compatible", but the compiler sees them as two different types, and nothing more.

不念旧人 2024-08-16 14:43:47

因为 FuncMyDelegate 是不同的声明类型。它们恰好兼容同一套方法;但它们之间没有隐式转换。

Because Func<int, string> and MyDelegate are different declared types. They happen to be compatible with the same set of methods; but there is no implicit conversion between them.

心不设防 2024-08-16 14:43:47
        //This line gives compiler error.
        Foo4(objMydelegate);

        //This works ok.
        Foo4(objMydelegate.Invoke);
        //This line gives compiler error.
        Foo4(objMydelegate);

        //This works ok.
        Foo4(objMydelegate.Invoke);
じее 2024-08-16 14:43:47

取决于场景,但一般情况下没有理由保留 Mydelegate 类型,只需使用 Func 即可。到处都是:)

depends on the scenario, but in the general case there's no reason to keep around the Mydelegate type, just use Func<int, string> everywhere :)

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