¿Por qué el operador 'igual' en LINQ se une?

Question

¿Por qué no se enlaza? Simplemente use el operador == en join si t puede usarlo en una cláusula 'where'?

Answer 1

Los dos lados de la igualdad en una unión se tratan como dos expresiones lambda separadas que generan las claves para las dos secuencias.

from category in categories 
join prod in products on category.ID equals prod.CategoryID 

categories.Join(products, 
       category => category.ID, 
       prod => prod.CategoryID, 
       (category, prod) => new { Category = category, Product=prod }); 

El uso de la palabra clave equals lo hace inequívoco cuando una lambda termina y la otra comienza. Para una cláusula donde, por el contrario, hay una sola expresión lambda que decide si cada elemento coincide:

from prod in products 
where prod.CategoryID == 1 

products.Where(prod => prod.CategoryID == 1) 

En teoría, se une podría haber sido implementado con una sola lambda como

from category in categories 
join prod in products on category.ID == prod.CategoryID 

categories.Join(products, 
       (category, prod) => category.ID == prod.CategoryID, 
       (category, prod) => new { Category = category, Product=prod }); 

Sin embargo Al calcular dos teclas y hacer la comparación, LINQ puede usar tablas hash para calcular la unión de manera más eficiente que si tuviera que ejecutar una comparación arbitraria para cada par de elementos.

Answer 2

Tendría que preguntar a los diseñadores, pero está claro que permitir cualquier expresión (booleana) permitiría demasiadas posibilidades. Usar una palabra clave especial como equals hace que sea mucho más fácil restringirla a la especificación como 2 columnas apropiadas.

Encontré una discusión en The Moth.