Comment faire des jointures dans LINQ sur plusieurs champs en une seule jointure

J'ai besoin de faire une requête LINQ2DataSet qui fait une jointure sur plusieurs champs (comme

var result = from x in entity
join y in entity2 
       on x.field1 = y.field1 
and 
          x.field2 = y.field2

Je n'ai pas encore trouvé de solution appropriée (je peux ajouter les contraintes supplémentaires à une clause where, mais c'est loin d'être une solution appropriée, ou utiliser cette solution, mais cela suppose une équijoin).

Est-il possible dans LINQ de se joindre à plusieurs champs en une seule jointure?

ÉDITER

var result = from x in entity
             join y in entity2
             on new { x.field1, x.field2 } equals new { y.field1, y.field2 }

est la solution que j'ai référencée en supposant une équijoin ci-dessus.

De plus EDIT

Pour répondre aux critiques selon lesquelles mon exemple d'origine était une équijoin, je reconnais que, Mon exigence actuelle est pour une équijoin et j'ai déjà utilisé la solution que j'ai mentionnée ci-dessus.

J'essaie cependant de comprendre quelles possibilités et meilleures pratiques j'ai / devrais utiliser avec LINQ. Je vais devoir bientôt faire une jointure de requête de plage de dates avec un ID de table, et je devais juste anticiper ce problème.Il semble que je devrai ajouter la plage de dates dans la clause where.

Merci, comme toujours, pour toutes les suggestions et commentaires donnés

La solution avec le type anonyme devrait fonctionner correctement. LINQ ne peut représenter que des équijointures (avec des clauses de jointure, de toute façon), et c'est d'ailleurs ce que vous avez dit que vous souhaitez exprimer de toute façon en fonction de votre requête d'origine.

Si vous n'aimez pas la version avec le type anonyme pour une raison spécifique, vous devez expliquer cette raison.

Si vous voulez faire autre chose que ce que vous aviez initialement demandé, veuillez donner un exemple de ce que vous voulez vraiment faire.

EDIT: Répondre à la modification dans la question: oui, pour faire une jointure "plage de dates", vous devez utiliser une clause where à la place. Ils sont vraiment sémantiquement équivalents, donc c'est juste une question d'optimisations disponibles. Les équijoins fournissent une optimisation simple (dans LINQ to Objects, qui comprend LINQ to DataSets) en créant une recherche basée sur la séquence interne - pensez-y comme une table de hachage de clé à une séquence d'entrées correspondant à cette clé.

Faire cela avec des plages de dates est un peu plus difficile. Cependant, selon exactement ce que vous entendez par "jointure de plage de dates", vous pourrez peut-être faire quelque chose de similaire - si vous prévoyez de créer des "bandes" de dates (par exemple une par an) de sorte que deux entrées qui se produisent dans le la même année (mais pas à la même date) devrait correspondre, alors vous pouvez le faire simplement en utilisant cette bande comme clé. Si c'est plus compliqué, par exemple, un côté de la jointure fournit une plage, et l'autre côté de la jointure fournit une seule date, correspondant si elle se situe dans cette plage, ce serait mieux géré avec une whereclause (après une secondefromclause) OMI. Vous pourriez faire de la magie particulièrement funky en commandant un côté ou l'autre pour trouver des correspondances plus efficacement, mais ce serait beaucoup de travail - je ne ferais ce genre de chose qu'après avoir vérifié si les performances sont un problème.

var result = from x in entity
   join y in entity2 on new { x.field1, x.field2 } equals new { y.field1, y.field2 }

var result = from x in entity1
             join y in entity2
             on new { X1= x.field1, X2= x.field2 } equals new { X1=y.field1, X2= y.field2 }

Vous devez le faire si les noms de colonne sont différents dans deux entités.

Juste pour compléter cela avec une syntaxe de chaîne de méthode équivalente:

entity.Join(entity2, x => new {x.Field1, x.Field2},
                     y => new {y.Field1, y.Field2}, (x, y) => x);

Alors que le dernier argument (x, y) => xest ce que vous sélectionnez (dans le cas ci-dessus, nous sélectionnons x).

Je pense qu'une option plus lisible et flexible consiste à utiliser la fonction Where:

var result = from x in entity1
             from y in entity2
                 .Where(y => y.field1 == x.field1 && y.field2 == x.field2)

Cela permet également de passer facilement de la jointure interne à la jointure gauche en ajoutant .DefaultIfEmpty ().

var result = from x in entity
             join y in entity2
             on new { X1= x.field1, X2= x.field2 } equals new { X1=y.field1, X2= y.field2 }
             select new 
             {
               /// Columns
              };

vous pourriez faire quelque chose comme (ci-dessous)

var query = from p in context.T1

        join q in context.T2

        on

        new { p.Col1, p.Col2 }

        equals

         new { q.Col1, q.Col2 }

        select new {p...., q......};

En utilisant l'opérateur de jointure, vous ne pouvez effectuer que des équijointures. D'autres types de jointures peuvent être construits à l'aide d'autres opérateurs. Je ne sais pas si la jointure exacte que vous essayez de faire serait plus facile à utiliser ces méthodes ou en changeant la clause where. La documentation sur la clause join peut être trouvée ici . MSDN a également un article sur les opérations de jointure avec plusieurs liens vers des exemples d'autres jointures.

Si le nom du champ est différent dans les entités

var result = from x in entity
   join y in entity2 on 
          new {
                field1=   x.field1,
               field2 =  x.field2 
             } 
          equals
         new { 
                field1= y.field1,
                field2=  y.myfield
              }
select new {x,y});

En tant que chaîne de méthode complète qui ressemblerait à ceci:

lista.SelectMany(a => listb.Where(xi => b.Id == a.Id && b.Total != a.Total),
                (a, b) => new ResultItem
                {
                    Id = a.Id,
                    ATotal = a.Total,
                    BTotal = b.Total
                }).ToList();

from d in db.CourseDispatches
                             join du in db.DispatchUsers on d.id equals du.dispatch_id
                             join u in db.Users on du.user_id equals u.id
                             join fr in db.Forumreports on (d.course_id + '_' + du.user_id)  equals  (fr.course_id + '_'+ fr.uid)

ça marche pour moi

Déclarez une classe (type) pour contenir les éléments que vous souhaitez joindre. Dans l'exemple ci-dessous, déclarez JoinElement

 public class **JoinElement**
{
    public int? Id { get; set; }
    public string Name { get; set; }

}

results = from course in courseQueryable.AsQueryable()
                  join agency in agencyQueryable.AsQueryable()
                   on new **JoinElement**() { Id = course.CourseAgencyId, Name = course.CourseDeveloper } 
                   equals new **JoinElement**() { Id = agency.CourseAgencyId, Name = "D" } into temp1