casting delegate

Question

I'm pretty new to c#, so my question might be simple, but here goes.

I've have been trying to work with delegates, and is kinda stuck with this problem.

.....
    public delegate double delegateA();
    public delegate double delegateB();

    public static double myFunc()
    {
        return 0;
    }
    public static delegateA myTest()
    {
        return myFunc;
    }

    static void Main(string[] args)
    {
        delegateB myFuncDelegate;

        myFuncDelegate = myTest();  // <-- Error: Cannot implicitly convert type....
    }
.....

I don't know how to make this conversion work, unless using the same delegate as type. But in my project, it would be more pretty for the delegate's to have different names (as they exist in different classes.

Hope you can help me.

What version of C# are you using? A modern variation of your code would be `Func`. — Kobi, Aug 12 '10 at 06:13

score 35 · Accepted Answer · answered Aug 12 '10 at 06:15

You can't convert between delegates like that directly. What you can do is make a new delegate from an existing, compatible one. So if you change your code to:

 delegateB myFuncDelegate = new delegateB(myTest());

that will work. (Note that "compatibility" doesn't necessarily meant that the signatures are identical - see the language specification for details.)

Just to make this slightly clearer to other readers, here's a simpler complete example, which doesn't need any method calls.

// Two delegate types with the same signature
delegate void Foo();
delegate void Bar();

class Test
{
    static void Main()
    {
        // Actual value is irrelevant here
        Foo foo = null;

        // Error: can't convert like this
        // Bar bar = foo;

        // This works fine
        Bar bar = new Bar(foo);
    }
}

Note that there's one exception to this "no conversions" rule - generic variance in C# 4. For example, in C# 4 you can write:

 Action<object> foo = x => Console.WriteLine(x.GetHashCode());
 Action<string> bar = foo;

... because Action<T> is contravariant in T (so it's actually declared as Action<in T>). This is a reference conversion - it doesn't create a new delegate like the first sample does. However, this isn't available for merely "compatible" delegates - only generic ones.

Note that this produces a delegate whose target is the Invoke method of the first delegate, a level of indirection you might not want. See http://stackoverflow.com/a/9290684/497397 and surrounding discussion for how to get a new delegate that refers directly to the original target. — Ian Griffiths, Feb 15 '12 at 14:09

score 6 · Answer 2 · answered Dec 04 '13 at 20:07

Also, not exactly what you asked about, but interestingly -- this doesn't work:

Func<double> func_double = () => 1;
Func<object> func_object;

func_object = func_double;

But this does:

Func<string> func_string = () => "hello";
Func<object> func_object;

func_object = func_string;

Difference being the string example is using reference types which can cast to an object, while a double must be boxed thereby blocking a direct cast

casting delegate

2 Answers2

Linked

Related