Implicit conversion from lambda expression to user-defined type

Question

I want to define an implicit conversion from (specific) lambda expressions to a user-defined type. I tried the following:

public static implicit operator DualElement<T>(Func<OPTatom, OPTatom, T> atomMap)
{
    return new DualElement<T>(e => atomMap(e[0],e[1]));
}

Then I tried

DualElement<double> dubidu = (i, j) => cost[i, j];

which gives "Cannot convert lambda expression ... because it is not a delegate type"

Instead, what works is:

DualElement<double> dideldu = (Func<OPTatom, OPTatom, double>)((i, j) => cost[i, j]);

I guess, lambda expressions do not have the type 'Func' so that I have to put something different into the implicit conversion.

Can somebody give me a hint?

@Sajjad: I have different lambda expressions which "mean" to be a function from an element of type OPTelement to T. My aim is to convert them implicitly to the same type so that I do not have to overload every method depending on where the DualElement came from. — J Fabian Meier, Apr 28 '15 at 11:14

score 7 · Accepted Answer · answered Apr 28 '15 at 10:50

7

Your workaround is pretty good.
Lambdas have no type in themselves, so they should be casted to some appropriate type.
Please see MSDN:

Note that lambda expressions in themselves do not have a type because the common type system has no intrinsic concept of "lambda expression." However, it is sometimes convenient to speak informally of the "type" of a lambda expression. In these cases the type refers to the delegate type or Expression type to which the lambda expression is converted.

This is why the following example won't compile:

var func = (i, j) => i + j;

answered Apr 28 '15 at 10:50

Dmitry

13,797
6
32
48

@JenishRabadiya I thought OP is trying to assign *lambda* to `DualElement`. But the lambdas have no type. Therefore preliminary converting lambda into `Func` helps. And my sample won't compile, try it yourself. – Dmitry Apr 28 '15 at 11:00
@JenishRabadiya Actually the OP wants to instantiate a `DualElement` by using an implicit operator, just as in Linq-to-XML you can use `XName foo = "bar"`. – Dirk Apr 28 '15 at 11:06
Does it mean that an implicit conversion from a lambda expression to some other type is impossible in C#? – J Fabian Meier Apr 28 '15 at 11:09
@JFMeier No, it is possible in C#, but not in the cast operator overload, since the compiler cannot determine the right type of lambda. Imagine that you have two different cast operators for two different delegate types with the same signature. Lambda can be casted to any of these delegate type. Which one to use? – Dmitry Apr 28 '15 at 11:22

Jenish Rabadiya · Answer 2 · 2015-04-28T11:53:19.647

You have defined implicit operator from Func<OPTatom, OPTatom, T> delegate type and trying to conversion from lambda expression which seems strange to C# compiler.

Instead store the lambda expression in some variable of type Func<OPTatom, OPTatom, T> and then perform implicit conversion. following will work here:

Func<OPTatom, OPTatom, T> temp = (i, j) => cost[i, j];
DualElement<double> dubidu = temp;

I created demo and it worked fine.

public class Program
{
    public static void Main()
    {
        Func<string, bool> func = d => true;
        Process<bool> p = func;
        //Process<bool> p = d => true; would result in error
    }
}

public class Process<T>
{
    public Process(T item)
    {
        Item = item;
    }

    public T Item
    {
        get;
        set;
    }

    public static implicit operator Process<T>(Func<string, T> func)
    {
        return new Process<T>(func("jenish"));
    }
}

Here is dotnetfiddle link in case you want to play with it.

Thank you. But my original aim was to use different lambda expressions as parameters of methods. At the moment, I write four overloaded methods for each method consuming a DualElement because I want an easy way of usage for the methods (in terms of lambda expressions). I tried to avoid this quadrupling but obviously, it is not possible to do so. — J Fabian Meier, Apr 28 '15 at 13:16

Implicit conversion from lambda expression to user-defined type

2 Answers2

Linked