À L'Aide De HttpContext.Courant dans WebApi est dangereux en raison de async

Ma question est un peu lié à ce: WebApi équivalent pour HttpContext.Articles avec l'Injection de Dépendance.

Nous voulons injecter une classe à l'aide HttpContext.Courant dans WebApi zone à l'aide de Ninject.

Ma préoccupation est que ce pourrait être très dangereux, comme dans WebApi (tout?) est asynchrone.

S'il vous plaît corrigez-moi si je me trompe dans ces points, c'est ce que j'ai étudié jusqu'à présent:

  1. HttpContext.Actuel devient le contexte actuel par Thread (j'ai regardé dans la mise en œuvre directement).

  2. À L'Aide De HttpContext.Courant à l'intérieur de async Tâche n'est pas possible, car il peut fonctionner sur un autre Thread.

  3. WebApi utilise IHttpController avec la méthode Task<HttpResponseMessage> ExecuteAsync => chaque demande est async => vous ne pouvez pas utiliser HttpContext.Courant à l'intérieur de la méthode d'action. Il pourrait même arriver, plus de requêtes sont exécutées sur le même thread par coicidence.

  4. Pour la création de contrôleurs injectées avec des trucs dans les constructeurs IHttpControllerActivator est utilisé avec sync méthode IHttpController Create. C'est, où ninject crée Contrôleur avec toutes ses dépendances.

  • Si je suis correct dans l'ensemble de ces 4 points, à l'aide de HttpContext.Courant à l'intérieur d'une méthode d'action ou de toute couche ci-dessous est très dangereux et peut avoir des résultats inattendus. J'ai vu sur de SORTE que beaucoup de réponses acceptées ce qui suggère exactement cela. À mon humble avis, cela peut fonctionner pendant un certain temps, mais il ne pourra pas sous la charge.

  • Mais lors de l'utilisation de DI de créer un Contrôleur et de ses dépendances, c'est Ok, parce que cela fonctionne sur un thread séparé. J'ai pu obtenir une valeur de la HttpContext dans le constructeur et il serait à l'abri?. Je me demande si chaque Contrôleur est créé sur un seul thread pour chaque demande, car cela pourrait provoquer un problème de sous de lourdes charges, où tous les threads de IIS peut être consommé.

Juste pour expliquer pourquoi je veux injecter HttpContext trucs:

  • une solution serait de faire la demande dans la méthode d'action de contrôleur et passer à la valeur nécessaire tous les calques en tant que param jusqu'à ce que son utilisé quelque part profondément dans le code.

  • notre voulaient solution: toutes les couches entre ne sont pas afected par cela, et nous pouvons utiliser l'injection de demande de quelque part profondément dans le code (par exemple, dans certains ConfigurationProvider qui dépend de l'URL)

    Merci de me donner votre avis si je suis totalement tort ou mes suggestions sont corrects, ce thème semble être très compliqué. Merci à l'avance!

  • C'est une question très intéressante. Cependant, autant que je sache, si le code ne prévoit pas explicitement de reporter les travaux à un autre thread, les choses seront toujours exécutées sur le même thread. Cela est également vrai pour les tâches asynchrones. Bien que ce ne sera pas bloquer le thread appelant, ça va encore être exécuté sur le thread appelant. Mais je ne suis pas sûr à 100%.. vous devriez l'essayer 😉
  • c'est exactement le problème avec vous attendent pour la plupart rester sur le même fil, mais vous ne pouvez pas être sûr à ce sujet. c'est pourquoi l'OMI tout le monde pense que cela fonctionne, mais va rompre dans des circonstances.. À la Tâche.Courir, c'est bien, c'est un autre thread.
  • pourquoi pensez-vous que vous ne pouvez pas être sûr à ce sujet? Plus que avec une "synchronisation" de la méthode? La méthode de synchronisation peut également exécuter Task.Run(..) ou il pourrait générer un nouveau thread et dans ce thread essayer d'obtenir le HttpContext injecté.. etc. Alors, quelle est la différence?
  • Lorsque vous ne Task.Run, vous le faites par vous-même et vous savez à quoi s'attendre, c'est ok pour moi. Ma préoccupation est,comme la méthode d'action dans webapi est exécutée de manière asynchrone par le cadre, c'est toujours être considéré comme asynchrone avec tous ses pièges. Je pense que, il est même possible, deux Demandes d'exécuter sur le même thread (c'est le but de l'attendent/async je pense) => HttpContext.Courant sera de retour une fausse valeur. En fait, cette question a déjà frappé moi une fois, par la prise de conscience que log4net LogicalThreadContext.Les propriétés ne sont pas de travail en vous connectant WebApi, mais en MVC ils font un travail.
  • Pour answere votre question, pourquoi voudrais-je pense qu'il n'est pas sûr qu'il est en cours d'exécution sur le même fil? - J'ai lu beaucoup d'articles sur internet et il semble que la communauté n'est pas vraiment sûr de cela, mais j'ai eu le sentiment que le SyncronizationContext va décider de commencer à nouveau Thread, ou non, selon les circonstances actuelles, mais practicaly cette situation est très rare. (pas encore sûr à 100% sur ce que beaucoup d'opinions différentes sur internet)
InformationsquelleAutor Lukas K | 2014-07-25
  1. 99

    HttpContext.Actuel devient le contexte actuel par Thread (j'ai regardé dans la mise en œuvre directement).

    Il serait plus correct de dire que HttpContext est appliqué à un fil, ou d'un fil "entre" la HttpContext.

    À L'Aide De HttpContext.Courant à l'intérieur de async Tâche n'est pas possible, car il peut fonctionner sur un autre Thread.

    Pas du tout; le comportement par défaut de async/await reprendra sur l'arbitraire d'un fil, mais ce thread va entrer dans le contexte de la demande avant de reprendre votre async méthode.

    La clé, c'est la SynchronizationContext. J'ai un MSDN article sur le sujet si vous n'êtes pas familier avec elle. Un SynchronizationContext définit un "contexte" pour une plate-forme avec la commune étant de l'INTERFACE utilisateur contextes (WPF, WinPhone, WinForms, etc), le pool de threads contexte, et la ASP.NET contexte de demande.

    L'ASP.NET contexte de demande gère HttpContext.Current ainsi que quelques autres choses comme la culture et de sécurité. L'INTERFACE utilisateur, les contextes sont tous étroitement associée à un seul thread (la thread d'INTERFACE utilisateur), mais le ASP.NET contexte de demande n'est pas liée à un thread spécifique. Il sera, cependant, ne permettre qu'à un fil dans le contexte de la demande à un moment.

    L'autre partie de la solution est comment async et await travail. J'ai un async intro sur mon blog qui décrit leur comportement. En résumé, await par défaut permettra de saisir le contexte actuel (qui est SynchronizationContext.Current, sauf si elle est null), et d'utiliser ce contexte pour reprendre le async méthode. Donc, await est capture automatiquement la ASP.NET SynchronizationContext et reprendre le async méthode dans ce contexte de demande (et donc de la préservation de la culture, de la sécurité, et HttpContext.Current).

    Si vous await ConfigureAwait(false), alors vous êtes explicitement dire await à pas de capture du contexte.

    Noter que ASP.NET ne changer son SynchronizationContext de travailler proprement avec async/await. Vous devez vous assurer que l'application est compilée en contre .NET 4.5 et aussi explicitement des objectifs de 4,5 dans son site web.config; c'est la valeur par défaut pour les nouveaux ASP.NET 4.5 projets mais doit être explicitement défini si vous avez mis à niveau à partir d'un projet existant ASP.NET 4.0 ou version antérieure.

    Vous pouvez vous assurer que ces paramètres sont corrects par l'exécution de votre application contre .NET 4.5 et en observant SynchronizationContext.Current. Si c'est AspNetSynchronizationContext, alors vous êtes bon; si c'est LegacyAspNetSynchronizationContext, les réglages sont mauvais.

    Aussi longtemps que les paramètres sont corrects (et que vous utilisez le ASP.NET 4.5 AspNetSynchronizationContext), alors vous pouvez utiliser en toute sécurité HttpContext.Current après une await sans vous en soucier.

    • merci Etienne pour cette belle explication! J'avais besoin de quelques jours pour l'étudier plus en détail. Ce fut une belle surprise pour moi, on peut l'utiliser en toute sécurité. Rend notre code plus propre. Je vois encore une fois, l'async des choses est assez compliqué à comprendre pleinement.
    • C'est compliqué sous les couvertures, de sorte que notre le code est plus propre et plus simple. 🙂
    • vous mentionnez que les paramètres sont mal si vous êtes l'obtention de l'Héritage, mais qui semble être la valeur par défaut. Si vous voulez obtenir le "non-legacy" SynchronizationContext vous devez l'ajouter à votre site Web.Config: <add key="aspnet:UseTaskFriendlySynchronizationContext" value="true" />
    • L'héritage contexte est utilisé uniquement si le serveur-côté quirks mode est actif. C'est seulement le cas si vous êtes à la mise à niveau .NET 4.5 et n'ont pas éteint encore. Pour une nouvelle .NET 4.5 ASP.NET projet, en utilisant le nouveau contexte est la valeur par défaut. Plus d'infos ici.
    • merci pour cette magnifique réponse. J'ai dû lire deux fois avant que je comprenne le problème que j'ai rencontrée a été le point que vous avez mentionné ne pas fixer le httpRuntime à 4.5. Dès que je l'ai fait, tous mes problèmes ont disparus.
    • Je voulais juste dire que toute cette histoire avec UseTaskFriendlySynchronizationContext et targetFramework ne fonctionne pas si vous l'appel de méthode asynchrone non async chemin à l'intérieur ASP.NET. Voyez vous-même: dotnetfiddle.net/9rPOoq
    • Ce code est à l'aide de ConfigureAwait(false), ce qui est explicitement dire ASP.NET qu'il ne pas besoin de la requête HTTP contexte, et alors qu'il accède à la requête HTTP contexte. Donc oui, je m'attends à une panne. La solution idéale est d'utiliser await au lieu de Task.Wait.
    • Si je saute .ConfigureAwait(faux) je vais avoir de blocage.
    • Pas si vous utilisez await au lieu de Task.Wait.
    • comme vous pouvez le voir dans mon exemple, c'est un cas où vous ne pouvez pas utiliser attendent en raison de l'héritage de code n'est pas asynchrone (il est généralement beaucoup plus de méthodes vers le haut qui ne peuvent pas être rapidement changés en asynchrone). Mais le nouveau code est asynchrone.
    • Ensuite, vous devez modifier le code héritage, ou de l'utilisation deux async et de synchronisation des Api dans le nouveau code. Il n'est pas possible de ne pas être sur le contexte et pour être sur le contexte.
    • Demande de commentaires sur cette connexes [questions/réponses] (stackoverflow.com/a/38339065/538763).
    • Il devrait y avoir aucun besoin de AsyncLocal<T>; si vous avez correctement cible .NET 4.5 ou supérieur, HttpContext.Current coule à travers await points.
    • Demande d'élaborer stackoverflow.com/questions/38340880
    • Si ConfigureAwait(false) est utilisée à tout moment dans la pile d'appel est-ce à dire que le contexte de thread sera perdu par un appelant qui avait l'intention de synchroniser le contexte? c'est à dire que l'appelant n'a pas spécifier ConfigureAwait(faux)?
    • Chaque méthode choisit de les capturer et de les reprendre à son propre contexte. Si le nom de la méthode entraîne la suppression de son contexte, qui n'affecte pas l'appelant. Si un appelant la méthode des rejets son contexte après l'appel de cette méthode, qui n'affectent pas cette méthode. Si un appelant la méthode des rejets son contexte avant appel de cette méthode, cette méthode n'aura pas un contexte.
    • Donc, serait-il correct de dire que ConfigureAwait(faux) devrait être utilisé sur tous les appels asynchrones au sein des bibliothèques. La valeur par défaut, ConfigureAwait(vrai), ne doivent être utilisés au niveau de l'application où il y a une interface graphique ou ASP.NET contexte afin de les synchroniser avec?
    • Soi - corrigez-moi si je me trompe, mais tl;dr - si vous utilisez httpRuntime > 4.5, HttpContext.Le courant est fort (grâce à SynchronisationContext)?
    • Oui. Ce n'est pas recommandé (il est encore considéré comme une mauvaise conception), mais il faudra travailler.
    • concernant la AsyncLocal wrapper et de ton commentaire sur HttpContext.Current qui coule à travers awaits - il ne semble pas être le cas dans WCF. Signifie-t-il la solution peut encore être utilisé?
    • Je crois que cela dépend de la façon dont votre WCF est hébergé; si c'est dans un cadre moderne ASP.NET de l'environnement, il doit être coulé (WCF ne pas fournir une SynchronizationContext, il ne laisse que jusqu'à son hôte). Mais vous pouvez utiliser AsyncLocal (dans une .NET 4.5 ou version plus récente de l'exécution), peu importe.
    • merci. Malheureusement, nous avons actuellement le débogage d'un mauvais scénario où ASP.NET intégré WCF gouttes HttpContext.Courant après une couple de récursive awaits. Malheureusement, même l'approche proposée impliquant AsyncLocal ne semble pas aider (ou au moins, nous avons quelques problèmes à l'utiliser). C'est vraiment la honte de la WCF ne rentre pas dans le modèle asynchrone en tant que bien que d'autres sous-systèmes ne. Ma question a été posée essentiellement pour s'assurer de la WCF n'a tout simplement pas suivre.
    • Oui; historiquement, async est sorti quand WebAPI était en train de devenir à la mode, de sorte WCF ne se perdent un peu. Une chose à vérifier est le httpRuntime@targetFramework paramètre dans votre web.config; autre que cela, vous êtes probablement mieux de l'ouverture d'un MS problème de prise en charge.

    InformationsquelleAutor Stephen Cleary
  2. 4

    Je suis en utilisant une api web, qui est à l'aide de async/await méthodologie.

    également à l'aide de 

    1) HttpContext.Current.Server.MapPath
2) System.Web.HttpContext.Current.Request.ServerVariables

    C'était très bien pour une bonne quantité de temps qui a éclaté subitement pour pas de changement de code.

    Passer beaucoup de temps en revenir à la précédente versions anciennes, trouvé la clé manquante à l'origine du problème. 

    < httpRuntime targetFramework="4.5.2"  /> under system.web

    Je ne suis pas un expert sur le plan technique. Mais je suggère d'ajouter la clé de votre configuration web et de lui donner un ALLER.

    • merci pour le commentaire. En fait, cela correspond à la accepté de répondre à de Stephen. Dans le nouveau cadre, le contexte de synchronisation a été retravaillé et ils assurez-vous que exactement la question que je mentionne fonctionne correctement comme prévu.
    InformationsquelleAutor Selva Ramaswamy
  3. 2

    J'ai trouvé très bon article qui décrit exactement ce problème: http://byterot.blogspot.cz/2012/04/aspnet-web-api-series-part-3-async-deep.html?m=1

    auteur étudié profondément, comment le ExecuteAsync méthode est appelée dans le WebApi cadre et est venu à cette conclusion:

    ASP.NET Web API actions (et tous le pipeline méthodes) va être appelée de façon asynchrone uniquement si vous retournez une Tâche ou une Tâche<T>. Cela peut paraître évident, mais aucun de la canalisation méthodes avec Async suffixe s'exécutent dans leur propre fils. À l'aide de couverture Async pourrait être un abus de langage. [Mise à JOUR: ASP.NET de l'équipe ont en effet confirmé que l'Asynchrone est utilisé pour indiquer les méthodes qui retournent des Tâches et vous pouvez exécuter de manière asynchrone, mais n'ont pas d']

    Ce que j'ai compris de l'article, c'est que les méthodes d'Action sont appelés de façon synchrone, mais c'est à l'appelant de la décision.

    J'ai créé une petite application de test à cette fin, quelque chose comme ceci:

    public class ValuesController : ApiController
{
    public object Get(string clientId, string specialValue)
    {
        HttpRequest staticContext = HttpContext.Current.Request;
        string staticUrl = staticContext.Url.ToString();

        HttpRequestMessage dynamicContext = Request;
        string dynamicUrl = dynamicContext.RequestUri.ToString();

        return new {one = staticUrl, two = dynamicUrl};
    }
}

    et une version Asynchrone de retour async Task<object>

    J'ai essayé de faire un peu d'attaque DOS sur elle avec jquery et n'a pas pu déterminer toute question jusqu'à ce que j'ai utilisé await Task.Delay(1).ConfigureAwait(false);, ce qui est évident qu'il serait un échec.

    Ce que j'ai pris à partir de l'article, c'est que le problème est très compliqué et le Fil de l'interrupteur peut se produire lors de l'utilisation de méthode d'action asynchrone, donc c'est vraiment un PAS une bonne idée d'utiliser HttpContext.Actuelle de n'importe où dans le code de l'action des méthodes. Mais comme le contrôleur est créé de manière synchrone, à l'aide de HttpContext.Courant dans le constructeur ainsi que dans l'injection de dépendance est OK.

    Quand quelqu'un a une autre explication à ce problème s'il vous plaît corrigez-moi que ce problème est très compliqué d'une je ne suis pas encore convaincu à 100%.

    diclaimer:

    • J'ignore pour l'instant le problème de l'auto-hébergée sur le Web-Api sans IIS, où HttpContext.Actuel ne fonctionnerait pas sans doute de toute façon. Nous avons désormais compter sur les services internet.
    InformationsquelleAutor Lukas K