Come eseguire join in LINQ su più campi in un unico join

Ho bisogno di fare una query LINQ2DataSet che faccia un join su più di un campo (come

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

Ho ancora trovato una soluzione adatta (posso aggiungere ulteriori vincoli a una clausola where, ma questa è ben lungi dall'essere una soluzione adatta, oppure utilizzare questa soluzione, ma che presuppone un equijoin).

È possibile in LINQ unirsi su più campi in un singolo join?

MODIFICARE

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

è la soluzione a cui ho fatto riferimento assumendo un equijoin sopra.

Ulteriore modifica

Per rispondere alle critiche secondo cui il mio esempio originale era un equijoin, riconosco che, il mio attuale requisito è per un equijoin e ho già utilizzato la soluzione di cui sopra.

Sto, tuttavia, cercando di capire quali possibilità e migliori pratiche ho / dovrei utilizzare con LINQ. Presto avrò bisogno di fare una query su un intervallo di date con un ID tabella e sto solo anticipando quel problema. Sembra che dovrò aggiungere l'intervallo di date nella clausola where.

Grazie, come sempre, per tutti i suggerimenti e commenti forniti

La soluzione con il tipo anonimo dovrebbe funzionare correttamente. LINQ può rappresentare solo equijoin (con clausole di join, comunque), e in effetti è quello che hai detto che vuoi esprimere comunque in base alla tua query originale.

Se non ti piace la versione con il tipo anonimo per qualche motivo specifico, dovresti spiegarlo.

Se vuoi fare qualcosa di diverso da quello che hai chiesto inizialmente, ti preghiamo di fare un esempio di ciò che vuoi davvero fare.

EDIT: rispondendo alla modifica nella domanda: sì, per fare un join "intervallo di date", devi usare invece una clausola where. Sono davvero semanticamente equivalenti, quindi è solo una questione di ottimizzazioni disponibili. Gli equijoin forniscono una semplice ottimizzazione (in LINQ to Objects, che include LINQ to DataSet) creando una ricerca basata sulla sequenza interna - pensala come una tabella hash dalla chiave a una sequenza di voci corrispondenti a quella chiave.

Farlo con intervalli di date è un po 'più difficile. Tuttavia, a seconda di cosa si intende esattamente per "unione di intervalli di date", potresti essere in grado di fare qualcosa di simile - se stai pianificando di creare "fasce" di date (ad esempio una all'anno) in modo tale che due voci presenti nel lo stesso anno (ma non nella stessa data) dovrebbe corrispondere, quindi puoi farlo semplicemente usando quella banda come chiave. Se è più complicato, ad esempio un lato del join fornisce un intervallo e l'altro lato del join fornisce una singola data, corrispondente se rientra in tale intervallo, che sarebbe meglio gestita con una whereclausola (dopo un secondofromclausola) IMO. Potresti fare qualche magia particolarmente funky ordinando da una parte o dall'altra di trovare le partite in modo più efficiente, ma sarebbe un sacco di lavoro - farei quel tipo di cose solo dopo aver verificato se le prestazioni sono un problema.

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 }

Devi farlo, se i nomi delle colonne sono diversi in due entità.

Solo per completare questo con una sintassi della catena del metodo equivalente:

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

Mentre l'ultimo argomento (x, y) => xè quello che selezioni (nel caso precedente selezioniamo x).

Penso che un'opzione più leggibile e flessibile sia quella di utilizzare la funzione Where:

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

Ciò consente anche di passare facilmente dal join interno al join sinistro aggiungendo .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
              };

potresti fare qualcosa del tipo (sotto)

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......};

Utilizzando l'operatore join è possibile eseguire solo equijoin. Altri tipi di join possono essere costruiti utilizzando altri operatori. Non sono sicuro che il join esatto che si sta tentando di eseguire sia più semplice utilizzando questi metodi o modificando la clausola where. La documentazione sulla clausola di join è disponibile qui . MSDN ha anche un articolo sulle operazioni di join con più collegamenti ad esempi di altri join.

Se il nome del campo è diverso nelle entità

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});

Come una catena di metodi completa che sarebbe simile a questa:

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)

questo funziona per me

Dichiarare una classe (tipo) per contenere gli elementi a cui si desidera unirsi. Nell'esempio seguente dichiarare 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