Entity Framework 5 vérification de l'installation

Question

J'ai un projet ASP.NET MVC 3 utilisant .NET Framework 4.0 et LINQ to SQL. Comme j'ai de sérieux problèmes de performances avec certaines requêtes lors de leur première exécution, j'ai décidé d'utiliser Entity Framework 5 afin de tirer parti de la nouvelle fonctionnalité compilée automatiquement par LINQ.

Maintenant, j'ai installé VS 2012, .NET framework 4.5 et Entity Framework 5 et j'ai modifié mon projet pour qu'il pointe vers .NET framework 4.5 et qu'il mette à jour mon fichier Data Context pour utiliser EF5. Les requêtes ont maintenant exactement les mêmes performances, certaines sont si lentes lors de la première exécution que même si je reçois une exception, la seconde fois tout va bien, je me demande si le problème est que le processus de migration n'était peut-être pas correct et j'utilise toujours l'EF4 ou c'est juste un problème de construction de ma requête qui ne peut pas utiliser la fonction compilée automatiquement pour une raison inconnue.

La DLL EntityFramework a la version 5.0, et la DLL System.Data.Entity la version 4, c'est exact, n'est pas? Aucune suggestion?

J'incluent la requête la plus problématique, il récupère paginé le résultat d'une grille (grille Telerik MVC) que je dois construire par 2 requêtes (à l'origine était une phrase SQL avec une sous requête):

 /// <summary> 
    /// Get the elements for the AppLog grid. 
    /// </summary> 
    public void GetAppLogElements(
     int clientID, string language, int functionID, int errorLevel, 
     int numPage, int pageSize, IList<IFilterDescriptor> filterDescriptors, IList<SortDescriptor> sortDescriptors, IList<GroupDescriptor> groupDescriptors, 
     ref IQueryable<Model_AppLog> rows, ref int numRows) 
    { 
     string orderString = string.Empty; 

     var items = 
      from ap in objDataContext.applicationLogs 
      where 
       ap.clientID == clientID && 
       ap.recordGroup != null 
      join alf in objDataContext.appLogFunctions on 
       new { functionID = ap.functionID.Value } equals new { functionID = alf.functionID } 
      join ale in objDataContext.appLogErrorLevels on 
       new { errorLevel = ap.errorLevel.Value } equals new { errorLevel = ale.errorLevelID } 
      join als in objDataContext.appLogSeverities on 
       new { severity = ap.severity.Value } equals new { severity = als.severityID } 
      group new { ap, alf, als } by new { ap.functionID, ap.recordGroup, ap.clerkID } into queryGrouped 
      select new Model_AppLog() 
      { 
       sequence = queryGrouped.Max(c => c.ap.sequence), 
       functionID = queryGrouped.Key.functionID, 
       recordGroup = queryGrouped.Key.recordGroup, 
       clerkID = queryGrouped.Key.clerkID, 
       date = queryGrouped.Min(c => c.ap.date), 
       errorLevel = (queryGrouped.Max(c => c.ap.errorLevel) == null || !queryGrouped.Max(c => c.ap.errorLevel).HasValue ? 0 : queryGrouped.Max(c => c.ap.errorLevel)), 
       severity = queryGrouped.Max(c => c.ap.severity) 
      };    

     if (errorLevel != -1) 
      items = items.Where(column => column.errorLevel >= errorLevel); 

     var _items = 
      from subSelect in items 
      join alf in objDataContext.appLogFunctions on 
       new { functionID = subSelect.functionID.Value } equals new { functionID = alf.functionID } 
      join alft in objDataContext.appLogFunctionTexts on 
       new { alf.functionID, language } equals new { alft.functionID, alft.language } 
      join ale in objDataContext.appLogErrorLevels on 
       new { errorLevel = subSelect.errorLevel.Value } equals new { errorLevel = ale.errorLevelID } 
      join alet in objDataContext.appLogErrorLevelTexts on 
       new { errorLevelID = subSelect.errorLevel.Value, language } equals new { alet.errorLevelID, alet.language } 
      join als in objDataContext.appLogSeverities on 
       new { severity = subSelect.severity.Value } equals new { severity = als.severityID } 
      join alst in objDataContext.appLogSeverityTexts on 
       new { als.severityID, language } equals new { alst.severityID, alst.language } 
      select new Model_AppLog() 
      { 
       sequence = subSelect.sequence, 
       functionID = subSelect.functionID, 
       recordGroup = subSelect.recordGroup, 
       clerkID = subSelect.clerkID, 
       date = subSelect.date, 
       errorLevel = subSelect.errorLevel, 
       severity = subSelect.severity, 
       functionDescription = alft.denotation, 
       errorLevelDescription = alet.denotation, 
       severityDescription = alst.denotation 
      };      

     //Apply filters 
     if (filterDescriptors != null && filterDescriptors.Any()) 
     { 
      _items = _items.Where(ExpressionBuilder.Expression<Model_AppLog>(filterDescriptors)); 
     } 

     if (functionID != -1)    
      _items = _items.Where(column => column.functionID == functionID);        

     //Apply sorting   
     if (sortDescriptors != null) 
     { 
      GlobalMethods objGlobalMethods = new GlobalMethods(); 
      orderString = objGlobalMethods.GetOrderString(sortDescriptors); 
     } 

     //Apply ordering 
     if (orderString != string.Empty)    
      _items = _items.OrderBy(orderString);    
     else    
      _items = _items.OrderByDescending(x => x.date);    

     //Set total number of rows 
     numRows = _items.AsEnumerable<Model_AppLog>().Count();    

     //Get paginated results 
     _items = _items.Skip(pageSize * (numPage - 1)).Take(pageSize);    

     //Set data result    
     rows = _items; 
    } 

Answer 1

Voici un article sur la performance EF: MSDN

la chose la plus importante que vous pouvez faire pour améliorer le temps de démarrage est de précompiler votre point de vue (il y a une section à la fin du document MSDN)

Si vous êtes en utilisant dat abase d'abord, il y a un modèle T4 here que vous pouvez utiliser.

Si vous utilisez le code en premier, il y a un projet here, bien que je ne l'ai pas essayé moi-même.

---

Remarque: lorsque vous mettez à niveau votre projet de .NET 4.0 à 4.5 .NET, vous devez désinstaller le package EF NuGet et réinstallez - il y a version de EF 5 pour les différents environnements d'exécution.