Entity Framework 4 Single() vs First() vs FirstOrDefault()

Question

I'm having a devil of a time finding a comparison of the different ways to query for a single item, and when to use each.

Does anyone have a link that compares all these, or a quick explanation as to why you would use one over the other? Are there still more operators that I am unaware of?

Thank you.

Solution 1

Here is an overview of the different methods:

• Find() - when you want to get an item by primary key. This will return null if it can't find an item. It will look in the context before going to the database (as pointed out by Yaron in the comments) which can be an important efficiency factor if you need to get the same entity multiple times while the same context is alive.

• Single() - when you expect exactly one item to be returned by a query. This will throw an exception if the query does not return exactly one item.

• SingleOrDefault() - when you expect zero or one items to be returned by a query (i.e. you are not sure if an item with a given key exists). This will throw an exception if the query does not return zero or one items.

• First() - when you expect one or more items to be returned by a query but you only want to access the first item in your code (ordering could be important in the query here). This will throw an exception if the query does not return at least one item.

• FirstOrDefault() - when you expect zero or more items to be returned by a query but you only want to access the first item in your code (i.e. you are not sure if an item with a given key exists)

Solution 2

I always tend to use FirstOrDefault. If you really want to be picky with performance then you should use FirstOrDefault in EF. Under the covers SingleOrDefault uses top (2) in the query because, it needs to check if there is a second row that matches the criteria and if it does, it throws an exception. Basically in SingleOrDefault you are saying that you want to throw an exception if your query returns more then 1 record.

Solution 3

It's really very simple: Single returns a single item and throw an exception if there is either none or more than one item. First will return the first item or throw when there is no item. FirstOrDefault will return the first item or return the default value (which is null in case the given type is a reference type) when there is no item.

This is the behavior the API is supposed to have. Note however that the underlying implementation could have a different behavior. While Entity Framework obeys this, a O/RM like LLBLGen can also return null when calling First which is a very strange thing. This was a very strange (and stubborn) decision by the designer IMO.

Solution 4

The four methods each have their place; Though you really only have two different operations.

• First - Expecting a result set that contains multiple items, give me the first item in that set.
• Single - Expecting a single result back, give me that item.

The xxxxOrDefault() version just adds on "I don't want to consider an empty result set to be an exceptional circumstance."

Solution 5

On the other side, you can divide these methods by the core logic, like this:

• Method will query database directly: Single(), SingleOrDefault(), First(), FirstOrDefault()
• Method will perform a search in cache before even issuing the query against the database: Find()

For some performance details, especially in the second case you can look here: https://msdn.microsoft.com/en-us/data/hh949853.aspx?f=255&MSPPError=-2147217396#3

In addition, in the first group you can define complex queries, but with Find() method you can provide only entity key for search.

View more solutions

Comments

[asfsadf]

Thanks Steven. I guess I'm still wondering why you'd use one over the other? I've always used FirstOrDefault(), and was curious as to why a lot of the new examples I've seen have switched to Single(). Is there a reason to switch to Single()? Are there others that also accomplish the same thing, that I should consider instead?

[asfsadf]

Do you use all 4 depending on the scenario, or stick to just one?

[Frank Schwieterman]

If you like your code to "fail fast", First() and Single() let your code more precisely say what is expected (so it can fail otherwise)

[asfsadf]

OK, so it seems to me that First() would rarely come in handy. I'm having a hard time coming up with a scenario where Single() wouldn't be the first option. You have a quick one off hand, by chance? Thanks.

[Steve Willcock]

It depends on the scenario. If you know you should always get a single record back from the db, no more, no less, for a given query then Single() is the 'right' one to use. In other situations the others may be more appropriate. In previous versions of EF we were limited to First() and FirstOrDefault() which work for scenarios where you are expecting a single record but they won't warn you if you actually get more than that single record back which could be important depending on the situation.

[asfsadf]

Thanks. I can't see myself needing First() anymore, where Single() wouldn't be better. If I were less dense, I'm sure I could appreciate/understand when to use First() still.

[Matt H]

Unfortunately a lot of developers use First() or FirstOrDefault() purely as a defensive measure, thinking it will avoid an exception when it really just has the potential to hide real problems.

[Steven]

I totally agree with Frank. It’s also about communicating intent. Single expresses clearly that you only expect the result to have one element.

[Mike Chamberlain]

First() makes most sense in the case where you want to retrieve only the object with the highest or lowest of what you are ordering by. For instance, find me the sale with the highest total value. Sales.OrderByDescending(s => s.TotalValue).First();

[mendel]

When retrieving an item by ID which is a primary key there can't be more than one record, so Single just introduces extra overhead. I must be missing something because I can't imagine a scenario where I would use Single instead of First. (I understand the logic, I just don't see where it comes into play in real life, if there should be only 1 result, 99% of the time the data layer will already ensure that there is only 1 possible result)

[Steve Willcock]

You are indeed missing something. To find something by primary key in Entity Framework you would generally use Find(), not any of the First/Single methods. Single and SingleOrDefault are used when you want to retrieve a single record by a field or combination of fields other than the primary key.

[mendel]

@SteveWillcock: thanks for that tip, but I can't seem to find the 'find' method in my project which is using EF4, am I missing a using, or is a new method in later versions?

[Yaron Levi]

All the comments over look an important difference. Find() is the only method that searches the context before hitting the db.

[Steve Willcock]

That's a very good point, I'll add it to the original answer!

[Steven]

Have you ever measured the performance difference between FirstOrDefault and SingleOrDefault to be significant? I'd say it's premature optimization in most cases.

[Bart Calixto]

Another point is when querying a sql database, Single or SingleOrDefault will query for 2 records (limit 2) while First or FirstOrDefault will query for 1 (limit 1).

[mortb]

I tend to use Single() or SingleOrDefault() when I return something of which there should only exist one. The reason I do so is to spot bugs by making badly written queries, which return more than they should, fail. At least in my mind, this will help keeping the data in the system consistent. Of course this is slower, but I would guess that it is not much slower, and I'm willing to pay that price.