Async-Programming | Multithreaded , Parallel , and Async Programming

Use "Task" as return type of async function.

https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/async/async-return-types#void-return-type

The Task return type prevents removal of newUser by "caller" method until async ends :

• you call asyncmethod with newUser from "caller" method
• await suspends processing async method and starts processing "caller" method
• the newUser is cleaned at the end of "caller" method
• then await ends and async method starts processing
• in this case 'newUser' is null and throw exception

Detailed solution, and the link to get the file related to the article

I ended up using MVVMLight. All function from this library are preceded with GS

XAML

First, it's important to note that either way, the code is asynchronous.

That said, I generally recommend people to start with async/await everywhere and then only elide the keywords in trivial cases. There are several caveats when eliding async and await, including exceptions and using statements. So as a general rule, if the implementation is truly trivial (literally just "forward to another method"), then feel free to elide async/await; everywhere else, keep the async/await keywords. They have minimal overhead and guarantee correct semantics for nontrivial methods.

I don't see why you'd need to create a async version of your RelayCommand. You could simply run a async method when the command executes that listens for a cancellation token. Something like:

Your command: public ICommand DoSomethingCommand { get; set; }

Instantiate your command somewhere: DoSomethingCommand = new RelayCommand(DoSomething);

And an example of the DoSomething method:

The Async comes in when you actually do something.

As long as you're setting up the query, from a task perspective it doesn't make sense to make thing asynchronous.

I'll give you an example;

The following code is about setting up the query:

JavaScript, the language, is not single-threaded, and there exist multi-threaded environments that run JavaScript (for instance, the Java virtual machine via its scripting support). The language itself is largely silent on the topic of threads. It does define a job queue (browser-oriented folks call it an "event loop") and run-to-completion semantics for jobs (see Jobs and Job Queues in the spec). More on that in a moment.

However, most environments (including browsers) run one thread per global environment (or sometimes one thread for multiple global environments), which is why "JavaScript is single-threaded" is so commonly believed. But even on browsers, you can have multiple threads via web workers. They do not share a common global environment, with all the complications that causes, but they can communicate.

Back to your question:

Running on a single thread and having asynchronous callbacks are not at all in conflict. A JavaScript thread works on the basis of a job queue that jobs get added to. A job is a unit of code that runs to completion. When that unit of code is done running to completion, the thread picks up the next job from the queue and runs that. One job cannot interrupt another job (spec link). Jobs running on the main UI thread cannot be suspended in the middle (mostly¹), though jobs on worker threads can be (via Atomics.wait). A thread with a suspended job is completely suspended, it does not pick up other jobs from its queue until it's resumed and completes the job that was suspend.

So for instance, consider:

As the comments have noted, you're having trouble with absolute vs relative paths and how node handles the current working directory.

The crux of your issue is best demonstrated by running the following:

I'm new to the async-programming

I suggest my async intro followed by my async best practices article.

Don't use async lambdas with Action delegate types; that results in an async void method. One of the drawbacks to async void methods is that you can't easily tell when they complete.

Async doesn't mesh naturally with Console apps. You can block the main thread on asynchronous code, but this is not a good pattern to use in any kind of other application: