Demande.Contenu.ReadAsMultipartAsync ne retourne jamais

Je suis tombé sur le même problème avec tous les 4.5.2 cadre.

Mon API méthode accepte un ou plusieurs fichiers téléchargés à l'aide d'une requête POST avec plusieurs parties de contenu. Il a bien fonctionné avec les petits fichiers, mais avec de plus gros, ma méthode pendu à jamais, parce que la ReadAsMultipartAsync() la fonction n'a jamais été terminée.

Ce qui m'a aidé: à l'aide d'un async méthode de contrôleur et await pour la ReadAsMultipartAsync() pour terminer, au lieu d'obtenir le résultat de la tâche en mode synchrone méthode de contrôleur.

Donc, , cela ne fonctionne pas:

[HttpPost]
public IHttpActionResult PostFiles()
{
    return Ok
    (
        Request.Content.ReadAsMultipartAsync().Result

        .Contents
        .Select(content => ProcessSingleContent(content))
    );
}

private string ProcessSingleContent(HttpContent content)
{
    return SomeLogic(content.ReadAsByteArrayAsync().Result);
}

Et cela a fonctionné:

[HttpPost]
public async Task<IHttpActionResult> PostFiles()
{
    return Ok
    (
        await Task.WhenAll
        (
            (await Request.Content.ReadAsMultipartAsync())

            .Contents
            .Select(async content => await ProcessSingleContentAsync(content))  
        )
    );
}

private async Task<string> ProcessSingleContentAsync(HttpContent content)
{
    return SomeLogic(await content.ReadAsByteArrayAsync());
}

où SomeLogic est juste une fonction synchrone de prendre le contenu binaire et la production d'une chaîne de caractères (peut être n'importe quel type de traitement).

Mise à JOUR Et enfin j'ai trouvé l'explication dans cet article: https://msdn.microsoft.com/en-us/magazine/jj991977.aspx

La cause de ce blocage est dû à la façon attendent poignées de contextes. Par défaut, lorsqu'un incomplètes Tâche est attendu, le courant “contexte” est captée et utilisée pour reprendre la méthode lorsque la Tâche est terminée. Ce “contexte” est l'actuel SynchronizationContext sauf si c'est null, dans ce cas, c'est l'actuel TaskScheduler. GUI et ASP.NET les applications ont un SynchronizationContext qui permet à un seul bloc de code à exécuter à un moment. Lorsque l'attendent terminée, il tente d'exécuter le reste de la méthode async dans la capture d'contexte. Mais ce contexte a déjà un thread, qui est (de façon synchrone) dans l'attente de la méthode asynchrone à compléter. Ils sont tous en attente pour l'autre, provoquant un blocage.

Donc, en gros, le “Async tout le chemin” de directive a une raison derrière elle, et c'est un bon exemple.

J'ai un travail .Net MVC WebAPi projet avec le Post suivant, la méthode qui semble bien fonctionner. C'est très similaire à ce que vous avez déjà ce qui devrait être utile.

    [System.Web.Http.AcceptVerbs("Post")]
    [System.Web.Http.HttpPost]
    public Task<HttpResponseMessage> Post()
    {
        //Check if the request contains multipart/form-data.
        if (!Request.Content.IsMimeMultipartContent())
        {
            throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
        }
        string fileSaveLocation = @"c:\SaveYourFile\Here\XXX";
        CustomMultipartFormDataStreamProvider provider = new CustomMultipartFormDataStreamProvider(fileSaveLocation);
        Task<HttpResponseMessage> task = Request.Content.ReadAsMultipartAsync(provider).ContinueWith<HttpResponseMessage>(t =>
            {
                if (t.IsFaulted || t.IsCanceled)
                {
                    Request.CreateErrorResponse(HttpStatusCode.InternalServerError, t.Exception);
                }
                foreach (MultipartFileData file in provider.FileData)
                {
                    //Do Work Here
                }
                return Request.CreateResponse(HttpStatusCode.OK);
            }
        );
        return task;
    }