C# How do I have an API call successfully return while executing an Async task?

I am having trouble coding an API call to perform an async call.
As a background, we have a call that needs to update a subscriber regarding some of the details within the API call. The subscriber call itself is relatively slow, it does not return anything, and there is no reason that we need to wait for it to complete.

Therefore the change I am trying to do is to have it called async and let the API exit out of the method so that the subscriber can be notified in its own time without holding the API call hostage.

The subscriber class already has existing (non async) methods, and I am simply trying to put a wrapper around it.

Here is an example:

public class Subscriber
{
  // existing method
  public void NotifySubscriber(string message)
  {
    // code goes here to send a message to the subscriber
    // this may take quite a few seconds to complete
  }

  // my new async wrapper
  public async void NotifySubscriberAsync(string message)
  {
    await Task.Run(() =>
    {
      NotifySubscriber(message);
    });
  }
}

And here is an example of my API method, which is called from the controller

public class MyClassService
{
  public void DoSomething(string input)
  {  
    // do operations specific to the service

    Subscriber s = new Subscriber();
    // old code - user forced to wait for the subscription notification
    //s.NotifySubscriber("my message");

    // new code. The goal is for the controller to no longer 
    // have to wait for the notification to complete
    s.NotifySubscriberAsync("my message");
  }
}

If I put a breakpoint in the code, I can see that the API method is running to completion, as is the calling code in the controller. The controller itself is returning a response, with the subscriber call happening in the background.

However, what happens is that the front-end code ends up hanging, almost like it is still waiting for the async method to complete. It completely locks up and with no errors in the console window in dev tools.

Removing the async call fixes it, so I know that the problem is related to that.

What am I overlooking here?

Many thanks and best regards

The solution for your actual problem (having notifications in the background without the user waiting) is not an async call. It may work, but it has so many pitfalls, because you already send the response, while there still is code running.

Simplest example, what about errors? What if sending the notification does not work? You cannot even notify the user of the error, they got the "ok" from your API and are happily browsing elsewhere. Or using blocks. Or Middleware. That all goes out the window when you split off tasks and don't await them. Is your database context still valid, or did the dependency injection dispose it after your call and scope was done?

What you want to do is put the information that a notification is to be sent into a table (or message queue). And then have a service, a completely different executable from your API, query that storage and send out notifications.

In other words, split the "action" ("I command you to send X") from the "execution" (sending X). You can absolutely make your API say "Sir, yes, sir!" after receiving the order, but make it sequential. Say "Sir, yes, sir!" and then, as a different step, execute it. Don't try to do X while you salute. That is madness.

Keep in mind, that async methods do not run in an own thread. The compiler just applies some magic, to have it behave like a async execution.

I would assume, that your example does not contain other code IN the async method? (That would be run in the main-thread, if it's not awaited).

For Fire and Forget I would just launch a thread to execute the action. Not more code and works guaranteed without stucks.

  public void NotifySubscriberThreaded(string message)
  {
    (new Thread(() => {
      NotifySubscriber(message);
    })).start();
  }

Or better return the thread object, then you could even check it's status later on if required. (or join, kill, etc.)

  public Thread NotifySubscriberThreaded(string message)
  {
    Thread t = new Thread(() => {
      NotifySubscriber(message);
    });
    t.start();
    return t;
  }

To use Fire And Forget, do this:

public void NotifySubscriberAsync(string message)
{
 //fireAndForget
 Task.Run(() =>
 {
   NotifySubscriber(message);
 });
}

Using async void will crash the program if an exception happens inside. Versus Task.Run that will just see it is detached, and continue on.