Question

I’m perplexed by the below.

I’ve been using LINQ in my projects using formats such as:

var query =     
    from obj_i in set1
    join obj_j in set2 on 
        new { 
          JoinField1 = obj_i.SomeField1,
          JoinField2 = obj_i.SomeField2,
          JoinField3 = obj_i.SomeField3,
          JoinField4 = obj_i.SomeField4
        } 
        equals 
        new { 
          JoinField1 = obj_j.SomeOtherField1,
          JoinField2 = obj_j.SomeOtherField2,
          JoinField3 = obj_j.SomeOtherField3,
          JoinField4 = obj_j.SomeOtherField4
        }

But I was recently told that the below is also ‘another way’ of writing LINQ queries.

var query =     
    from obj_i in set1
    join obj_j in set2 on       
    obj_i.SomeField1 = obj_j.SomeOtherField1 and
    obj_i.SomeField2 = obj_j.SomeOtherField2 and
    obj_i.SomeField3 = obj_j.SomeOtherField3 and
    obj_i.SomeField4 = obj_j.SomeOtherField4

As I understand, using the single = is wrong (especially in the case where by == doesn’t apply since you need to use equals, but also using and is wrong, since the correct keyword would be && if you were allowed to use anything but equals in this case.

I can understand the use of && and == in the where clause, which makes it even more outstanding that the above code can be used, since it doesn’t even compile.

Am I missing something?
If so, could you point me to where I can learn of this alternate method of writing LINQ?

Answer 1

But I was recently told that the below is also ‘another way’ of writing LINQ queries.

No, the second syntax you show is incorrect. Just try it, you’ll see that it doesn’t compile.

The join clause in Linq query comprehension syntax is translated to a call to the Join extension method. For instance, this query:

var query =
    from x in a
    join y in b
    on x.Foo equals y.Bar
    select Baz(x, y);

Is translated to:

var query = a.Join(b, x => x.Foo, y => y.Foo, (x, y) => Baz(x, y));

So you can see that the parts on the left and right of equals correspond to different parameters of the Join method: the left part selects the join key for the first source, and the right part selects the key for the second source. These keys are then matched against each other to perform the join. This is the important part: the on clause doesn’t specify a free-form join condition, it specifies how to extract the join key on each side. So the left and right key selectors have to be clearly separated; the second syntax you show can’t work, because there’s no way to extract full key information for either source: the join could only be performed by evaluating the join condition for each (x, y), which is an O(n²) operation instead of a (roughly) O(n) operation.

However, sometimes you need more flexibility than what an equi-join can give; in that case you can use a cross-join and filter the results:

var query =
    from x in a
    from y in b
    where x.Foo == y.Bar
    select Baz(x, y);

Or in your case:

var query =     
    from obj_i in set1
    from obj_j in set2
    where obj_i.SomeField1 == obj_j.SomeOtherField1
    &&    obj_i.SomeField2 == obj_j.SomeOtherField2
    &&    obj_i.SomeField3 == obj_j.SomeOtherField3
    &&    obj_i.SomeField4 == obj_j.SomeOtherField4;