c# - method - Cómo hacer uniones en LINQ en múltiples campos en una sola unión

left join linq c# ejemplos

Question

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 restricciones adicionales a una cláusula where, pero esto dista mucho de ser una solución adecuada, o usar this solución, pero eso supone un equijoin).

¿Es posible en LINQ unirse en múltiples campos en una única unió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 hice referencia asumiendo un equijoin arriba.

Seguir editando

Para responder a la crítica de que mi ejemplo original era un equijoin, reconozco que, mi requisito actual es para un equijoin y ya he empleado la solución a la que me he referido anteriormente.

Sin embargo, estoy tratando de entender qué posibilidades y mejores prácticas tengo / debo emplear con LINQ. Tendré que hacer una unión de consulta de rango de fechas pronto con un ID de tabla, y 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.

Answer 1

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

Answer 2

Creo que una opción más legible y flexible es utilizar 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 unión interna a unión izquierda agregando .DefaultIfEmpty ().

Answer 3

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

Answer 4

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 quiere 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 solicitó originalmente, por favor dé un ejemplo de lo que realmente quiere hacer.

EDITAR: Respondiendo a la edición en la pregunta: sí, para hacer una combinación de "rango de fechas", necesita usar una cláusula where en su lugar. Son semánticamente equivalentes, por lo que es solo una cuestión de las optimizaciones disponibles. Equijoins proporciona una optimización simple (en LINQ to Objects, que incluye LINQ to DataSets) al crear una búsqueda basada en la secuencia interna. Piense en ello como una tabla hash de clave a una secuencia de entradas que coinciden con esa clave.

Hacer eso con rangos de fechas es algo más difícil. Sin embargo, dependiendo exactamente de lo que quiere decir con una "combinación de fechas", puede hacer algo similar : si planea crear "bandas" de fechas (por ejemplo, una por año) de manera tal que dos entradas que ocurren en el El mismo año (pero no en la misma fecha) debe coincidir, entonces puede hacerlo usando esa banda como la clave. Si es más complicado, por ejemplo, un lado de la unión proporciona un rango, y el otro lado de la unión proporciona una fecha única, que coincide si cae dentro de ese rango, que se manejaría mejor con una cláusula where (después de un segundo from cláusula ) OMI. Podría hacer un poco de magia especialmente divertida ordenando un lado u otro para encontrar 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.

Answer 5

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

Answer 6

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

Mientras que el último argumento (x, y) => x es lo que selecciona (en el caso anterior seleccionamos x ).

Answer 7

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

Answer 8

usted podría 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......};

Answer 9

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

Answer 10

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

Answer 11

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

Answer 12

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.