Entity Framework, DBContext et en utilisant () + async?

votre code:

public Task<tblLanguage> Post(tblLanguage language)
{
    using (var langRepo = new TblLanguageRepository(new Entities()))
    {
        return langRepo.Add(RequestOrganizationTypeEnum, language);
    }
}

dispose du dépôt avant de retourner un Task . Si vous faites le code async :

public async Task<tblLanguage> Post(tblLanguage language)
{
    using (var langRepo = new TblLanguageRepository(new Entities()))
    {
        return await langRepo.Add(RequestOrganizationTypeEnum, language);
    }
}

Il dispose alors du dépôt juste avant que le Task ne soit terminé. Ce qui se passe en fait , c'est que lorsque vous appuyez sur le await , la méthode retourne un Task incomplet (notez que le bloc using est toujours "actif" à ce point). Puis, lorsque la tâche langRepo.Add complète, la méthode Post reprend l'exécution et dispose du langRepo . Lorsque la méthode Post est terminée, le formulaire Task retourné est rempli.

pour plus d'information, voir mon async intro .

j'opterais pour le mode 'one DbContext per request', et réutilise le DbContext dans la requête. Comme toutes les tâches doivent être effectuées à la fin de la demande de toute façon, vous pouvez disposer à nouveau en toute sécurité.

voir: un DbContext par requête en ASP.NET MVC (sans conteneur CIO)

quelques autres avantages:

• certaines entités peuvent déjà être matérialisées dans le DbContext de requêtes précédentes, enregistrement de quelques requêtes supplémentaires.
• vous n'avez pas toutes ces déclarations supplémentaires using qui encombrent votre code.

si vous utilisez des patteurs de programmation À n niveaux appropriés, votre contrôleur ne devrait même pas savoir qu'une demande de base de données est faite. Cela devrait se produire dans votre couche de service.

il y a plusieurs façons de le faire. L'un est de créer 2 constructeurs par classe, un qui crée un contexte et un qui accepte un contexte déjà existant. De cette façon, vous pouvez passer le contexte si vous êtes déjà dans la couche service, ou en créer une nouvelle si c'est la contrôleur / model appelant la couche service.

L'autre est de créer un interne de surcharge de chaque méthode et d'accepter le contexte.

Mais, oui, vous devriez les emballer dans une utilisation.

en théorie, la collecte des ordures devrait nettoyer ces derniers sans les emballer, mais je ne fais pas entièrement confiance au GC.

je d'accord avec @Dirk Boer que la meilleure façon de gérer DbContext durée de vie est avec un conteneur IoC, qui dispose du contexte lors de la requête http est terminée. Toutefois, si ce n'est pas une option, vous pouvez aussi faire quelque chose comme ceci:

var dbContext = new MyDbContext();
var results = await dbContext.Set<MyEntity>.ToArrayAsync();
dbContext.Dispose();

la déclaration using n'est que du sucre syntaxique pour disposer d'un objet à la fin d'un bloc de code. Vous pouvez obtenir le même effet sans bloc using en j'appelle .Dispose vous-même.

en y repensant, vous ne devriez pas avoir d'exception si vous utilisez le mot-clé await dans le bloc d'utilisation:

public async Task<tblLanguage> Post(tblLanguage language)
{
    using (var langRepo = new TblLanguageRepository(new Entities()))
    {
        var returnValue = langRepo.Add(RequestOrganizationTypeEnum, language);
        await langRepo.SaveChangesAsync();
        return returnValue;
    }
}

IMHO, c'est encore un problème causé par l'usage du chargement paresseux. Après avoir disposé de votre contexte, vous ne pouvez plus charger paresseusement une propriété car la disposition du contexte ferme la connexion sous-jacente au serveur de base de données.

si vous avez activé la charge paresseuse et que l'exception se produit après la portée using , alors s'il vous plaît voir https://stackoverflow.com/a/21406579/870604