Après cette question, je suis plus à l'aise lorsque j'utilise des opérations asynchrones dans ASP.NET MVC. J'ai donc écrit deux articles de blog à ce sujet :
J'ai trop de malentendus dans mon esprit concernant les opérations asynchrones sur ASP.NET MVC.
J'entends toujours cette phrase : L'application peut mieux évoluer si les opérations sont exécutées de manière asynchrone.
Et j'ai aussi beaucoup entendu ce genre de phrases : si vous avez un énorme volume de trafic, il est préférable de ne pas exécuter vos requêtes de manière asynchrone - la consommation de deux threads supplémentaires pour répondre à une requête prive de ressources les autres requêtes entrantes.
Je pense que ces deux phrases sont incohérentes.
Je n'ai pas beaucoup d'informations sur le fonctionnement du pool de threads en ASP.NET mais je sais que le pool de threads a une taille limitée pour les threads. Donc, la deuxième phrase doit être liée à ce problème.
Et je voudrais savoir si les opérations asynchrones dans ASP.NET MVC utilisent un thread du ThreadPool sur .NET 4 ?
Par exemple, lorsque nous mettons en œuvre un AsyncController, comment l'application se structure-t-elle ? Si j'ai un trafic énorme, est-ce une bonne idée de mettre en œuvre AsyncController ?
Y a-t-il quelqu'un qui puisse enlever ce rideau noir devant mes yeux et m'expliquer ce qu'est l'asynchronie sur ASP.NET MVC 3 (NET 4) ?
Editar:
J'ai lu le document ci-dessous des centaines de fois et j'en ai compris l'essentiel, mais je reste confus car il y a trop de commentaires incohérents.
Utilisation d'un contrôleur asynchrone dans ASP.NET MVC
Editar:
Supposons que j'ai une action de contrôleur comme ci-dessous (qui n'est pas une mise en œuvre de l'option AsyncController cependant) :
public ViewResult Index() {
Task.Factory.StartNew(() => {
//Do an advanced looging here which takes a while
});
return View();
}Comme vous le voyez ici, je lance une opération et je l'oublie. Puis, je reviens immédiatement sans attendre qu'elle soit terminée.
Dans ce cas, doit-on utiliser un thread du pool de threads ? Si c'est le cas, qu'advient-il de ce thread une fois l'opération terminée ? Est-ce que GC vient et nettoie juste après la fin de l'opération ?
Editar:
Pour la réponse de @Darin, voici un exemple de code asynchrone qui communique avec la base de données :
public class FooController : AsyncController {
//EF 4.2 DbContext instance
MyContext _context = new MyContext();
public void IndexAsync() {
AsyncManager.OutstandingOperations.Increment(3);
Task<IEnumerable<Foo>>.Factory.StartNew(() => {
return
_context.Foos;
}).ContinueWith(t => {
AsyncManager.Parameters["foos"] = t.Result;
AsyncManager.OutstandingOperations.Decrement();
});
Task<IEnumerable<Bars>>.Factory.StartNew(() => {
return
_context.Bars;
}).ContinueWith(t => {
AsyncManager.Parameters["bars"] = t.Result;
AsyncManager.OutstandingOperations.Decrement();
});
Task<IEnumerable<FooBar>>.Factory.StartNew(() => {
return
_context.FooBars;
}).ContinueWith(t => {
AsyncManager.Parameters["foobars"] = t.Result;
AsyncManager.OutstandingOperations.Decrement();
});
}
public ViewResult IndexCompleted(
IEnumerable<Foo> foos,
IEnumerable<Bar> bars,
IEnumerable<FooBar> foobars) {
//Do the regular stuff and return
}
}
