FirstOrDefault()는 LINQ 대 FirstArDefault()를 Lambda와 함께 사용합니까?

Question

나는 FirstOrDefault와 관련하여 어느 것이 "모범 사례"로 간주되는지 약간 궁금합니다.

나는 이미이 질문을 보았습니다.이 질문은 제가 가지고있는 질문과 비슷하지만 제 질문에 대한 답변에 충분히 가깝지 않습니다.

"더 나은 코드"중 어느 것입니까? 그리고 왜? IMO, 그것은 청소기 코드를 만들면서

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"); 

나는 후자쪽으로 경향이있다. 그러나 나는 그곳에서 벌어지는 일의 기술적 인 "용기"가 다른면에서보다 효율적인지 아닌지에 대해 궁금합니다. 다른 유형의 IEnumerables를 사용하는 경우이 변경됩니까? 같은 DataTables 또는 문자열 배열 또는 LINQ 개체?

========= 존 소총의 게시물 올바른 가정

, 내가 리플렉터에보고 갔다 편집 ==========는 어디서 FirstOrDefault 모양을 참조하고 (=> f.Bar f를 == "거미 원숭이") foos.Where의 경우

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.Bar == "spider monkey")의 경우;

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); 
} 

것을 보면 아직도 나 효율성 특정 개체 유형에 대한 적절한 반복자를 사용하여이 추가됩니다 조금 혼란 잎? 아니면 모든 것을 건너 뛰고 루핑을 시작하고 테스트하는 것이 더 효율적입니까? 내 직감은 나에게 그것이 후자라고 다시 말합니다.

Answer 1

음, "선택"부분은 어쨌든 컴파일러에 의해 제거됩니다, 그래서 당신은 정말 비교하고 있습니다 :

foo.Where(f => f.Bar == "spider monkey") 
    .FirstOrDefault() 

foo.FirstOrDefault(f => f.Bar == "spider monkey") 

대 내가 어떤 이 크게 만들 것입니다 의심은 LINQ에서 개체로의 효율성과 차이가 있습니다. 개인적으로 후자의 버전을 직접 사용하고 싶습니다 ... 다른 곳에서 쿼리의 필터링 부분을 재사용하고 싶지 않으면.

Answer 2

더 간단하기 때문에 후자를 선호합니다.

효율성면에서 나는 당신이 2의 실질적인 차이점을 발견 할 수 있을지 의심 스럽습니다. 실제로는 약간 다르지만 실제로는 행동이 동일합니다.

가장 큰 차이점은 첫 번째 요소가 새로운 IEnumerable<T> 인스턴스를 생성하고 첫 번째 요소에 대해 걸었다는 것입니다. 후자의 경우 기존 IEnumerable<T> 인스턴스는 술어와 일치하는 첫 번째 값으로 이동합니다. 다시 한 번 눈치 채지 못할 것입니다.

Answer 3

두 번째 버전이 훨씬 더 효율적입니다.

첫 번째 버전

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

모든 항목을 항상 루프, 일치하는 항목의 새 컬렉션을 생성.

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

가 일치하는 다음 항목을 통해서만 루프 발견되는 것까지 두 번째 버전이 돌아왔다.