Choosing not to await async function in action in ASP.NET Core WebAPI controller

Question

The scenario is the following:

Backend: Asp.NET Core WebAPI 2.2
Frontend: iOS and Android which consumes the API

I have a function allowing the user to send messages to other users. The sending of a message is done in an asynchronous action:

public async Task<IActionResult> CreateMessage

This action does the following in order:

Validation
Awaits persistance of the message to DB
Awaits the notification of relevant clients via SignalR
Doesn't await the sending of push notification via Azure Notification Hub.
Returns a 200 OK.

The last two lines in the action is the following:

_notificationHubProxy.SendNotification(messageToReturnResource.SenderName, messageToPush, recipientId);

return Ok(messageToReturnResource);

SendNotification is asynchronous but I choose to not await it to avoid UI-locks caused by the waiting of the request to finish. At the moment all this seems to work fine.

My question is really the following: is this okey (i.e. to not await), or is this an example of writing bad code which will cause problems when I have many clients using the application?

Regards

One negativity of not awaiting the async call is, that every exception which occurs during SendNotification() will be lost. I would suggest creating a service class which runs in its own Thread and handles the sending of the notifications. In this service class you can await the sending and handle (logging etc.) any occurring exceptions so they will not be lost. But your action is still non-blocking. — croxy
– croxy, Commented Feb 1, 2019 at 9:20
@croxy Thanx for the answer! If that's the only downside I can live with it at the moment. I will look into your suggestion though; Do you mind pointing me in the right direction with regards to how I will go about implementing a service class running in its own thread? An article or a post on stackoverflow etc. would suffice if you don't have the opportunity explaining it yourself. — solojuve1897
– solojuve1897, Commented Feb 1, 2019 at 9:41
You should be careful about unhandled exceptions if the task you don't await could possible throw an exception. From the docs on TaskScheduler.UnobservedTaskException Event: "Occurs when a faulted task's unobserved exception is about to trigger exception escalation policy, which, by default, would terminate the process." ASP.NET might subscribe to the event to prevent the process from being terminated, but you should test it to make sure. — zivkan
– zivkan, Commented Feb 1, 2019 at 10:14
@solojuve1897 Using Asp.Net cores Backgroundworker would be one possibility to implement such a service. You might want to implement a queue within the service which then gets processed by a worker which is responsible for sending the push notifications. — croxy
– croxy, Commented Feb 1, 2019 at 10:39
@solojuve1897 I understand that SignalR is the correct solution for this scenario, in that it implements its own queue and all the developer need do is create a SignalR hub that can be used to notify clients (like web page) — Su Llewellyn
– Su Llewellyn, Commented Feb 19, 2019 at 18:29

Stephen Cleary · Accepted Answer · 2019-02-01 19:19:00Z

9

There are a few problems with fire-and-forget on ASP.NET (both Core and Classic):

Any exceptions will be silently ignored.
The application cannot detect when the operation has completed. This means that everything "higher" than this code has no idea that your code is still doing something; ASP.NET, IIS, and your load balancer have no idea that your application still has something in progress. Some of these are management systems that can (and will) shut down your app. E.g., IIS performs regular AppPool recycling.

The use cases for Fire and Forget on ASP.NET are much rarer than most people think. Not only do you have to be OK with silently swallowing errors, but you also have to be OK with occasionally losing that work.

I choose to not await it to avoid UI-locks caused by the waiting of the request to finish.

That sounds like a UI problem that should be solved by a UI solution.

answered Feb 1, 2019 at 19:19

Stephen Cleary

460k78 gold badges721 silver badges858 bronze badges

Sign up to request clarification or add additional context in comments.

3 Comments

solojuve1897 Over a year ago

You are right. It is a UI issue and I now have a great UI solution implemented. I have changed it back so that I await the sending of push.

Shaul Behr Over a year ago

So Stephen, what is the correct code pattern for a situation where you want to send a bunch of SignalR notifications as a result of some action that was taken? You don't want them to fail silently or get GC'd, but you don't need to wait for them before returning to the calling method.

Stephen Cleary Over a year ago

@ShaulBehr: They wouldn't be GC'ed, but they could fail silently. In order to prevent this, you need to have something listening to them. Since the calling method won't listen to them, something else will have to. The easier but less reliable solution is to do this in-proc: e.g., a background service that delays shutdown until responses are received. That's probably sufficient. The more complex but more reliable solution is to have a separate process, complete with reliable storage of any in-progress communication - this changes the architecture since the SignalR hub is moved.

Collectives™ on Stack Overflow

Choosing not to await async function in action in ASP.NET Core WebAPI controller

1 Answer 1

3 Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

3 Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related