Pourquoi est-Entity Framework .ToList ().Très lent et comment puis-je accélérer?

Je suis l'interrogation d'une base de données oracle avec EF4.

J'ai 2 tables POINTS (avec près de 100 000 lignes) et COUNTRIES, chaque point ayant une countryCode comme clé étrangère

J'ai les 2 méthodes ci-dessous dans un référentiel

public List<PointsTable> GetAll()
{
    using (Entities context = new Entities())
    {
        List<PointsTable> theList = context.POINTS_TABLE.ToList();
        return theList;
    }
}

public List<PointsTable> GetAllComplete()
{
    using (Entities context = new Entities())
    {
        List<PointsTable> theList = context.POINTS_TABLE.Include("Countries").ToList();
        return theList;
    }
}

La GetAll prend que 5 secondes, mais le GetAllComplete prend 2 minutes!

J'ai l'aide de AsParallel() mais le gain est ridicule.

Puis-je accélérer les choses, ou ce qui est à l'origine pour être lent?

GetAllComplete est de faire la jointure avec le Pays de table et de récupérer tous les points et tous les pays, quand GetAll est juste en train de tous les points sans tables de référence. GetAllComplete devient de plus en plus de lignes. L'extraction de tous les éléments avec ToList() n'est pas une bonne idée lors de l'exploitation des big data.
Mais je suis complètement perdu ici, si je l'exécute en PL/SQL, je n'ai pas de différence entre les 2 ci-dessous requêtes: select * from POINTS_TABLE et select * from POINTS_TABLE a left join COUNTRY_TABLE b on B.CountryCode = A.CountryCode
c'est EF pas de sql, ORM sont beaucoup plus lents que les clients sql, si vous avez vraiment besoin de récupérer 200k lignes à la fois, utilisez ado.net pas de EF. Mais je préfère utiliser linq et fetch ligne par ligne, ou dans 100 points de packs.
sur votre explication de GetAll "est juste en train de tous les points sans tables de référence", mais je peux voir tous les graphique au cours de débogage rapide de montres. Donc, est-ce en raison de la fonctionnalité de débogage pour parcourir dans son ensemble graphique?

OriginalL'auteur DonQi | 2013-10-30

  1. 5

    La raison en est que, pour chaque enregistrement, vous récupérez il est des pays qui, pour 200k enregistrements se multiplie en beaucoup de dossiers.

    Allez-vous à l'interrogation de ces données plus tard pour le ramener à vos besoins spécifiques? Si donc, ne pas .ToList() juste encore.

    Changer votre référentiel de méthodes de retourner IQueryable, de cette façon, vous pouvez limiter la requête pour les données vous avez besoin par la suite de réduire la quantité de données que vous avez mis en mémoire

    private Entities _context;

public PointsRepository(Entities context)
{
    _context = context
}

public IQueryable<PointsTable> GetAll()
{
    return context.POINTS_TABLE;
}

public IQueryable<PointsTable> GetAllComplete()
{
    return context.POINTS_TABLE.Include("Countries");
}

    Vous pouvez ensuite ajouter vos filtres et ToList le plus petit résultat. par exemple,

    using (Entities context = new Entities())
{
    var rep = new PointsRepository(context);

    //This will change the query you send to sql to only 
    //retrieve the specific data you want and should result 
    //in much quicker execution
    var result = rep.GetAllComplete()                    //get all with includes
                    .Where(p => p.Property = "Specific") //refine the query 
                    .ToList()                            //retrieve the data and add to memory
}

    Espère que cette aide

    OriginalL'auteur NinjaNye

  2. 0

    Parallèles(), pas de travail avec Linq to entities, en travaillant uniquement avec Linq to Object.

    Charge 200K avec EF n'est pas bonne de la plaine.

    Vous pouvez améliorer les performances avec le readonly charge:

    context.POINTS_TABLE.MergeOption = MergeOption.NoTracking;

    OriginalL'auteur PakKkO