फर्स्टऑर्डडिफॉल्ट() लम्बा के साथ फर्स्टऑर्डडिफॉल्ट() के साथ LINQ बनाम?

Question

मैं थोड़ा उत्सुक हूं क्योंकि इसे 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, यह क्लीनर कोड के लिए बनाता है। लेकिन मैं उत्सुक हूं कि तकनीक पर "क्या चल रहा है" की "गड़बड़ी" है या नहीं, दूसरी तरफ अधिक कुशल है। यदि आप विभिन्न प्रकार के आईनेमरेबल्स का उपयोग कर रहे हैं तो क्या यह बदलता है? डेटाटेबल्स या स्ट्रिंग एरे या LINQ ऑब्जेक्ट्स की तरह?

========= संपादित ==========

मान लिया जाये कि जॉन स्कीट की पोस्ट सही है, मैं परावर्तक में देख चला गया क्या कहाँ और FirstOrDefault की तरह लग रही देखने के लिए, और

foos.Where के मामले में (च => f.Bar == "मकड़ी बंदर") 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 == "मकड़ी बंदर") के मामले में; कि कम से

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

केवल आइटम के माध्यम से लूप जब तक कोई मिलान पाया है और फिर होगा लौट आए।