FirstOrDefault () прочь LINQ по сравнению с FirstOrDefault () с Лямбдой?

Мне немного любопытно, относительно которого считается "лучшей практикой" когда дело доходит до FirstOrDefault.

Я уже видел этот вопрос, который подобен вопросу, который я имею, но не достаточно близко, что он отвечает на мой вопрос.

Какой из них является "лучшим кодом"? и почему?

var foos = GetMyEnumerableFoos();

var foo1 = (from f in foos
     where f.Bar == "spider monkey"
     select f).FirstOrDefault();

/* OR */

var foo2 = foos.FirstOrDefault(f => f.Bar == "spider monkey");

Я склоняюсь к последнему как IMO, он делает для более чистого кода. Но мне любопытно относительно того, более ли технические "кишки" того, что продолжается, там эффективны другой путь. Это изменяется при использовании различных типов IEnumerables? как DataTables или массивы строк или объекты LINQ?

========= редактирование ==========

Должность принимающего Jon Skeet корректна, я пошел, изучив Отражатель для наблюдения что, Где и FirstOrDefault похожи и здесь то, что я придумал:

В случае foos. Где (f => f. Панель == "обезьяна паука").FirstOrDefault ()

public static IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
{
    if (source == null)
    {
        throw Error.ArgumentNull("source");
    }
    if (predicate == null)
    {
        throw Error.ArgumentNull("predicate");
    }
    if (source is Iterator<TSource>)
    {
        return ((Iterator<TSource>) source).Where(predicate);
    }
    if (source is TSource[])
    {
        return new WhereArrayIterator<TSource>((TSource[]) source, predicate);
    }
    if (source is List<TSource>)
    {
        return new WhereListIterator<TSource>((List<TSource>) source, predicate);
    }
    return new WhereEnumerableIterator<TSource>(source, predicate);
}

который питался бы в:

public static TSource FirstOrDefault<TSource>(this IEnumerable<TSource> source)
{
    if (source == null)
    {
        throw Error.ArgumentNull("source");
    }
    IList<TSource> list = source as IList<TSource>;
    if (list != null)
    {
        if (list.Count > 0)
        {
            return list[0];
        }
    }
    else
    {
        using (IEnumerator<TSource> enumerator = source.GetEnumerator())
        {
            if (enumerator.MoveNext())
            {
                return enumerator.Current;
            }
        }
    }
    return default(TSource);
}

В случае foos. FirstOrDefault (f => f. Панель == "обезьяна паука");

public static TSource FirstOrDefault<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
{
    if (source == null)
    {
        throw Error.ArgumentNull("source");
    }
    if (predicate == null)
    {
        throw Error.ArgumentNull("predicate");
    }
    foreach (TSource local in source)
    {
        if (predicate(local))
        {
            return local;
        }
    }
    return default(TSource);
}

Рассмотрение этого все еще оставляет меня немного смущенным, там была бы эффективность, добавленная при помощи надлежащего итератора для определенных типов объектов? Или действительно ли более эффективно пропустить все это и только запустить цикличное выполнение через и тестирование? Мой пищеварительный тракт снова говорит мне, что это - последний.