.net (dotnet) core webapi and async method - feedback wanted

1. No control over http response, headers, code, etc - all set by the framework in case of success or failure, return type is visible to run-time tools

You shouldn't have to use dynamic ever, if you need to return arbitrary responses from an action, you can use

public IActionResult Get(string name = _defaultName)
{
    // or any other method which accepts a response object)
    return Ok(someModel);
}

2. Better control over the http response, but it will tie up the thread while executing the method, no definition for the output data type

The request thread will be kept up for the duration of the action yes. But if you do not use any async operations (DB Access, a network connection to another website/webservice or read/write files to database), using it is fine.

// Here no async operations are called, so Task is not necessary
public IActionResult Index(string name = _defaultName)
{
    if(!ModelState.IsValid)
    {
        return BadRequest(ModelState);
    }

    return Ok();
}

For async operations you should use the Task<IActionResult> instead.

3. Better control over http response, will not tie up the thread while executing the method, but will spin off another thread to compute the result, and no definition for the output type

This assumption is just wrong. Using Task alone with true async operations (I/O operations like reading from filesystem, network connections or access to database) will NOT SPAWN a new thread. The operation will be started and the thread returned to the thread pool.

No new thread will be started instead. When the async operation completes, a thread will be taken from the thread pool and operation continues.

// No extra thread is called and the request thread is only 
// used in between "await" calls
public async Task<IActionResult> Get(string name = _defaultName)
{
    var result = await GetResultFromDatabase();

    return Ok(someModel);
}

Please read the Async Programming : Introduction to Async/Await on ASP.NET article on MSDN from Stephen Cleary. It is about ASP.NET MVC 5 (the old webstack, not the rewrite ASP.NET Core) but the principle still applies to ASP.NET Core.

If you have CPU bound operation (calculating some complicated math etc.), then do not start a new thread. This will mess up with how ASP.NET Core manages the thread pool and you will gain nothing, but will still have the overhead of context-switches and hence it will lower your performance instead of increasing it.

For CPU bound operation, simply runt hem synchronously on the request thread.

public IActionResult Get(string name = _defaultName)
{
    // Don't await or run CPU intensive stuff via Task.Run
    var result = SomeCpuIntensiveOperation();

    return Ok(result);
}

You can also mix CPU bound and async operations

public async Task<IActionResult> Get(string name = _defaultName)
{
    // runs async, no extra thread
    var valueFromDb = await GetValueFromDb();

    // Don't await or run CPU intensive stuff via Task.Run
    // runs sync, on request thread
    var result = SomeCpuIntensiveOperation(valueFromDb);

    return Ok(result);
}

I am wondering whether it makes sense without such downstream async dependencies to pursue async webapi methods and the resulting a tad weird looking code.

That's for you to decide, based the new knowledge about your 3rd assumption

Generally, async scales better, when you have more requests than available threads in the thread pool. But most small sized applications never reach that state, especially when it's an learning exercise or a proof of concept.

It's very unlikely you hit that limit unless you have a high-traffic website which handles 100s or 1000s of requests per second.