Ignore async without await compilation warning

Question

I have a base controller with the following abstract method:

[HttpDelete]
public abstract Task<IHttpActionResult> Delete(int id);

In one particular controller, I don't want to implement deletion, so the method looks like this:

public override async Task<IHttpActionResult> Delete(int id)
{
    return ResponseMessage(Request.CreateResponse(HttpStatusCode.MethodNotAllowed, new NotSupportedException()));
}

Although the above code compiles, I get a warning:

This async method lacks 'await' operators and will run synchronously. Consider using the 'await' operator to await non-blocking API calls, or 'await Task.Run(...)' to do CPU-bound work on a background thread.

Apart from ignoring the above warning, is there a better alternative (ie. changing the code above) so that this warning doesn't occur?

EDIT

I change the line to:

return await Task.Run(() => ResponseMessage(Request.CreateResponse(HttpStatusCode.MethodNotAllowed, new NotSupportedException())));

This removes the warning. However, is there a better solution?

Answer 1

Apart from ignoring the above warning, is there a better alternative (ie. changing the code above) so that this warning doesn't occur?

The alternative is to remove the async modifier and use Task.FromResult to return a Task<IHttpActionResult>:

public override Task<IHttpActionResult> Delete(int id)
{
    return Task.FromResult<IHttpActionResult>(
                ResponseMessage(Request.CreateResponse(
                                        HttpStatusCode.MethodNotAllowed,
                                        new NotSupportedException())));
}

Answer 2

While Yuval's answer regarding removing the async completely is usually the prefered way to remove the warning, another correct answer that doesn't degrage performance is to await an already completed task.

await is roughly translated to checking whether the awaited task completed, if so continue on executing the rest of the method synchronously and if not add the rest as a continuation on that task.

private static readonly Task _completedTask = Task.FromResult(false);
public override async Task<IHttpActionResult> Delete(int id)
{
    await _completedTask;
    return ResponseMessage(Request.CreateResponse(HttpStatusCode.MethodNotAllowed, new NotSupportedException()));
}

In .Net 4.6 you can use the new Task.CompletedTask property instead of creating your own completed task.

This enables you to keep the method async and with it keep the same error-handling semantics.