How could I accomplish Node.js like asynchronicity with C#?

Question

I work with Node.js and so I got very used to its 'programming style' and its way to deal with asynchronous operations through higher order functions and callbacks, where most I/O events are handled in a async way by design and if I want to make a sync operation, I need to use Promises or the await shortcut, whereas in synchronous programming languages like Java, C#, C++ apparently I'd have to do the opposite, by somehow telling the compiler that the task I want to achieve must be performed asynchronously. I tried reading through the Microsoft docs and couldn't really understand how to achieve it. I mean, I could use Threads but for the simple task I want to process, exploring Threads is just not worth it for the trouble on guaranteeing thread-safety. I came across the Task class. So, suppose that I want to run a Task method multiple times in a async way, where the functions are being called in parallel. How can I do this?

        private Task<int> MyCustomTask(string whatever)
        {
           // I/O event that I want to be processed in async manner
        }

So basically, I wanted to run this method in 'parallel' without threading.

foreach (x in y)
{
   MyCustomTask("");
}

Answer 1

If you don't want to await, you can do something like this.

public class AsyncExamples
{
    public List<string> whatevers = new List<string> { "1", "2", "3" };

    private void MyCustomTask(string whatever)
    {
        // I/O event that I want to be processed in async manner
    }

    public void FireAndForgetAsync(string whatever)
    {
        Task.Run(
            () =>
            {
                MyCustomTask(whatever);
            }
        );
    }

    public void DoParallelAsyncStuff()
    {
        foreach (var whatever in whatevers)
        {
            FireAndForgetAsync(whatever);
        }
    }
}

Answer 2

most I/O events are handled in a async way by design and if I want to make a sync operation, I need to use Promises or the await shortcut

I believe the difference you're expressing is the difference between functional and imperative programming, not the difference between asynchronous and synchronous programming. So I think what you're saying is that asynchronous programming fits more naturally with a functional style, which I would agree with. JavaScript is mostly functional, though it also has imperative and OOP aspects. C# is more imperative and OOP than functional, although it grows more functional with each year.

However, both JavaScript and C# are synchronous by default, not asynchronous by default. A method must "opt in" to asynchrony using async/await. In that way, they are very similar.

I tried reading through the Microsoft docs and couldn't really understand how to achieve it.

Cheat sheet if you're familiar with asynchronous JavaScript:

• Task<T> is Promise<T>
  • If you need to write a wrapper for another API (e.g., the Promise<T> constructor using resolve/reject), then the C# type you need is TaskCompletionSource<T>.
• async and await work practically the same way.
• Task.WhenAll is Promise.all, and Task.WhenAny is Promise.any. There isn't a built-in equivalent for Promise.race.
• Task.FromResult is Promise.resolve, and Task.FromException is Promise.reject.

So, suppose that I want to run a Task method multiple times in a async way, where the functions are being called in parallel. How can I do this?

(minor pedantic note: this is asynchronous concurrency; not parallelism, which implies threads)

To do this in JS, you would take your iterable, map it over an async method (resulting in an iterable of promises), and then Promise.all those promises.

To do the same thing in C#, you would take your enumerable, Select it over an async method (resulting in an enumerable of tasks), and then Task.WhenAll those tasks.

var tasks = y.Select(x => MyCustomTask(x)).ToList();
await Task.WhenAll(tasks);