Cómo hacer combinaciones en LINQ en múltiples campos en combinación única

Necesito hacer una consulta LINQ2DataSet que haga una unión en más de un campo (como

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

Todavía he encontrado una solución adecuada (puedo agregar las restricciones adicionales a una cláusula where, pero esto está lejos de ser una solución adecuada, o usar esta solución, pero eso supone un equijoin).

¿Es posible en LINQ unirse en múltiples campos en una sola combinación?

EDITAR

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

es la solución a la que me referí como asumir un equijoin arriba.

EDITAR más

Para responder a las críticas de que mi ejemplo original era un equijoin, reconozco que, mi requisito actual es un equijoin y ya he empleado la solución que mencioné anteriormente.

Sin embargo, estoy tratando de entender qué posibilidades y mejores prácticas tengo / debo emplear con LINQ. Voy a necesitar hacer una consulta de rango de fechas unirme con una ID de tabla pronto, y solo estaba adelantando ese problema, parece que tendré que agregar el rango de fechas en la cláusula where.

Gracias, como siempre, por todas las sugerencias y comentarios dados.

La solución con el tipo anónimo debería funcionar bien. LINQ solo puede representar equijoins (con cláusulas de unión, de todos modos), y de hecho eso es lo que ha dicho que desea expresar de todos modos en función de su consulta original.

Si no le gusta la versión con el tipo anónimo por alguna razón específica, debe explicar esa razón.

Si desea hacer algo diferente a lo que originalmente solicitó, por favor, dé un ejemplo de lo que realmente quiere hacer.

EDITAR: respondiendo a la edición en la pregunta: sí, para hacer una unión de "intervalo de fechas", debe usar una cláusula where en su lugar. En realidad, son semánticamente equivalentes, por lo que es solo una cuestión de las optimizaciones disponibles. Los equijoins proporcionan una optimización simple (en LINQ to Objects, que incluye LINQ to DataSets) mediante la creación de una búsqueda basada en la secuencia interna; considérelo como una tabla hash de clave a secuencia de entradas que coinciden con esa clave.

Hacer eso con los rangos de fechas es algo más difícil. Sin embargo, dependiendo de exactamente lo que quiere decir con una "unión de rango de fechas", puede hacer algo similar , si planea crear "bandas" de fechas (por ejemplo, una por año) de modo que dos entradas que ocurran en el el mismo año (pero no en la misma fecha) debería coincidir, entonces puede hacerlo simplemente usando esa banda como clave. Si es más complicado, por ejemplo, un lado de la combinación proporciona un rango, y el otro lado de la combinación proporciona una sola fecha, que coincide si cae dentro de ese rango, que se manejaría mejor con una wherecláusula (después de un segundofromcláusula) OMI. Podrías hacer algo de magia particularmente funky ordenando a un lado u otro que busque coincidencias de manera más eficiente, pero eso sería mucho trabajo: solo haría ese tipo de cosas después de verificar si el rendimiento es 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 }

Debe hacer esto si los nombres de las columnas son diferentes en dos entidades.

Solo para completar esto con una sintaxis de cadena de método equivalente:

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

Si bien el último argumento (x, y) => xes lo que selecciona (en el caso anterior seleccionamos x).

Creo que una opción más legible y flexible es usar la función Where:

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

Esto también permite cambiar fácilmente de la unión interna a la unión izquierda agregando .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
              };

podrías hacer algo como (abajo)

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

Usando el operador de unión solo puede realizar equijoins. Se pueden construir otros tipos de combinaciones utilizando otros operadores. No estoy seguro de si la unión exacta que está intentando hacer sería más fácil usando estos métodos o cambiando la cláusula where. La documentación sobre la cláusula de unión se puede encontrar aquí . MSDN también tiene un artículo sobre operaciones de combinación con múltiples enlaces a ejemplos de otras combinaciones.

Si el nombre del campo es diferente en las entidades

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

Como una cadena de método completa que se vería así:

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)

esto funciona para mi

Declare una clase (tipo) para contener los elementos que desea unir. En el siguiente ejemplo, declare 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