ASP.NET Web API 2 - ReadAsMultipartAsync alternative/how to - asp.net

Question

I'm using Web API 2.2 to receive an HTTP post with form data and files, I'm doing the following:
Synchronous version:
[HttpPost]
public IHttpActionResult CreateTicket()
{
string root = HttpContext.Current.Server.MapPath("~/UserFiles/Temp/");
var provider = new MultipartFormDataStreamProvider(root);
// Timeouts
Request.Content.ReadAsMultipartAsync(provider).Wait(TimeSpan.FromSeconds(20));
...
}
Async version:
[HttpPost]
public async Task<HttpResponseMessage> CreateTicket()
{
string root = HttpContext.Current.Server.MapPath("~/UserFiles/Temp/");
var provider = new MultipartFormDataStreamProvider(root);
// Works
await Request.Content.ReadAsMultipartAsync(provider);
...
// Error because: HttpContext.Current == null
}
Both versions of this code work in IIS 10, but fail on production (IIS 8.5). The first version timeouts and the second works but HttpContext.Current is not available which makes other parts of my code fail.
How can I make either the upload synchronous (preferred) or make the async code have HttpContext.Current available?
UPDATE:
Just discovered that the problem (in the second code fragment) only happens if the application does not have the following in the web.config:
<httpRuntime targetFramework="4.6.1" />
Still investigating the side effects to see if I can apply that safely or need to change the code.

Answer 1

I've finally figured it out by creating a small app and trying to reproduce it. As Dmitry and Paulo have pointed out, it should work. However, it should work for any new project and in my case the project is 10 years old and has lots of legacy configurations.
TL;DR: The async/await keywords do not work very well (the HttpContext.Current will be null after calling await) if this setting is not present in the web.config:
<httpRuntime targetFramework="4.6.1" />
That is a shortcut for a bunch of settings, including this one (which is the one I care here):
<configuration>
<appSettings>
<add key="aspnet:UseTaskFriendlySynchronizationContext" value="true" />
</appSettings>
</configuration>
Everything is explained in detail here: https://blogs.msdn.microsoft.com/webdev/2012/11/19/all-about-httpruntime-targetframework/
For reference, it says:
<add key="aspnet:UseTaskFriendlySynchronizationContext" value="true" />
Enables the new await-friendly asynchronous pipeline that was
introduced in 4.5. Many of our synchronization primitives in earlier
versions of ASP.NET had bad behaviors, such as taking locks on public
objects or violating API contracts. In fact, ASP.NET 4’s
implementation of SynchronizationContext.Post is a blocking
synchronous call! The new asynchronous pipeline strives to be more
efficient while also following the expected contracts for its APIs.
The new pipeline also performs a small amount of error checking on
behalf of the developer, such as detecting unanticipated calls to
async void methods.
Certain features like WebSockets require that this switch be set.
Importantly, the behavior of async / await is undefined in ASP.NET
unless this switch has been set. (Remember: setting <httpRuntime
targetFramework="4.5" /> is also sufficient.)
If that settings is not present at all, then version 4.0 is assumed and it works in 'quirks'-mode:
If there is no <httpRuntime targetFramework> attribute present in Web.config, we assume that the application wanted 4.0 quirks behavior.

Answer 2

For retrieving files in ASP.NET Core try using IFileProvider instead of HttpContext - see File Providers in ASP.NET Core documentation for more details about configuring and injecting it via DI.
If that is the POST controller action to upload multiple files and receive other data - you can do it this way. Below for demo purposes I use View but data can just go from anywhere as API POST request.
View
#model MyNamespace.Models.UploadModel
<form asp-controller="MyController" asp-action="Upload" enctype="multipart/form-data" method="post">
<input asp-for="OtherProperty">
<input name="Files" multiple type="file">
<button type="submit" class="btn btn-success">Upload</button>
</form>
Model - note that files are passed as IFormFile objects
public class UploadModel
{
public List<IFormFile> Files { get; set; }
public string OtherProperty { get; set; }
}
Controller
[HttpGet]
public IActionResult Upload()
{
return View(new UploadModel());
}
[HttpPost]
public async Task<IActionResult> Index(UploadModel model)
{
var otherProperty = model.OtherProperty;
var files = new Dictionary<string, string>();
foreach (IFormFile file in model.Files)
{
using (var reader = new StreamReader(file.OpenReadStream()))
{
string content = await reader.ReadToEndAsync();
files.Add(file.Name, content);
// Available file properties:
// file.FileName
// file.ContentDisposition
// file.ContentType
// file.Headers
// file.Length
// file.Name
// You can copy file to other stream if needed:
// file.CopyTo(new MemoryStream()...);
}
}
}