В чем разница между
var q_nojoin = from o in one
from t in two
where o.SomeProperty == t.SomeProperty
select new { o, t };
и
var q_join = from o in one
join t in two on o.SomeProperty equals t.SomeProperty
select new { o, t };
Они, похоже, дают мне те же результаты.
Они дают тот же результат, но соединение происходит намного быстрее, если вы не используете LINQ to SQL, чтобы база данных могла оптимизировать запросы.
Я провел тест с двумя массивами, содержащими по 5000 элементов каждый, а запрос с соединением был примерно в 450 раз быстрее (!), чем запрос без соединения.
Если вы используете LINQ to SQL, база данных будет оптимизировать оба запроса для выполнения одного и того же задания, поэтому в этом случае нет разницы в производительности. Однако явное соединение считается более читаемым.
Если вы используете LINQ для другого источника данных, нет оптимизирующего слоя, поэтому существует значительная разница в том, как работают запросы. Соединение использует хеш-таблицу или аналогично быстрому поиску совпадающих значений, в то время как запрос без объединения будет сравнивать все элементы в одной таблице с каждым элементом в другой таблице. Сложность объединения примерно равна O (n + m), а сложность запроса без объединения - O (n * m). Это означает не только то, что запрос без соединения медленнее, но также и то, что он плохо масштабируется, так как данные растут, он будет экспоненциально медленнее.
A JOIN - это средство для объединения полей из двух (или более) таблиц с использованием значений, общих для каждого.
Предложение WHERE указывает, что оператор SQL (язык манипулирования данными) должен влиять только на строки, соответствующие заданным критериям (подумайте о предложении WHERE как ФИЛЬТРЕ).
на практике, в зависимости от множества других факторов, вы можете получить прирост производительности, используя один над другим. Я бы предположил (хотя на самом деле у меня нет оснований для этого), что соединения более склонны, чем предложения WHERE.
edit: оказывается, я совершенно неправ. Там (не должно быть) никакой разницы в производительности между этими двумя типами. Тем не менее, новый стиль (с использованием JOIN) намного понятнее читать (imo), а также Microsoft заявила, что они не будут поддерживать старый стиль (внешнее соединение с использованием WHERE) неопределенно.
Собственно в SQL, операторы join-on могут быть записаны в операторы from-where (если вы действительно этого хотите). Но вы знаете, что мы имеем left join left outer join и т.д. В операторах SQL, что упрощает выражение того, что мы хотим (конечно, вы также можете использовать from-where, но это заставит ваш код выглядеть сумасшедшим). Поэтому мы всегда используем where, если хотим отфильтровать наш результат, а используйте join, если есть связь между таблицами.
Первый запрос говорит, по сути, "Сделайте крест-соединение в этих коллекциях (создавая сущностно матрицу NxM), затем возьмите только те, которые находятся по диагонали, и дайте их мне"
Второй запрос - это, по сути, "Создать список только комбинированных элементов, в которых совпадают параметры".
Результаты те же, но процесс получения там немного отличается.
Так как базы данных SQL, как правило, сильно оптимизированы, поэтому, когда вы запрашиваете первый, сервер просто говорит "Idiot user..." и заменяет второй.
В средах, отличных от SQL (например, Linq-to-Objects), если вы попросите первого, то что он будет делать, и вы увидите значительный успех.