async code block

[ctigrisht]

Would it be possible to add an async statement directly, not bound to anything, such as in this example

void RunFunc(){
    //async block, runs a delegate or action asynchronously in main code 
    async{
        await var data = Db.QueryAsync(filter);
        foreach(var i in data) Console.WriteLine(JsonSerialize(i));
    }
    
    //async block with result, basically makes a task
    var task = async {
        return Db.QuerySync(filter);
    }
}

async{ } would basically put the delegate/action in a Task.Run at runtime

it would open code possibilities as such

if (someInt > 1000) async {
                DoSmtSync();
            } else async {
                DoSmtElseSync();
            }
foreach (var i in Collection) async {
                DoSmtSync(i);
            }

[yaakov-h]

What would it do that can't be achieved with Task.Run?

[ctigrisht]

because i would want to write less code everytime i want to do something async
this could be a shortcut to Task.Run(delegate{}) and would provide "cleaner" code in my opinion

also for long running tasks, you could do as such

void Smt(){
    thread {
        //do heavy things
        async { /*do other things*/  }
    }
}

this would remove a lot of the brackets needed

[HaloFour]

The async keyword in C# very intentionally does not start another thread.

[ctigrisht]

The async keyword in C# very intentionally does not start another thread.

i'm not proposing that it should start a new thread, i'm saying that Task.Run(delegate{}) could have a shortcut => async {}
even if the keyword is delegate{} then i think it should be run async without the need to put it in a Task.Run, task options would be set to default

[HaloFour]

Task.Run results on the task executing on a different thread. That's not a behavior that should be encouraged, it's generally the wrong thing to do, especially in async code. And it's not like calling Task.Run is overly verbose, this would at most save 10 keystrokes.

[ctigrisht]

well i was saying this because it would look better and be faster to code, not saying "change how tasks and threads work"

just adding the option of doing such =>

         static void LongRunningThing<T>(List<string> ids)
         {
             var tl = new List<Task<List<T>>>();
             
             // a task declared with "async{}" would start on the running thread
 
             //start new thread with default options
             var thr = thread{
                 foreach (var id in ids) {
                     
                     //just like starting a delegate, this task would run on thread "thr"
                     var task = async {
                           return Db.Collection.SelectAllWithKey(id).ToList(); }
                     tl.Add(task);
                 }
             } 
             
             //this executes on main thread
             async{
                 Task.WhenAll(tl);
                 foreach (var task in tl)
                 {
                     //do updates to documents/rows based on data
                 }
             } 
         }

[DaZombieKiller]

it would look better and be faster to code

If anything, this example is making the feature even less appealing. What is async doing here? Magically making a sync method asynchronous? How? Why are there no awaits inside these async blocks?

I'd highly suggest reading up on how async works in C#, because this looks largely incoherent in that context.

[canton7]

@ctigrisht Can you provide the equivalent code to your example, but using current C# syntax? I'm struggling to figure out what the async block does.

Please don't use phrases like "this task would run on thread thr". Task simply represents an operation which might or might not have finished/failed yet: there isn't necessarily any code running anywhere. A Task can represent a network request for which a response might not have been received yet: there's no code "running" until the response is received. Talk about the code inside methods running on particular threads.

[YairHalberstadt]

Rust and Scala have async blocks, and they're actually reasonably useful.

Essentially

Task M()
{
   var task1 = async {
       await whatever;
       dowhatever()
   };

   var task2 = async {
       await whatever2;
       dowhatever2()
   };

   return Task.WhenAll(task1, task2);
}

Is semantically equivalent to:

Task M()
{
   var task1 = ((Func<Task>)(async () => {
       await whatever;
       dowhatever()
   }))();

   var task2 = ((Func<Task>)(async () => {
       await whatever2;
       dowhatever2();
   }))();

   return Task.WhenAll(task1, task2);
}

It makes more sense in languages where blocks are expressions though, and also where async is a modifier after the method signature before the method implementation.

[YairHalberstadt]

If this were done, it probably also ought to be done for iterators as well.

[foxesknow]

Task.Run results on the task executing on a different thread. That's not a behavior that should be encouraged, it's generally the wrong thing to do, especially in async code. And it's not like calling Task.Run is overly verbose, this would at most save 10 keystrokes.

I totally agree with you, which makes me wonder why they bothered adding expression-bodied members to the language. It's probably the most pointless language feature ever added to the language.

[ctigrisht]

@canton7

@ctigrisht Can you provide the equivalent code to your example, but using current C# syntax? I'm struggling to figure out what the async block does.

            static void Method(List<string> ids)
            {
                var tl = new List<Task<List<object>>>();

                var thr = new Thread(new ThreadStart(delegate
                {
                    foreach (var id in ids)
                    {
                        var task = Task.Run(delegate
                        {
                            //say this is db query
                            return new List<object>();
                        });
                        tl.Add(task);
                    }
                }));
                thr.Start();

                Task.Run(delegate
                {
                    foreach (var task in tl)
                    {
                        //do work with result
                        var res = task.Result;
                    }
                });
            }

versus what i propose (mind that async{} could as well be task{}

           static void LongRunningThing(List<string> ids)
            {
                var tl = new List<Task<List<object>>>();

                // a task declared with "async{}" would start on the running thread

                //start new thread with default options
                var thr = thread{
                    foreach (var id in ids)
                    {

                        //just like starting a delegate, this task would run on thread "thr"
                        var task = async {
                            //say this is db query
                            return new List<object>();
                        }
                        tl.Add(task);
                    }
                }
                thr.Start()
                //this executes on main thread
                async{
                    foreach (var task in tl)
                    {
                        //do work with result
                        var res = task.Result;
                    }
                }
            }

also don't mind that the tasks are run on the main scheduler, even from the new thread, its just for display purposes

[DaZombieKiller]

Race condition aside, these snippets are not equivalent. Task.Run will not execute the delegate on the main thread.

I'm having trouble seeing any tangible benefit that can be obtained with this feature, especially when the examples showcasing it don't seem to make much sense.

[canton7]

@ctigrisht The thing is, noone would ever write the code in your first snippet, so I think you're trying to solve a problem that doesn't exist.

There's no point in new Thread, since all you do from it is put stuff on the thread pool. There's normally no point in putting DB queries on thread-pool threads, since they're supposed to be async (i.e. non-blocking). There's no need to move explicitly back to the UI thread: provided that your method started on the UI thread, await will do that for you.

Most people would write that as some variation on this (depending on whether the DB queries need to be made sequentially or in order, whether the DB query can be made asynchronous or not, etc):

static async Task Method(List<string> ids)
{
    var tasks = ids.Select(x => Db.Collection.SelectAllWithKeyAsync(x)).ToList();
    await Task.WhenAll(tasks);

    foreach (var task in tasks)
    {
        var result = task.Result;
        // ...
    }
}

From your posts, I suspect that you don't understand how async/await works in C#.

[orthoxerox]

There's normally no point in putting DB queries on thread-pool threads, since they're supposed to be async

@canton7 Unless the name of your DBMS starts with O, then your async calls are actually sync.

[canton7]

@orthoxerox Sure ^^. Then .Select(x => Task.Run(() => DB.Collection.SelectAllWithKey(x))).ToList()