LINQ equivalent of List<T>.Find()?

Question

I'm looking at some code that takes an IEnumerable<T> and converts it to a List<T> so it can use List<T>.Find(predicate):

var myEnumerable = ...;
var myList = new List<T>(myEnumerable);
var match = myList.Find(value => value.Aaa == aaa && value.Bbb == bbb);

Is there a way to rewrite this using the LINQ extension methods that has the same effect, but without building an extra List<T> as an intermediate step?

The FirstOrDefault(source, predicate) extension method looks like a good candidate, but trying to figure out if it's exactly equivalent to Find is making my head hurt.

Answer 1

Just for reference, here is a table of some old .NET 2 style List<> instance methods, and their equivalent extension methods in Linq:

METHOD IN List<>                              METHOD IN Linq
------------------------------------------------------------------------------------------

list.Contains(item)                           query.Contains(item)

list.Exists(x => x.IsInteresting())           query.Any(x => x.IsInteresting())
list.TrueForAll(x => x.IsInteresting())       query.All(x => x.IsInteresting())

list.Find(x => x.IsInteresting())             query.FirstOrDefault(x => x.IsInteresting())
list.FindLast(x => x.IsInteresting())         query.LastOrDefault(x => x.IsInteresting())

list.FindAll(x => x.IsInteresting())          query.Where(x => x.IsInteresting())

list.ConvertAll(x => x.ProjectToSomething())  query.Select(x => x.ProjectToSomething())

Of course some of them are not entirely equivalent. In particular Linq's Where and Select use deferred execution, while FindAll and ConvertAll of List<> will execute immediately and return a reference to a new List<> instance.

FindLast will often be faster than LastOrDefault because FindLast actually searches starting from the end of the List<>. On the other hand LastOrDefault(predicate) always runs through the entire sequence (starting from the first item), and only then returns the most "recent" match.

Answer 2

The LINQ equivelent would be to use FirstOrDefault:

var match = myEnumerable.FirstOrDefault(value => value.Aaa == aaa && value.Bbb == bbb);