When to Use .First and When to Use .Firstordefault With Linq

When to use .First and when to use .FirstOrDefault with LINQ?

I would use First() when I know or expect the sequence to have at least one element. In other words, when it is an exceptional occurrence that the sequence is empty.

Use FirstOrDefault() when you know that you will need to check whether there was an element or not. In other words, when it is legal for the sequence to be empty. You should not rely on exception handling for the check. (It is bad practice and might hurt performance).

Finally, the difference between First() and Take(1) is that First() returns the element itself, while Take(1) returns a sequence of elements that contains exactly one element.

Why use First instead of FirstOrDefault in LINQ?

To respond directly to your specific question (why use First if you can always use FirstOrDefault), there are instances where you cannot use FirstOrDefault, because it loses information! The "default value" is likely a valid element type in the source list. You have no way to distinguish between the first element in the enumeration being null/default vs. there being no elements in the list unless you use First or first check if there are Any elements, which requires double-enumeration.

This is especially true for value-typed enumerables, such as int[]. default(int) is 0, which is also most likely a valid value of the array.

In general, the two methods represent different logical flows. First would be used if not having any elements is "exceptional" (an error), which then want to handle out-of-band in your application. In this scenario, you "expect" to have at least one element. FirstOrDefault returns null on an empty set, which means you need to do additional processing with the returned value. This is similar logic to the Parse vs TryParse methods on int/double/etc. In fact, your question in some ways leads itself to the more general question of why to ever use exceptions.

Since First throws an exception, it lends itself to all of the code-reuse opportunities that exceptions provide. For example, you could do:

try
{
    x = arr1.First();
    y = arr2.First();
    z = arr3.First();
}
catch
{
    throw new ArgumentException();
}

LINQ: When to use SingleOrDefault vs. FirstOrDefault() with filtering criteria

Whenever you use SingleOrDefault, you clearly state that the query should result in at most a single result. On the other hand, when FirstOrDefault is used, the query can return any amount of results but you state that you only want the first one.

I personally find the semantics very different and using the appropriate one, depending on the expected results, improves readability.

LINQ ANY() with First() And FirstOrDefault()

You can use the null-conditional operator to make all of this a lot simpler, assuming that the element type of totals is a reference type:

TotalCashIn = totals?.FirstOrDefault()?.TotalCashIn;

With this:

• If totals is null, the overall result is null due to the first null-conditonal operator
• If totals is empty, FirstOrDefault() will return null, so the overall result is null due to the second null-conditional operator
• Otherwise, the result is the TotalCashIn property of the first element

Difference between First, FirstOrDefault and singleOrDefault keywords in ORM

A quick Google gives you the following Questions which address your question:

• When to use .First and when to use .FirstOrDefault with LINQ?

• LINQ: When to use SingleOrDefault vs. FirstOrDefault() with filtering criteria

You might also find the following article useful as it goes into each method:

• http://www.technicaloverload.com/linq-single-vs-singleordefault-vs-first-vs-firstordefault/

As stated in the answers, the names do give it away (to those familiar), but here's a quick overview:

First

Will return the first entry in a collection (one or more results returned), will throw an exception if no records returned.

FirstOrDefault

Will return the first entry in a collection (one or more results returned), will return the appropriate default object if no records returned

SingleOrDefault

This one isn't really the same as the previously mentioned functions, it will return the result only if only one record is returned, otherwise will return the appropriate default object.

I tend to use First if I know that my results will always return "something", I use FirstOrDefault when I just want the first element but know that sometimes the query might return nothing. I've yet to personally use SingleOrDefault but it should only be used where your query is only ever going to return one row and that returned results should be ignored if more than one result exists.

Difference between LINQ FirstOrDefault vs. Where(...).FirstOrDefault?

If we are talking about Linq to Objects, then there is one notable difference. Second statement

Where(someField => someField.Name.Equals(settings.Text)).FirstOrDefault() 

Will create WhereEnumerableIterator internally, and then it will start enumeration and take first item:

// argument checks and collection optimizations removed
public static IEnumerable<TSource> Where<TSource>(
     this IEnumerable<TSource> source, Func<TSource, bool> predicate)
{
     // it enumerates source and returns items which match predicate
     return new WhereEnumerableIterator<TSource>(source, predicate);
}

public static TSource First<TSource>(this IEnumerable<TSource> source)
{
    using (IEnumerator<TSource> enumerator = source.GetEnumerator())
    {
        if (enumerator.MoveNext())        
            return enumerator.Current;        
    }

    throw Error.NoElements();
}

But first statement will just take first item from source which matches predicate without creating additional enumerator:

// argument checks removed
public static TSource First<TSource>(
    this IEnumerable<TSource> source, Func<TSource, bool> predicate)
{    
    foreach (TSource local in source)
    {
        if (predicate(local))        
            return local;        
    }

    throw Error.NoMatch();
}

So, first one is better in terms of performance:

FirstOrDefault(someField => someField.Name.Equals(settings.Text))

LINQ - Is Where(Predicate).FirstOrDefault() the same as FirstOrDefault(Predicate)

Because method chains in Linq are lazily evaluated, there shouldn't be any material difference between the two. Where.FirstOrDefault will stop executing when it obtains a value, just as FirstOrDefault(Predicate) will.

To put it another way, FirstOrDefault (or any other Linq operator downstream, for that matter) accepts items one at a time from Where for evaluation, not the entire list at once (The result of a Linq operator that returns an IEnumerable is essentially a yield return under the hood).

See Also

Where.FirstOrDefault vs FirstOrDefault

Linq FirstOrDefault

First of all, that is not a valid query. When you use the query syntax (from blah in blah ...), you must have a select clause. It should be more like:

var manager =
    (from n in DataContext.Manager
    where n.Name == "Jones"
    select n).FirstOrDefault();

To answer your question, calling FirstOrDefault() on your query will return the first result of the query or the default value for the type (most likely null in this case). For what you're going for, this won't be an adequate use since the query may contain more than one result.

If you wish to verify that the query only returns a single result, you should use the SingleOrDefault() method instead. It will return either the one item produced by the query, the default value null if it was empty or throw an exception if there was more than one item.

If you don't want to throw an exception, it may be easier to just throw the first two results into a list and verify that you only have one.

var managers =
    (from m in DataContext.Manager
    where m.Name == "Jones"
    select m).Take(2).ToList();
if (managers.Count == 1)
{
    // success!
    var manager = managers.First();
    // do something with manager
}
else
{
    // error
}

In Linq, what's the difference between .FirstOrDefault and .SingleOrDefault

FirstOrDefault() is for when zero or more results are expected to be present in the input collection and the call returns the first item if there are multiple results, Default if none.

SingleOrDefault() is for when zero or one result is expected in the input collection and the call returns the one result if exactly one result is present, Default if no results and exception if more than one result.

---

Related Topics