Performance: .Join vs .Contains – Linq para Entidades

Estoy usando Linq para las entidades para consultar la base de datos para obtener la lista de int para su procesamiento posterior. Tengo dos formas de obtener la lista a continuación:

Primero es:

List lstBizIds = new List() { 1, 2, 3, 4, 5 }; List lstProjectIds = context.Projects.Where(x => lstBizIds.Contains(x.businessId)).Select(x => x.projectId).ToList(); 

Segundo es

 List lstBizIds = new List() { 1, 2, 3, 4, 5 }; List lstProjectIds = context.Projects.Join(lstBizIds, p => p.businessId, u => u, (p, u) => p.projectId).ToList(); 

Ahora mi pregunta es cuál de los métodos anteriores es mejor en cuanto a rendimiento? ¿También afecta el rendimiento si la primera lista, es decir, lstBizIds crece de tamaño? Sugiéreme también otras formas de implementación si eso reduce el rendimiento.

Debe ir con Contains , porque EF puede producir una consulta más eficiente.

Esta sería la unión SQL:

 SELECT Id FROM Projects INNER JOIN (VALUES (1), (2), (3), (4), (5)) AS Data(Item) ON Projects.UserId = Data.Item 

Este sería el SQL Contiene:

 SELECT Id FROM Projects WHERE UserId IN (1, 2, 3, 4, 5, 6) 

IN es más eficiente que JOIN porque el DBMS puede dejar de cuidar la primera coincidencia del IN ; El JOIN siempre termina, incluso después del primer partido.

También es posible que desee comprobar qué consultas se envían realmente a la base de datos. Siempre hay que comparar el SQL, no el código LINQ (obviamente).

Realizar una unión es bastante eficiente porque la condición Where en realidad realiza un producto cartesiano de todas las tablas, luego filtra las filas que satisfacen la condición. Esto significa que la condición donde se evalúa para cada combinación de filas (n1 * n2 * n3 * n4)

El operador Unir toma las filas de las primeras tablas, luego toma solo las filas con una clave coincidente de la segunda tabla, luego solo las filas con una clave coincidente de la tercera tabla, y así sucesivamente. En segundo lugar, contiene funcionaría de manera iterativa, lo que lo hace más lento que unir

Elijo el primero, porque no aumenta la memoria de la computadora.
Si usa ambas matrices para comparar las condiciones, elija entre la segunda.

Acabo de pasar bastante tiempo tratando de encontrar, lo que causó un error de desbordamiento de stack en un progtwig con unas pocas consultas LINQ accediendo a una base de datos de tamaño medio.

para ICollection con ~ 10k elementos en un lado y tabla sql en el otro, un solo cambio de “unirse” a “Contiene” corrigió el error de desbordamiento de stack.

Parece que a pesar del rendimiento comparativo, Contains es una opción más segura.