How to implicitly convert lambda expressions to types

[RRQM]

Demand

I have an asynchronous callback delegate that I want people to use can use asynchronous lambda expressions for assignments, as well as synchronous lambda expressions for assignments. This avoids the hassle of returning a Task.CompletedTask if there is only synchronous code in the asynchronous lambda expression.

Code base

First, I wrapped an asynchronous delegate with a struct,

Then you can assign a value to the asynchronous delegate in the constructor, and at the same time overload a constructor that converts the synchronous delegate to asynchronous.

Finally, using implicit conversion, it is hoped that synchronous and asynchronous delegates can be directly converted into this struct.

The basic code is as follows:

struct TaskDelegate
{
    public TaskDelegate(Action<int> action)
    {
        Task Action(int a)
        {
            action.Invoke(a);
            return Task.CompletedTask;
        }

        this.TaskProperty = Action;
    }

    public TaskDelegate(Func<int, Task> func)
    {
        this.TaskProperty = func;
    }

    public Func<int, Task> TaskProperty { get; set; }

    public static implicit operator TaskDelegate(Action<int> action)
    {
        return new TaskDelegate(action);
    }

    public static implicit operator TaskDelegate(Func<int, Task> func)
    {
        return new TaskDelegate(func);
    }
}

Then when using, I declare a usage class object with the following code:

class MyClass
{
    public TaskDelegate MyDelegate { get; set; }
}

Then, you can use it like this:

MyClass myClass = new MyClass(); 
myClass.MyDelegate = (int a) => { };//Synchronize lambdas
myClass.MyDelegate =  (int a) => Task.CompletedTask;//Asynchronous lambdas

But it actually failed.

Issue

Why is the following code successful?

MyClass myClass = new MyClass(); 

var action=(int a) => { };//Synchronize lambdas
myClass.MyDelegate = action;

var func=(int a) => Task.CompletedTask;//Asynchronous lambdas
myClass.MyDelegate =  func;

And the direct assignment fails?

MyClass myClass = new MyClass(); 
myClass.MyDelegate = (int a) => { };//Synchronize lambdas
myClass.MyDelegate =  (int a) => Task.CompletedTask;//Asynchronous lambdas

Suggestion

I think that it can be var from (int a) = > { }; Inferring the action of type var means that the compiler can derive it, so why can't it be implicitly converted and assigned after derivation?

This feels like a problem that can be solved, and I hope that the government will pay attention to it and solve it.

Or it would be nice if it fundamentally solved the problem that asynchronous delegates can assign synchronous methods.

[HaloFour]

Lambda expressions are target typed. In this case, the target type is the TaskDelegate struct, which is not a delegate, so the compiler doesn't know what type to make the delegate. It wasn't designed to consider that the target type might have implicit conversion operators from delegate types, and to use those intermediate delegate types to inform the delegate type inference.

[RRQM]

So I'm wondering if I can analyze it a little bit more, and if there is an implicit conversion, can it be directly deduced. Or a new feature that makes the conversion work as well.

[colejohnson66]

Could the "natural types" of delegates (Action/Func) be employed (in the future) to guide the compiler to choose one of the implicit conversion operators?

@RRQM The best option you have now is to assign the lambda to a properly typed local variable, then assign the property.

Func<int, Task> x = (int _) => Task.CompletedTask;
myClass.MyDelegate = x;

Alternatively, you can have a method that sets the delegate:

myClass.SetMyDelegate((int a) => Task.CompletedTask);

[RRQM]

@colejohnson66 Thank you for your suggestion, but in fact, I have tried this operation before, but it cannot replace the effect of direct assignment in terms of user experience. For now, let's just use an asynchronous delegate directly. I hope the official can solve this problem in the future.