First vs FirstOrDefault vs Take(1) in LINQ with C#

By the end of this page, you will understand how First(), FirstOrDefault(), and Take(1) behave in LINQ, especially when a sequence may be empty. You will learn when each method is appropriate, what values they return, when they throw exceptions, and which option is most readable in real C# code.

LINQ methods often answer slightly different questions, even when they look similar.

First() asks:

• Give me the first item
• Throw an exception if there is none

FirstOrDefault() asks:

• Give me the first item
• If there is none, return the default value for the type instead

Take(1) asks:

• Give me a sequence containing up to one item
• If there is no item, return an empty sequence

That difference matters because these methods return different kinds of results:

• First() returns a single value
• FirstOrDefault() returns a single value or default
• Take(1) returns an IEnumerable<T> sequence

Why this matters

In real programs, sometimes not finding a result is a bug. Other times, it is normal.

Use First() when:

• you expect at least one matching item
• no result means something is wrong
• you want failure to be explicit

Think of a row of boxes on a shelf.

• First() means: Open the first box. If there is no box, that is an error.
• FirstOrDefault() means: Open the first box. If there is no box, hand me an empty placeholder instead.
• Take(1) means: Give me a tray that can hold one box. If a box exists, put it on the tray. If not, give me an empty tray.

So:

• First() and FirstOrDefault() return the item itself
• Take(1) returns a container that may contain one item

That is the easiest way to remember the difference:

• First* -> single item
• Take -> sequence

The most common forms are:

var item = source.First();
var item = source.FirstOrDefault();
var sequence = source.Take(1);

You can also pass a predicate directly instead of calling Where(...) first:

var item = source.First(x => x == "foo");
var item = source.FirstOrDefault(x => x == "foo");

This is usually cleaner than:

var item = source.Where(x => x == "foo").First();
var item = source.Where(x => x == "foo").FirstOrDefault();

Example 1: First()

var names = new List<string> { "bar", "foo", "baz" };
var result = names.First(x => x == "foo");
Console.WriteLine(result);

Output:

foo

Consider this example:

var numbers = new List<int> { 10, 20, 30 };
var result = numbers.FirstOrDefault(x => x > 15);
Console.WriteLine(result);

Here is what happens step by step:

1. numbers contains three items: 10, 20, 30
2. FirstOrDefault(x => x > 15) starts checking items from the beginning
3. It checks 10
   • 10 > 15 is false
4. It checks 20
   • 20 > 15 is true
5. Because it found the first match, it stops immediately
6. result becomes 20
7. Console.WriteLine(result) prints

Use First() when missing data is unexpected

var adminUser = users.First(u => u.Role == "Admin");

Good when:

• your business rules guarantee at least one admin
• no admin means the system is in an invalid state

Use FirstOrDefault() when missing data is normal

var middleName = names.FirstOrDefault(n => n.Type == "Middle");

Good when:

• the item may or may not exist
• you want to check for null or another default afterward

Use Take(1) when an API expects a sequence

var firstError = logEntries.Where(e => e.Level == "Error").Take(1);

Good when:

• you want to pass the result to another method that accepts IEnumerable<T>
• you want to keep working with sequence operations

Database queries with Entity Framework

In real C# projects, developers usually choose based on intent.

Common pattern: fail fast with First()

var config = configs.First(c => c.Key == "ConnectionString");

This communicates:

• this value must exist
• if it does not, the application should fail rather than continue incorrectly

Common pattern: optional lookup with FirstOrDefault()

var existingUser = users.FirstOrDefault(u => u.Email == email);
if (existingUser == null)
{
    return NotFound();
}

This is a very common web API pattern.

Guard clauses after FirstOrDefault()

var order = orders.FirstOrDefault(o => o.Id == id);
if (order == null)
{
    throw new ArgumentException("Order not found.");
}

This lets you control the error message instead of relying on LINQ's default exception.

Prefer predicate overloads for readability

Instead of:

Mistake 1: Using First() when no match is possible

Broken example:

var user = users.First(u => u.Email == inputEmail);
Console.WriteLine(user.Name);

Problem:

• if no user matches, this throws InvalidOperationException

Better:

var user = users.FirstOrDefault(u => u.Email == inputEmail);
if (user != null)
{
    Console.WriteLine(user.Name);
}

Mistake 2: Forgetting that FirstOrDefault() may return null

Broken example:

var user = users.FirstOrDefault(u => u.Email == inputEmail);
Console.WriteLine(user.Name);

Problem:

• if no user is found, user is null
• accessing user.Name causes a NullReferenceException

Better:

First() vs FirstOrDefault()

// Throws if no match
var item = source.First(x => condition);

// Returns default(T) if no match
var item = source.FirstOrDefault(x => condition);

// Returns sequence with 0 or 1 items
var items = source.Where(x => condition).Take(1);

Quick rules

• Use First() when a result must exist.
• Use FirstOrDefault() when a result may not exist.
• Use Take(1) when you need a sequence, not a single item.
• Prefer First(predicate) over Where(predicate).First().
• Prefer FirstOrDefault(predicate) over Where(predicate).FirstOrDefault().

Empty-sequence behavior

• First() -> exception
• FirstOrDefault() -> default(T)
• Take(1) -> empty IEnumerable<T>

Default values

When should I use First() instead of FirstOrDefault() in LINQ?

Use First() when your logic expects a matching item to always exist, and the absence of one should be treated as an error.

What does FirstOrDefault() return if nothing is found?

It returns default(T). For reference types like string, that is usually null. For value types like int, it is 0.

Is Take(1) the same as FirstOrDefault()?

No. FirstOrDefault() returns a single value. Take(1) returns a sequence that contains zero or one item.

Does First() return the only matching item?

No. It returns the first matching item it encounters. There may be more matches after that.

Should I use Where(...).FirstOrDefault() or FirstOrDefault(...)?

• Single() — similar to First(), but requires exactly one matching item.
• SingleOrDefault() — similar to FirstOrDefault(), but ensures there is at most one match.
• Any() — useful for checking whether at least one matching item exists.
• Where() — filters a sequence before selecting items.
• DefaultIfEmpty() — inserts a default value when a sequence is empty.
• Count() — can check how many items match, though often less efficient than Any() for existence checks.
• IEnumerable<T> — important for understanding why Take(1) returns a sequence.
• Deferred execution — helps explain when LINQ queries actually run.