नया [] या नई सूची <T>?

Question

मैं सिर्फ स्टाइल और प्रदर्शन के बारे में सोच रहा हूं। इससे पहले मैं, की तरह कुछ लिखने के लिए

var strings = new List<string> { "a", "b", "c" }; 
var ints = new List<int> { 1, 2, 3}; 

इस्तेमाल किया लेकिन अब मैं इस शैली अधिक पसंद करने के लिए,

var strings = new [] { "a", "b", "c" }.ToList(); 
var ints = new [] { 1, 2, 3}.ToList(); 

मैं दूसरी शैली पसंद करते हैं, लेकिन अब पर विचार करते हैं - यह वास्तव में है जैसे कि यह लिखने के लायक है वह या शायद यह कुशल नहीं है और अधिक परिचालन की आवश्यकता है?

Answer 1

मैं डारिन से असहमत हूं: वे प्रदर्शन के संदर्भ में समकक्ष हैं। बाद वाले संस्करण को एक नई सरणी बनाना है, और ToList फिर इसे नई सूची में कॉपी करेगा। संग्रह प्रारंभकर्ता संस्करण के बराबर है:

var tmp = new List<int>(); 
tmp.Add(1); 
tmp.Add(2); 
tmp.Add(3); 
var ints = tmp; 

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

प्रदर्शन अंतर नगण्य होने की संभावना है, लेकिन यह गैर शून्य है (और किसी भी दिशा में स्पष्ट रूप से बेहतर नहीं - सरणी संस्करण में कम कॉल, लेकिन अधिक आवंटन देखते हैं)।

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

व्यक्तिगत रूप से मैं पहला फॉर्म पसंद करता हूं - मुझे लगता है कि यह स्पष्ट करता है कि आप शुरुआत से ही एक सूची का उपयोग कर रहे हैं।

public static class Lists 
{ 
    public static List<T> Of<T>(T item0) 
    { 
     return new List<T> { item0 }; 
    } 

    public static List<T> Of<T>(T item0, T item1) 
    { 
     return new List<T> { item0, item1 }; 
    } 

    public static List<T> Of<T>(T item0, T item1, T item2) 
    { 
     return new List<T> { item0, item1, item2 }; 
    } 

    ... as many times as you really care about, then ... 

    public static List<T> Of<T>(params T[] items) 
    { 
     return items.ToList(); 
    } 
} 

तो फिर तुम लिख सकते हैं:: एक अन्य विकल्प अपने स्वयं के स्थिर कक्षा में लिखने के लिए होगा

var ints = Lists.Of(1); 
var ints = Lists.Of(1, 2, 3); 
var ints = Lists.Of(1, 2, 3, 5, 6, 7, 8); // Use the params version 

यह अभी भी यह स्पष्ट है कि आप सूचियों का उपयोग कर रहे है, लेकिन प्रकार निष्कर्ष का लाभ लेता है।

आप अच्छी तरह से यह overkill विचार कर सकते हैं, हालांकि :)

Answer 2

मुझे लगता है कि पहले मामले तत्वों को स्वचालित रूप से सूची में जोड़ा जाता है जबकि दूसरे में पहली बार एक सरणी बनाई जाती है, फिर इसे पुनरावृत्त किया जाता है और प्रत्येक तत्व सूची में जोड़ा जाता है।

शायद दूसरा एक एक वास्तविक सरणी सृजन यह देख लायक है से बचने के लिए अनुकूलित किया जाएगा कि इस आपरेशन एक पाश अंदर किया जाता है, तो आप शायद दो बार वस्तु आवंटन राशि (जब तक यह straightly अनुरूप होता है) करने के लिए कोई वास्तविक आवश्यकता के साथ वो करें।

आप बाईटकोड की जाँच करनी चाहिए इसके बारे में सुनिश्चित करने के लिए।

मैं सी # internals के शौकीन नहीं हूँ हालांकि बहुत देखभाल के साथ इस ले!

Answer 3

प्रदर्शन परिप्रेक्ष्य से दोनों के बीच अंतर को अलग करना, पूर्व व्यक्त करता है कि आप बेहतर तरीके से हासिल करने की कोशिश कर रहे हैं। इन सामग्री के साथ तार की एक सरणी की घोषणा

इन सामग्री

और

साथ स्ट्रिंग की एक सूची की घोषणा और फिर इसे परिवर्तित:

अंग्रेजी में कोड व्यक्त विचार करें स्ट्रिंग की एक सूची में

मेरे लिए, पहला अधिक प्राकृतिक लगता है। हालांकि मैं स्वीकार करता हूं कि दूसरा आपके लिए बेहतर हो सकता है।

Answer 4

उदाहरण 1 (वर ints = नई सूची {1, 2, 3};): एक 31.5% भूमि के ऊपर (Eumerable.ToList) और List.Add प्रदान करता है () 8.7% ओवरहेड का कारण बनता है।

उदाहरण के रूप में 2: List.ctor पर 11.8% ओवरहेड और एनसुर क्षमता के लिए 5% का कारण बनता है।

आपको लगता है कि वर ints = नई सूची देख सकते हैं (लाल गेट चींटियों प्रदर्शन प्रोफाइलर से परिणाम) {1, 2, 3}; अधिक संचालन disassembly

var intsx = new[] {1, 2, 3}.ToList(); 
0000003f mov   edx,3 
00000044 mov   ecx,60854186h 
00000049 call  FFF5FD70 
0000004e mov   dword ptr [ebp-4Ch],eax 
00000051 lea   ecx,[ebp-50h] 
00000054 mov   edx,872618h 
00000059 call  61490806 
0000005e lea   eax,[ebp-50h] 
00000061 push  dword ptr [eax] 
00000063 mov   ecx,dword ptr [ebp-4Ch] 
00000066 call  614908E3 
0000006b mov   ecx,dword ptr [ebp-4Ch] 
0000006e call  dword ptr ds:[008726D8h] 
00000074 mov   dword ptr [ebp-54h],eax 
00000077 mov   eax,dword ptr [ebp-54h] 
0000007a mov   dword ptr [ebp-40h],eax 

var ints = new List<int> { 1, 2, 3 }; 
0000007d mov   ecx,60B59894h 
00000082 call  FFF5FBE0 
00000087 mov   dword ptr [ebp-58h],eax 
0000008a mov   ecx,dword ptr [ebp-58h] 
0000008d call  60805DB0 
00000092 mov   eax,dword ptr [ebp-58h] 
00000095 mov   dword ptr [ebp-48h],eax 
00000098 mov   ecx,dword ptr [ebp-48h] 
0000009b mov   edx,1 
000000a0 cmp   dword ptr [ecx],ecx 
000000a2 call  608070C0 
000000a7 nop 
000000a8 mov   ecx,dword ptr [ebp-48h] 
000000ab mov   edx,2 
000000b0 cmp   dword ptr [ecx],ecx 
000000b2 call  608070C0 
000000b7 nop 
000000b8 mov   ecx,dword ptr [ebp-48h] 
000000bb mov   edx,3 
000000c0 cmp   dword ptr [ecx],ecx 
000000c2 call  608070C0 
000000c7 nop 
000000c8 mov   eax,dword ptr [ebp-48h] 
000000cb mov   dword ptr [ebp-44h],eax 
     } 

Answer 5

मैं पहले संस्करण की तरह के माध्यम से पालन किया है। लेकिन के बारे में कार्यक्षमता मुझे लगता है कि सबसे अच्छा सरणी का उपयोग करें और परिभाषित विशेष रूप से तत्वों की संख्या है, तो निश्चित रूप से यह संभव हो सकता है होने जा रहा है के लिए है:

var x = new int[3] { 1, 3, 3 }.ToList();