Comment effacer les entités de suivi dans le cadre de l'entité

Je suis en cours d'exécution un peu de correction de code qui s'exécute sur un gros tas d'entités, comme les progrès de sa vitesse diminue, c'est parce que le nombre d'entités de suivi dans le contexte d'augmenter à chaque itération, Il peut prendre un certain temps donc je suis de l'enregistrement des modifications à la fin de chaque itération. Chaque itération est indépendant et ne change pas le previosuly chargé des entités.

Je sais que je peux désactiver le suivi des modifications, mais je ne veux pas, parce que ce n'est pas une insertion en bloc de code, mais le chargement des entités et de calculer un peu de choses et si les chiffres ne sont pas corrects définir les nouveaux numéros et de mettre à jour/supprimer/créer certaines autres entités. Je sais que je peux créer un nouveau DbContext pour chaque itération et probablement que ça irait plus vite que de faire tous dans le même exemple, mais je pense qu'il pourrait y avoir une meilleure façon.

Donc la question est; Est-il un moyen de nettoyer les entités précédemment chargé dans la base de données de contexte?

  • Vous pouvez les appeler context.Entry(entity).State = EntityState.Detached et il va arrêter le suivi de cette entité.
  • Pourquoi ne pas instancier un nouveau Contexte? Il n'y a vraiment pas grand-généraux, sauf si vous avez besoin d'un code optimisé.
  • entity framework frappe le serveur de base de données uniquement pour la modification des entités, vous n'avez pas de problèmes de performances à ce sujet. mais vous pouvez créer un nouveau contexte uniquement composé de tables de travail pour la rendre plus rapide.
  • détecter les changements prennent du temps, je ne suis pas inquiet DbPerformance.
  • avez-vous fait une mise au point et de suivi de la performance de goulot d'étranglement, ou tout simplement en supposant que cela?
InformationsquelleAutor hazimdikenli | 2014-12-11
  1. 69

    Vous pouvez ajouter une méthode à votre DbContext ou une méthode d'extension qui utilise le ChangeTracker pour détacher tous les Ajoutés, Modifiés et Supprimés entités:

    public void DetachAllEntities()
{
    var changedEntriesCopy = this.ChangeTracker.Entries()
        .Where(e => e.State == EntityState.Added ||
                    e.State == EntityState.Modified ||
                    e.State == EntityState.Deleted)
        .ToList();

    foreach (var entry in changedEntriesCopy)
        entry.State = EntityState.Detached;
}
    • Assurez-vous d'appeler "ToList" après le "Où". Sinon, il jette à un Système.InvalidOperationException: 'Collection a été modifiée; opération d'énumération peut pas execute.'
    • intéressant... peut-être que ce qui se passe dans les versions plus récentes de l'EF. J'ai mis à jour la réponse à inclure votre suggestion parce que cela semble être une bonne chose à faire, juste au cas où. Merci!
    • Dans mon test de l'unité, les participations de l'état est "non modifié", maybse parce que j'utilise une transaction que je roule en arrière à la fin de la méthode d'essai. Cela signifiait que je devais suivi des entrées en état "Détaché" sans vérification de l'état actuel, de sorte que mes tests tout exécuter correctement à la fois. J'appelle le code ci-dessus à droite après le rollback de la transaction, mais je l'ai eu, la restauration signifie sûrement pas été modifiée.
    • de manière explicite de la boucle foreach peut même être incorporé directement dans l'expression lambda après la conversion à la liste: .ForEach(e => e.Etat = EntityState.Détaché);
    • Avez-vous besoin de faire this.Entry(entity.Entity).State = Detached? Je pense que vous pouvez juste faire entity.State = Detached Voir cette réponse
    • (et aussi var entity devrait vraiment être var entry que c'est l'entrée, pas l'Entité)
    • oui, vous avez raison. Merci! Il y avait une certaine gymnastique passe là-bas en raison de la mauvaise appellation 🙂
    • Pensé que ce pourrait être le cas! Je l'ai pris parce que dans une application de test de la mine, le vélo par le biais de 1000 articles et de le marquer comme Détaché a pris environ 6000ms avec le code existant. À propos de 15ms avec le nouveau 🙂
    • Ne devriez-vous pas également utiliser l'e.Etat == EntityState.Inchangée? Bien que l'entité est inchangé, il est toujours suivi dans le cadre et est une partie de l'ensemble d'entités qui sont considérées pendant DetectChanges. E. g. vous ajoutez de la nouvelle entité (il est dans l'état Ajoutée), appelez SaveChanges et l'entité a désormais l'état Inchangé (il va à l'encontre de la UnitOfWork modèle, mais l'op a demandé: je suis de l'enregistrement des modifications à la fin de chaque itération).

    InformationsquelleAutor David Sherret
  2. 13

    1. Possibilité de détacher l'entrée

    dbContext.Entry(entity).State = EntityState.Detached;

    Lorsque vous déconnectez l'entrée de la modification de suivi arrêter le suivi (et devrait aboutir à de meilleures performances)

    Voir: http://msdn.microsoft.com/de-de/library/system.data.entitystate(v=vs. 110).aspx

    2. Possibilité de travailler avec votre propre Status champ + déconnecté contextes

    Peut-être que vous voulez contrôler l'état de votre entité, indépendamment de sorte que vous pouvez utiliser les graphiques déconnecté. Ajouter une propriété pour le statut de l'entité et de transformer ce statut dans le dbContext.Entry(entity).State lorsque vous effectuez des opérations (utilisation d'un référentiel pour ce faire)

    public class Foo
{
    public EntityStatus EntityStatus { get; set; }
}

public enum EntityStatus
{
    Unmodified,
    Modified,
    Added
}

    Voir le lien suivant pour voir un exemple: https://www.safaribooksonline.com/library/view/programming-entity-framework/9781449331825/ch04s06.html

    • Je pense que l'ajout d'une méthode d'extension et de l'exécution sur toutes les entités du ChangeTracker et le détachement devrait fonctionner.
    InformationsquelleAutor road242
  3. 8

    Je suis exécution d'un service windows qui met à jour les valeurs de chaque minute et j'ai eu le même problème. J'ai essayé de courir @DavidSherrets solution, mais après quelques heures, c'est lent. Ma solution était tout simplement de créer un nouveau contexte comme celui-ci pour chaque nouvelle exécution. Simple, mais il fonctionne.

    _dbContext = new DbContext();

    • Façon la plus simple à résoudre.
    • Ce n'est pas Simple, mais qui fonctionne", la solution pour votre objectif. C'est le seul bon. Contexte doit vivre le moins possible, 1 cadre pour 1 opération est la meilleure option.
    • D'accord avec @pwrigshihanomoronimo, le contexte suit la UnitOfWork modèle de conception. Tel que défini par Martin Fowler: > tient à jour une liste des objets touchés par une transaction commerciale et > coordonne la rédaction des modifications et de la résolution de la simultanéité > les problèmes.
    InformationsquelleAutor Ogglas
  4. 2

    Je viens de tomber sur ce problème, et finalement je suis tombé sur la meilleure solution pour ceux qui utilisent le typique .NET de Base de l'injection de dépendances. Vous pouvez utiliser une étendue de DbContext pour chaque opération. Qui va réinitialiser DbContext.ChangeTracker de sorte que SaveChangesAsync() de ne pas s'enliser vérification des entités à partir d'itérations passées. Voici un exemple ASP.NET Contrôleur de Base de la méthode:

        ///<summary>
    ///An endpoint that processes a batch of records.
    ///</summary>
    ///<param name="provider">The service provider to create scoped DbContexts.
    ///This is injected by DI per the FromServices attribute.</param>
    ///<param name="records">The batch of records.</param>
    public async Task<IActionResult> PostRecords(
        [FromServices] IServiceProvider provider,
        Record[] records)
    {
        //The service scope factory is used to create a scope per iteration
        var serviceScopeFactory =
            provider.GetRequiredService<IServiceScopeFactory>();

        foreach (var record in records)
        {
            //At the end of the using block, scope.Dispose() will be called,
            //release the DbContext so it can be disposed/reset
            using (var scope = serviceScopeFactory.CreateScope())
            {
                var context = scope.ServiceProvider.GetService<MainDbContext>();

                //Query and modify database records as needed

                await context.SaveChangesAsync();
            }
        }

        return Ok();
    }

    Étant donné que ASP.NET les grands projets utilisent généralement DbContextPool, ce n'est même pas créer/détruire les DbContext objets. (Dans le cas où vous étiez intéressé, DbContextPool fait des appels DbContext.ResetState() et DbContext.Resurrect(), mais je ne recommanderais pas l'appel de ceux qui sont directement à partir de votre code, comme ils vont probablement changer dans les futures versions.)
    https://github.com/aspnet/EntityFrameworkCore/blob/v2.2.1/src/EFCore/Internal/DbContextPool.cs#L157

    InformationsquelleAutor Matt