TL;DR: if you see someone using the LINQ method First() without a comparator it’s probably a bug and they should have used Single().
I often see code where the author “knows” that a sequence (i.e. an Enumerable<T>) will result in just one element and so they use the LINQ method First() to retrieve the value, e.g.
var value = sequence.First();
However there is also the Single() method which could be used to achieve a similar outcome:
var value = sequence.Single();
So what’s the difference and why do I think it’s probably a bug if you used First?
Both First and Single have the same semantics for the case where the the sequence is empty (they throw) and similarly when the sequence contains only a single element (they return it). The difference however is when the sequence contains more than one element – First discards the extra values and Single will throw an exception.
If you’re used to SQL it’s the difference between using “top” to filter and trying extract a single scalar value from a subquery:
select top 1 x as [value] from . . .
select a, (select x from . . .) as [value] from . . .
(The latter tends to complain loudly if the result set from the subquery is not just a single scalar value or null.)
While you might argue that in the face of a single-value sequence both methods could be interchangeable, to me they say different things with Single begin the only “correct” choice.
Seeing First says to me that the author knows the sequence might contain multiple values and they have expressed an ordering which ensures the right value will remain after the others have been consciously discarded.
Whereas Single suggests to me that the author knows this sequence contains one (and only one) element and that any other number of elements is wrong.
Hence another big clue that the use of First is probably incorrect is the absence of a comparator function used to order the sequence. Obviously it’s no guarantee as the sequence might be being returned from a remote service or function which will do the sorting instead but I’d generally expect to see the two used together or some other clue (method or variable name, or parameter) nearby which defines the order.
The consequence of getting this wrong is that you don’t detect a break in your expectations (a multi-element sequence). If you’re lucky it will just be a test that starts failing for a strange reason, which is where I mostly see this problem showing up. If you’re unlucky then it will silently fail and you’ll be using the wrong data which will only manifest itself somewhere further down the road where it’s harder to trace back.