[Suggestion] Method local Task variables accessible in runtime

[SuprOrel]

Essentially i'm asking to access variables in the async return type inside of the method.
So it looks something like this with Task.

public static async Task Something(int num)
{
    if(this.Status == Somethin) ...;
}

That use is just to explain the concept its actual use will work with classes, something like so.

[MyTaskMethodBuilder]
public class MyTask<T>
{
    public MyTask(Func<Task<T>> func) { } // it would be nice to have something like this instead of taskmethodbuilder where you just get the function in here instead of deal with AsyncTaskMethodBuilder, this way you could also wrap task by giving base func

    public int MyNum = 0;
}

public static async MyTask Something(int myNum)
{
    this.MyNum = myNum;
    for(; MyNum < 10; MyNum++)
    {
        Task.Delay(1000);
        ...
     }
}

This will allow you to interact with the task as its running for example

MyTask work = Something(5);
work.MyNum = 0; // resets the loop

Itll also allow you to reuse tools on other async functions such as adding a DateTime Started variable and setting it in the constructor as well as better extension methods in a task wrapper.

This pretty much replaces the need for AsyncLocal or ThreadLocal since itll be far easier to manage and i assume better performance if AsyncLocal and ThreadLocal actually have to search for the current thread id while this is just standard class variables no different from any other like IsCompleted. (This could also be used to alternate CancellationToken by just having a cancel variable on tasks)

Here's an example where this is necessary.

public class MyTask
{
    public int Speed = 1;
    private DateTime last = DateTime.Now;
    public Task Delay(int miliseconds)
    {
        DateTime latest = DateTime.Now;
        int catchup = (int)(latest - last).TotalMilliseconds;
        last = latest;
        return Task.Delay(miliseconds * speed - catchup);
    }
}

This implements a custom delay method with its usefulness being in scripted animations (came up with it for a video game) allowing you to speed up all MyTask animations by having their own speed variable and make them look smoother by catching up on the actual animation's runtime through calculating it from the last time called.

[chucker]

(Please consider editing your post to enable syntax highlighting.)

I think what you're asking here is some kind of syntactical sugar to supply a Task with public member variables, which are internally treated as AsyncLocal fields?

[HaloFour]

I'd need to hear some more use cases for something like this. Writing custom task types seems pretty niche already so a feature targeting specific custom task types would be doubly-so.

Also, anything that encourages exposing mutable state in an asynchronous context seems like a big no-no.

[SuprOrel]

(Please consider editing your post to enable syntax highlighting.)

I think what you're asking here is some kind of syntactical sugar to supply a Task with public member variables, which are internally treated as AsyncLocal fields?

Kinda yes. Thing is if MyNum was actually an AsyncLocal field it would also apply to all functions within Something() so if i called another function they'd have the same MyNum which isn't what i want. I want MyNum to be independent for every MyTask function. For example this is necessary for the use i just edited into the post