Pourquoi l'opérateur 'equals' dans LINQ se joint-il?

Question

Pourquoi ne pas simplement utiliser l'opérateur == dans les jointures si t peut l'utiliser dans une clause 'where'?

Answer 1

Les deux côtés de l'égalité dans une jointure sont traités comme deux expressions lambda distinctes qui génèrent les clés pour les deux séquences. L'utilisation du mot-clé equals rend ambigu le point où un lambda se termine et l'autre commence. Pour une clause where, d'autre part, il y a une seule expression lambda qui décide si chaque élément correspond:

from prod in products 
where prod.CategoryID == 1 

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

En théorie, rejoint aurait pu être mis en œuvre avec un lambda comme

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

Cependant , en calculant deux clés et en effectuant la comparaison elle-même, LINQ peut utiliser des tables de hachage pour calculer la jointure plus efficacement que s'il devait exécuter une comparaison arbitraire pour chaque paire d'éléments.

Answer 2

Vous devrez demander aux concepteurs mais il est clair que permettre n'importe quelle expression (booléenne) permettrait beaucoup trop de possibilités. En utilisant un mot-clé spécial comme equals, il est beaucoup plus facile de le contraindre à la spécification que 2 colonnes appropriées. J'ai trouvé une discussion à propos de The Moth.