在后台线程上运行异步函数？

Question

I'm working on a project that includes a server and a client. The client sends every second a UDP packet to the server, and according to the server's response it might open a TCP connection with the server (and recieve files from the server), the client's program has a GUI which I don't want to block (made in WPF MVVM), and also it's problematic to start async function on constructor of the MainWindow as constructors can't be async. So my question is, can I and should I run async functions on a background thread? Does the async improve performance if it's on a background thread, I'm talking about the difference between these options:

public MainWindow()
{
    InitializeComponent();
    DirectoryViewModel DirectoryVM = new DirectoryViewModel();
    this.DataContext = DirectoryVM;
    DirectoryVM.StartListen(); //Unwanted as constructor won't finish
}

To

public MainWindow()
{
    InitializeComponent();
    DirectoryViewModel DirectoryVM = new DirectoryViewModel();
    this.DataContext = DirectoryVM;
    Task.Run(DirectoryVM.StartListen()); //Possible but async might be faster
}

To

public MainWindow()
{
    InitializeComponent();
    DirectoryViewModel DirectoryVM = new DirectoryViewModel();
    this.DataContext = DirectoryVM;
    Task.Run(async () => await DirectoryVM.StartListenAsync()); //Is it faster than the second option?
}

From what I've seen I shouldn't run async code on background thread like this, but why? Isn't it faster than running sync code on a background thread? Also I guess it's not really different but on my server I'll create a constant running thread that listens for tcp connections and will send files over it, should I make the send file function async or not?

Thanks!

Answer 1

... is it ok to start async method on a seperate thread ...

I think you fundamentally misunderstand the async methods. Calling an async method does not create a new thread or offload the entire method onto any other thread. Calling an async method is like calling any other method, but it maybe at some point returns execution back to the caller (with a Task as a promise) and finishes its remaining job at some point.

Though it is possible to spin up an always running periodic listener using async method, it is rather against its purpose.

When you call an async method, you expect it will be run to completion within a reasonable time (hence why you want to await on it), but it might takes long enough time to do something else meanwhile. In your case, you should explicitly start a new background task or thread what does the periodic check for you. It can be a new thread or better, a new task (Task.Run for example).

From what I've seen I shouldn't run async code on background thread like this, but why?

According to your comments the DirectoryVM.StartListen() starts the constantly running listening, what does not have to be async. Unless it does any async calls, it is not something awaitable.

Isn't it faster than running sync code on a background thread?

Async is not about speed, but about thread blocking. It does not matter if the thread is foreground or background, using async method for an I/O operation, like calling an http endpoint or sending a UDP packet is always beneficial, if the thread can do other things while waiting, or otherwise blocking that thread might cause other issues.

Also I guess it's not really different but on my server I'll create a constant running thread that listens for tcp connections and will send files over it, should I make the send file function async or not?

You should, if it is beneficial. See previous part.

Answer 2

From what I've seen I shouldn't run async code on background thread like this, but why?

I'm not aware of any recommendations not to run asynchronous code with Task.Run .

Task.Run should be avoided on ASP.NET (for both synchronous and asynchronous code), but that doesn't apply here since you have a GUI app.

Isn't it faster than running sync code on a background thread?

No. The code will not be any faster. async is about freeing up threads, not running faster.

I think the concern that you've seen is that of ignoring tasks. Using Task.Run and ignoring the task it returns is problematic because that's a form of fire-and-forget. So if your loop fails due to an exception, your application would never know. One way around this is to await the task from an async void method. For example, as your Window's Initialized event handler:

async void Window_Initialized(object, EventArgs)
{
  await Task.Run(DirectoryVM.StartListen);
  // or, if asynchronous:
  await DirectoryVM.StartListenAsync();
}