Perché l'operatore "uguale" in LINQ si unisce?

Question

Perché link non usa semplicemente l'operatore == in join se t può usarlo in una clausola 'where'?

Answer 1

I due lati dell'uguaglianza in un join vengono considerati due espressioni lambda distinte che generano le chiavi per le due sequenze.

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

Utilizzando la parola uguale rende unabmiguous dove uno lambda finisce e le altre partenze. Per una clausola in cui, d'altra parte, c'è una sola espressione lambda che decide se ogni voce corrisponde:

from prod in products 
where prod.CategoryID == 1 

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

In teoria, si unisce avrebbe potuto essere realizzato con un unico lambda come

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

Tuttavia Calcolando due chiavi e eseguendo il confronto stesso, LINQ può utilizzare le tabelle hash per calcolare l'unione in modo più efficiente rispetto a se dovesse eseguire un confronto arbitrario per ogni coppia di elementi.

Answer 2

Si dovrebbe chiedere ai progettisti, ma è chiaro che consentire qualsiasi espressione (booleana) consentirebbe troppe possibilità. L'utilizzo di una parola chiave speciale come equals rende molto più semplice vincolarlo alle specifiche come 2 colonne appropriate.

Ho trovato una discussione su The Moth.