एक फॉरेस्ट लूप के अंदर या बाहर एक चर की घोषणा: जो तेज / बेहतर है?

Question 1

इनमें से कौन सा तेज / बेहतर है?

यह वाला:

List<User> list = new List<User>();
User u;

foreach (string s in l)
{
    u = new User();
    u.Name = s;
    list.Add(u);
}

या यह एक:

List<User> list = new List<User>();

foreach (string s in l)
{
    User u = new User();
    u.Name = s;
    list.Add(u);
}

मेरा नौसिखिया-विकासशील कौशल मुझे बताता है कि पहला बेहतर है, लेकिन मेरा एक दोस्त मुझे गलत बताता है, लेकिन मुझे एक अच्छा कारण नहीं दे सका कि दूसरा क्यों बेहतर है।

क्या प्रदर्शन में कोई अंतर है?

Question 2

प्रदर्शन-वार दोनों उदाहरण समान IL में संकलित किए गए हैं, इसलिए कोई अंतर नहीं है।

दूसरा बेहतर है, क्योंकि यह अधिक स्पष्ट रूप से आपके इरादे को व्यक्त करता है यदि uकेवल लूप के अंदर उपयोग किया जाता है।

Question 3

किसी भी मामले में, सबसे अच्छा तरीका है कि एक कंस्ट्रक्टर का उपयोग किया जाए जो एक नाम लेता है ... या, अन्यथा, घुंघराले बालों वाली नोटरी का शोषण करें:

foreach (string s in l)
{
    list.Add(new User(s));
}

या

foreach (string s in l)
{
    list.Add(new User() { Name = s });
}

या इससे भी बेहतर, LINQ:

var list = l.Select( s => new User { Name = s});

अब, जबकि आपका पहला उदाहरण, कुछ मामलों में, अप्रतिस्पर्धी रूप से तेज़ हो सकता है, दूसरा बेहतर है क्योंकि यह अधिक पठनीय है, और कंपाइलर चर को छोड़ सकता है (और इसे पूरी तरह से छोड़ सकता है) क्योंकि यह foreachस्कोप के दायरे से बाहर नहीं है।

Question 4

एक घोषणा के कारण किसी भी कोड को निष्पादित नहीं किया जाता है, इसलिए यह प्रदर्शन का मुद्दा नहीं है।

दूसरा वह है जो आप का मतलब है, और यदि आप इसे दूसरे तरीके से करते हैं, तो आप बेवकूफ बनाने की संभावना कम है, इसलिए इसका उपयोग करें। हमेशा छोटे दायरे में चर घोषित करने की कोशिश करें।

और इसके अलावा, Linq का उपयोग करने का बेहतर तरीका है:

List<User> users = l.Select(name => new User{ Name = name }).ToList();

Question 5

जब भी आपके पास प्रदर्शन के बारे में कोई प्रश्न होता है, तो केवल एक ही उपाय होता है - अपने परीक्षण के चारों ओर एक लूप चलाएं और उसे समय दें।

आपके प्रश्न का उत्तर देने के लिए - बिना नाप के :-) या उत्पन्न आईलैश को देखे - किसी भी अंतर को पुनरावृत्तियों की सार्थक संख्या में ध्यान देने योग्य नहीं होगा और आपके कोड में सबसे महंगा ऑपरेशन कुछ आदेशों द्वारा उपयोगकर्ता आवंटन होने की संभावना है। परिमाण का, इसलिए कोड स्पष्टता पर ध्यान केंद्रित करें (जैसा कि आपको सामान्य रूप से होना चाहिए) और 2 के साथ जाएं।

ओह, देर हो चुकी है और मुझे लगता है कि मैं सिर्फ यह कहना चाहूंगा कि इस तरह की चिंता मत करो या इस तरह के विवरण में फंस जाओ।

क

Question 6

दूसरा बेहतर है। आपके पास प्रत्येक पुनरावृत्ति में एक नया उपयोगकर्ता होने का अर्थ है।

Question 7

तकनीकी रूप से, पहला उदाहरण कुछ नैनोसेकंड्स को बचाएगा क्योंकि स्टैक फ्रेम को एक नया चर आवंटित करने के लिए स्थानांतरित नहीं करना पड़ेगा, लेकिन यह सीपीयू समय की इतनी छोटी मात्रा है जो आप इसे नोटिस नहीं करेंगे, ऐसा कंपाइलर नहीं करता है किसी भी अंतर दूर अनुकूलन।

Question 8

इस परिदृश्य में, दूसरा संस्करण बेहतर है।

सामान्य तौर पर, यदि आपको केवल पुनरावृत्ति के शरीर के भीतर मूल्य तक पहुंचने की आवश्यकता है, तो दूसरा संस्करण चुनें। दूसरी ओर, यदि कुछ अंतिम स्थिति है तो चर लूप के शरीर से परे होगा, तो घोषित करें फिर पहले संस्करण का उपयोग करें।

Question 9

प्रदर्शन में कोई अंतर नहीं होना चाहिए।

Question 10

एक और संदर्भ जो ऊपर जैसा दिखता है:

http://social.msdn.microsoft.com/forums/en-US/csharplanguage/thread/d43aaba5-a58b-4610-bea4-5bc5d6741f98

Question 11

मैं इस मुद्दे को सत्यापित करने के लिए गया था। मेरे गंदे परीक्षणों पर आश्चर्यचकित रूप से पता चलता है कि हर समय दूसरा विकल्प थोड़ा और भी तेज है।

namespace Test
{
  class Foreach
  {
    string[] names = new[] { "ABC", "MNL", "XYZ" };

    void Method1()
    {
      List<User> list = new List<User>();
      User u;

      foreach (string s in names)
      {
        u = new User();
        u.Name = s;
        list.Add(u);
      }
    }

    void Method2()
    {

      List<User> list = new List<User>();

      foreach (string s in names)
      {
        User u = new User();
        u.Name = s;
        list.Add(u);
      }
    }
  }

  public class User { public string Name; }
}

मैंने सीआईएल को सत्यापित किया लेकिन यह समान नहीं है।

इसलिए मैंने कुछ तैयार किया जो मैं बहुत बेहतर परीक्षण करना चाहता था।

namespace Test
{
  class Loop
  { 

    public TimeSpan method1 = new TimeSpan();
    public TimeSpan method2 = new TimeSpan();

    Stopwatch sw = new Stopwatch();

    public void Method1()
    {
      sw.Restart();

      C c;
      C c1;
      C c2;
      C c3;
      C c4;

      int i = 1000;
      while (i-- > 0)
      {
        c = new C();
        c1 = new C();
        c2 = new C();
        c3 = new C();
        c4 = new C();        
      }

      sw.Stop();
      method1 = method1.Add(sw.Elapsed);
    }

    public void Method2()
    {
      sw.Restart();

      int i = 1000;
      while (i-- > 0)
      {
        var c = new C();
        var c1 = new C();
        var c2 = new C();
        var c3 = new C();
        var c4 = new C();
      }

      sw.Stop();
      method2 = method2.Add(sw.Elapsed);
    }
  }

  class C { }
}

इस मामले में भी दूसरा तरीका हमेशा जीत रहा था लेकिन फिर मैंने सीआईएल को सत्यापित कर दिया कि कोई अंतर नहीं है।

मैं सीआईएल-रीडिंग गुरु नहीं हूं, लेकिन मुझे कोई घोषणा का मुद्दा दिखाई नहीं देता है। जैसा कि पहले ही बताया गया था कि घोषणा आवंटन नहीं है, इसलिए इस पर कोई प्रदर्शन जुर्माना नहीं है।

परीक्षा

namespace Test
{
  class Foreach
  {
    string[] names = new[] { "ABC", "MNL", "XYZ" };

    public TimeSpan method1 = new TimeSpan();
    public TimeSpan method2 = new TimeSpan();

    Stopwatch sw = new Stopwatch();

    void Method1()
    {
      sw.Restart();

      List<User> list = new List<User>();
      User u;

      foreach (string s in names)
      {
        u = new User();
        u.Name = s;
        list.Add(u);
      }

      sw.Stop();
      method1 = method1.Add(sw.Elapsed);
    }

    void Method2()
    {
      sw.Restart();

      List<User> list = new List<User>();

      foreach (string s in names)
      {
        User u = new User();
        u.Name = s;
        list.Add(u);
      }

      sw.Stop();
      method2 = method2.Add(sw.Elapsed);
    }
  }

  public class User { public string Name; }