LINQ utilisant plusieurs extensions .join avec plusieurs tables (4) ou plus

Question

Je rencontre des problèmes lors de la configuration d'une requête LINQ en utilisant plusieurs tables de ma base de données. Je suis capable de joindre deux tables sans problème en utilisant la syntaxe LINQ que j'apprends, mais plus que cela me donne des ennuis. Je tente de convertir la requête SQL ci-dessous en format LINQ. Je suis nouveau aux requêtes LINQ et à la façon dont tout se combine, mais c'est ce que j'ai imaginé. C'est un peu compliqué car avec 4 tables, la clause where est tirée de trois des différentes tables et la façon dont je l'ai mise en place m'oblige à disperser la méthode .Where() dans ma requête. Voir ci-dessous:

int num = db.apps.Distinct() 
      .Join(db.application_statuses, 
      a => a.apps_status, 
      aa => aa.application_status, 
      (a, aa) => new { apps = a, application_statuses = aa }) 
      .Where(j => j.apps.admit_status == status && j.apps.apps_stu_type == type && j.apps.apps_start_term == term && j.application_statuses.application_code != null) 
       .Join(db.stu_terms, 
       a => a.apps.applicant, 
       st => st.student_id, 
       (a, st) => new { apps = a, stu_terms = st }) 
       .Where(j => j.stu_terms.st_active_cred >= 0) 
        .Join(db.acad_prog, 
        a => a.apps.apps.apps_program, 
        ap => ap.acad_program, 
        (a, ap) => new { apps = a, acad_prog = ap }) 
         .Join(db.stu_terms, 
         ap => ap.acad_prog.acad_lvl, 
         st => st.st_acad_lvl, 
         (ap, st) => new { acad_prog = ap, stu_terms = st }).Count(); 

Comme vous pouvez le voir, la méthode Où se trouve en deux endroits séparés parce qu'il ne serait en mesure de voir les colonnes de la table spécifique dans ces endroits. La majorité des problèmes que je vois est parce que je ne suis pas au courant si je me joins même à ces quatre tables correctement. La plupart de ces choses sont encore nouvelles pour moi (le placement aléatoire de la méthode Distinct() montre que)

J'apprécie l'aide.

Answer 1

LINQ a déjà rejoint dans votre modèle de domaine (souvenez-vous ICollection si vous utilisez le code-Première)

Vous n » t besoin de spécifier les jointures. Il utilise le chargement différé par défaut, ce qui signifie que les jointures sont automatiquement créées lorsque vous les utilisez (= appelez .ToList()).

Par exemple.

db.Apps.Where(el => el.Students.Any(dl => dl.Type == 'Something')).ToList() 

Si vous voulez des performances plus rapides, vous pouvez utiliser le chargement avec impatience avec Include. Ce qui crée les jointures depuis le début.

db.Apps.Include(el => el.Students.Select(dl => dl.childOfStudents)) 

Depuis que vous êtes nouveau. Vous devez également savoir que toutes vos requêtes sont suivies pour les modifications, ce qui réduit les performances.

Donc, si vous n'avez pas besoin de changer + mettre à jour les objets, utilisez .AsNonQueryable() pour des performances légèrement supérieures.

PS. Vous pouvez toujours utiliser SQL ->https://msdn.microsoft.com/en-us/library/jj592907(v=vs.113).aspx :)

Answer 2

Vous très rarement utiliser rarement Join() dans LINQ avec des bases de données. Au lieu de cela, vous naviguez simplement dans les propriétés de navigation. Avec un modèle approprié c'est aussi simple que:

 var q = from a in apps 
       where a.StuTerms.ActtiveCredits > 0 
       && a.StartTerm = startTerm 
       && a.ApplicationStatus.AdmitStatus = admitStatus 
       && a.StudentType = studentType 
       && a.application_code != null 
       select a; 

    var applicants = q.GroupBy(a => a.ApplicantId).Count(); 

David