লিনকিউ ক্যোয়ারিতে টোলিস্ট () বা টোআর্রে () কল করা ভাল?


518

আমি প্রায়শই সেই ক্ষেত্রে চলে যাই যেখানে যেখানেই আমি এটি ঘোষণা করি ঠিক সেখানেই কোনও ক্যোয়ারী তুলে ধরতে চাই। এটি সাধারণত কারণ আমার এটির উপরে একাধিকবার পুনরাবৃত্তি করা দরকার এবং এটি গণনা করা ব্যয়বহুল। উদাহরণ স্বরূপ:

string raw = "...";
var lines = (from l in raw.Split('\n')
             let ll = l.Trim()
             where !string.IsNullOrEmpty(ll)
             select ll).ToList();

এটি কাজ করে। তবে আমি যদি ফলাফলটি পরিবর্তন করতে যাচ্ছি না, তবে আমি ToArray()পরিবর্তে কল করতে পারি ToList()

আমি ToArray()প্রথমে কল করে বাস্তবায়ন করা হয়েছে ToList()এবং তাই কেবল কল করার চেয়ে কম স্মৃতিশক্তি কম কিনা তা আমি ভাবছি ToList()

আমি কি পাগল? আমি কি কেবল কল করতে পারি ToArray()- নিরাপদ এবং জ্ঞানটিতে সুরক্ষিত যে মেমরিটি দু'বার বরাদ্দ করা হবে না?


10
নেট থেকে পর্দার আড়ালে কী ঘটে তা আপনি যদি কখনও জানতে চান তবে আমি সত্যিই সুপারিশ করছি। নেট প্রতিফলক
ডেভিড হেডলুন্ড

32
@ ডেভিডহেল্ড আমি । নেট উত্স কোডের প্রস্তাব দিই ।
Gqqnbig

1
আমি সম্মত হই না যে একটি গুরুত্বপূর্ণ সম্পর্ক থাকা সত্ত্বেও স্ট্যাকওভারফ্লো / প্রশ্ন / 6750447/c-toarray-performance এই প্রশ্নের সদৃশ। মেমরি উভয়ই ব্যবহার (এই প্রশ্ন) এবং কর্মক্ষমতা (অন্যান্য প্রশ্ন) এবং আকর্ষণীয় এবং অদ্বিতীয় বিষয় বিবেচনা করে। এগুলি আলাদাভাবে বর্ণনা করা যায়, তবে উভয়েরই একে অপরের থেকে একটি বেছে নেওয়ার সিদ্ধান্ত নেওয়া উচিত। আমি এই বা অন্য প্রশ্নের উত্তরের কোনওটিকেই বিস্তৃত হিসাবে সুপারিশ করতে পারি না। বেশ কয়েকটি উত্তর রয়েছে যেগুলি যখন একত্রে নেওয়া হয় তখন কীভাবে একে অপরের থেকে কীভাবে বেছে নেওয়া যায় তার সম্পূর্ণ আলোচনা সরবরাহ করে।
স্টিভ

1
@ জিকিউকিএনবিগ - সবচেয়ে দরকারী মন্তব্য! ধন্যবাদ :-)
মার্ক কুপার

উত্তর:


365

আপনার ব্যবহার করা উচিত অন্যান্য প্রতিবন্ধকতাগুলি পূরণ করার জন্য যদি আপনার কেবল অ্যারের প্রয়োজন হয় না ToList। সংখ্যাগরিষ্ঠ পরিস্থিতিতে এর ToArrayচেয়ে বেশি মেমরি বরাদ্দ করা হবে ToList

উভয় স্টোরেজের জন্য অ্যারে ব্যবহার করে তবে ToListআরও নমনীয় বাধা রয়েছে। সংগ্রহের উপাদানগুলির সংখ্যার চেয়ে কমপক্ষে বৃহত্তর হতে এটির অ্যারে প্রয়োজন। অ্যারে বড় হলে, এটি কোনও সমস্যা নয়। তবে ToArrayঅ্যারের উপাদানগুলির সংখ্যার জন্য হুবহু আকারের হওয়া দরকার।

এই সীমাবদ্ধতা মেটাতে ToArrayপ্রায়শই তার চেয়ে আরও বেশি বরাদ্দ থাকে ToList। একবার এটির পরিমাণ যথেষ্ট বড় হয়ে গেলে এটি একটি অ্যারের বরাদ্দ করে যা হুবহু সঠিক আকার এবং উপাদানগুলিকে সেই অ্যারেটিতে অনুলিপি করে। কেবলমাত্র এটি এড়াতে পারে যখন অ্যারের জন্য বেড়ে ওঠা অ্যালগরিদম ঠিক তখনই সংঘবদ্ধ হওয়া উপাদানগুলির সংখ্যার সাথে মিলিত হয় (অবশ্যই সংখ্যালঘুতে)।

সম্পাদনা

কয়েকজন লোক আমাকে অতিরিক্ত অব্যবহৃত মেমরির List<T>মানটির পরিণতি সম্পর্কে জিজ্ঞাসা করেছে ।

এটি একটি বৈধ উদ্বেগ। যদি তৈরি সংগ্রহটি দীর্ঘকাল বেঁচে থাকে, তৈরি হওয়ার পরে কখনই সংশোধন করা হয় না এবং জেন 2 হিপ অবতরণ করার উচ্চ সম্ভাবনা থাকে তবে আপনি ToArrayসামনের দিকে অতিরিক্ত বরাদ্দ নেওয়া ভাল be

সাধারণভাবে যদিও আমি এটি বিরল ক্ষেত্রে বলে মনে করি। এটি অনেক বেশি ToArrayকল দেখতে পাওয়া যায় যা মেমরির অন্যান্য স্বল্পস্থায়ী ব্যবহারের ক্ষেত্রে তাত্ক্ষণিকভাবে প্রেরণ করা হয়, যা ক্ষেত্রে ToListপ্রদর্শিত হয় আরও ভাল।

এখানে কীটি হ'ল প্রোফাইল, প্রোফাইল এবং তারপরে আরও কিছু প্রোফাইল।


14
অন্যদিকে, অ্যারে তৈরির জন্য লেগওয়ার্কের জন্য বরাদ্দ করা অতিরিক্ত মেমরি কী আবর্জনা সংগ্রহের জন্য উপযুক্ত হবে না, তবে তালিকার অতিরিক্ত ওভারহেড কী থাকবে? আমি বলছি এটি সহজ রাখুন। আপনার যদি উপাদানগুলি যুক্ত করতে বা মুছে ফেলার দরকার হয় তবে তার জন্য একটি সরঞ্জাম রয়েছে। আপনি যদি না করেন তবে তার জন্য আলাদা সরঞ্জাম রয়েছে। যেটি বোঝায় তা ব্যবহার করুন। যদি পরে, আপনি স্মৃতি এবং কর্মক্ষমতা নিয়ে একটি সমস্যা আবিষ্কার করেন এবং এটি এটি হয় , এটি পরিবর্তন করুন।
অ্যান্টনি পেগ্রাম

1
@ অ্যান্থনিপাগ্রাম হ্যাঁ এটি করা বৈধ বিবেচনা। যদি মানটি দীর্ঘমেয়াদী স্টোরেজে ব্যবহার করা হচ্ছে, কোনও পরিবর্তন করা হবে না এবং সম্ভাব্যভাবে এটিকে জেনার 2 তে পরিণত করবে তবে জেনার 2 এর apগলকে দূষিত করে অতিরিক্ত অতিরিক্ত বরাদ্দ দেওয়া এখন আপনার পক্ষে ভাল। আইএমই যদিও আমি খুব কমই এটি দেখতে পাই। টোআরিকে অন্য স্বল্পস্থায়ী লিনকুই ক্যোয়ারিতে তাত্ক্ষণিকভাবে পাঠানো দেখতে আরও বেশি সাধারণ।
জারেডপাড়

2
আলোচনার এই দিকটি অন্তর্ভুক্ত করার জন্য
@ অ্যান্থনি পেগ্রাম

8
@ জ্যারেডপ্যার আমি বুঝতে পারি না ToArrayযে এটির সঠিক অবস্থানগুলির আকারের যেখানে ToList<>স্পষ্টতই এটির স্বয়ংক্রিয় খুচরা স্থান রয়েছে তার চেয়ে বেশি মেমরি কীভাবে বরাদ্দ করা যায় । (স্বতঃসংশ্লিষ্ট)
রই নমির

5
@ রোয়নিমির কারণ টোআরাই প্রথমে ওভারহেড দিয়ে টোললিস্ট-স্টাইলের বরাদ্দ দেয়, তারপরে একটি অতিরিক্ত সঠিক-আকার বরাদ্দ করে।
টিম্বো

169

পারফরম্যান্স পার্থক্য List<T>তাত্পর্যপূর্ণ হবে, যেহেতু গতিশীল আকারের অ্যারে হিসাবে প্রয়োগ করা হয়। হয় কল করা ToArray()(যা Buffer<T>অ্যারে বাড়ানোর জন্য অভ্যন্তরীণ শ্রেণীর ব্যবহার করে) বা ToList()(যা কল করেList<T>(IEnumerable<T>) কনস্ট্রাক্টরকে ) এগুলিকে অ্যারে রাখার এবং অ্যারে বাড়ানোর বিষয়টি শেষ হবে যতক্ষণ না এটি সমস্ত মানায়।

আপনি যদি এই সত্যটির দৃ concrete় নিশ্চয়তা চান, তবে প্রতিবিস্মকে সম্পর্কিত প্রশ্নে পদ্ধতিগুলি বাস্তবায়নের জন্য দেখুন - আপনি দেখতে পাবেন যে তারা প্রায় অভিন্ন কোডে সিদ্ধ হয়।


2
একটি আকর্ষণীয় সত্য যেটি আমি জুড়ে এসেছি তা হ'ল আপনার প্রক্ষেপণে একটি গ্রুপের মাধ্যমে সংজ্ঞায়িত একটি গোষ্ঠী ব্যবহারের কারণে সংযুক্ত প্রশ্নের জন্য লিনককে এসকিউএল-তে এই গ্রুপের জন্য গণনা পুনরুদ্ধারের জন্য আরও একটি উপ-কোয়েরি যুক্ত করার কারণ ঘটায়। আমি ধরে নিচ্ছি যে এই ক্ষেত্রে আইটেমগুলি পুনরুদ্ধার করার আগে সংগ্রহের আকারটি জানা যাবে এবং ফলস্বরূপ ফলাফল কার্যকর করার সময় সঠিক আকারের অ্যারে তৈরি করা যেতে পারে যা প্রক্রিয়াজাতকরণ এবং মেমরির সংস্থানগুলিতে সংরক্ষণ করতে পারে।
jpierson

133
গণনাটি আগে থেকেই জানা থাকলে, পারফরম্যান্সটি অভিন্ন। যাইহোক, যদি কাউন্ট আগাম জানা যায় না, মধ্যে একমাত্র পার্থক্য ToArray()এবং ToList()সাবেক অতিরিক্ত, যা সম্পূর্ণ অ্যারে কপি জড়িত, যেহেতু আধুনিক বাড়তি ছাঁটা নেই ছাঁটা আছে, কিন্তু 25 গড়ে ব্যবহার আরও% মেমরি। যদি ডেটা টাইপ বড় হয় তবে এটির মধ্যেই কেবল প্রভাব পড়বে struct। চিন্তার জন্য শুধু খাবার।
স্কট রিপ্পি 26'10

9
@ এল্ড্রিচকনড্রাম 25% এই যুক্তি থেকে এসেছে: যদি আইটেমের সংখ্যাটি অজানা থাকে তবে কল করা ToListবা ToArrayএকটি ছোট বাফার তৈরি করে শুরু করা হবে। যখন সেই বাফারটি পূর্ণ হয়, এটি বাফারের ক্ষমতা দ্বিগুণ করে এবং অবিরত থাকে। ক্ষমতাটি সর্বদা দ্বিগুণ হওয়ার কারণে অব্যবহৃত বাফার সর্বদা 0% থেকে 50% এর মধ্যে থাকবে।
স্কট রিপ্পি

2
@ স্কটআরপি আমি আইনিউবারেবল উত্স থেকে নতুন তালিকার উত্সটি সন্ধান করেছি, এবং এটি পরীক্ষা করে যে আইনামেবারেবল একটি আইকোলিকেশন কিনা এবং যদি এটি হয় তবে এটি গণনা সম্পত্তি থেকে সঠিক আকারের সাথে একটি অ্যারের বরাদ্দ করে শুরু হয়, সুতরাং এটি ToList () অবশ্যই দ্রুততর হবে এমন ক্ষেত্রে হবে। একটি সম্পূর্ণ উত্তরে সেই সত্যটি অন্তর্ভুক্ত থাকতে পারে, যদিও আমি মনে করি এটি সবচেয়ে সাধারণ ঘটনা নয়।
অ্যান্ডিক্লা

3
অ্যান্ডি ক্ল্লো উভয়কেই Listএবং Bufferএটি পরীক্ষা করবে ICollection, এক্ষেত্রে পারফরম্যান্সটি অভিন্ন হবে।
স্কট রিপ্পি

54

(সাত বছর পরে ...)

অন্যান্য কয়েকটি (ভাল) উত্তর মাইক্রোস্কোপিক পারফরম্যান্স পার্থক্যের দিকে মনোনিবেশ করেছে যা ঘটবে।

এই পোস্টটি কেবল অ্যারের দ্বারা উত্পাদিত ( ) দ্বারা উত্পাদিত এর মধ্যে বিদ্যমান শব্দার্থক পার্থক্য উল্লেখ করার পরিপূরক ।IEnumerator<T>T[]List<T>

উদাহরণ সহকারে সেরা চিত্রিত:

IList<int> source = Enumerable.Range(1, 10).ToArray();  // try changing to .ToList()

foreach (var x in source)
{
  if (x == 5)
    source[8] *= 100;
  Console.WriteLine(x);
}

উপরের কোডটি ব্যতিক্রম ছাড়াই চলবে এবং আউটপুট উত্পাদন করবে:

1
2
3
4
5
6
7
8
900
10

এটি দেখায় যে IEnumarator<int>একটি দ্বারা প্রত্যাবর্তন int[]করা হয়েছে অ্যারেরটি তৈরির পরে অ্যারেটি সংশোধিত হয়েছে কিনা তা ট্র্যাক করে না।

নোট করুন যে আমি স্থানীয় ভেরিয়েবলটিকে sourceএকটি হিসাবে ঘোষণা করেছি IList<int>। সেভাবে আমি নিশ্চিত করে দিচ্ছি যে সি # সংকলক foreachবিবৃতিটি এমন কোনও কিছুতে অনুকূলিত করে না যা for (var idx = 0; idx < source.Length; idx++) { /* ... */ }লুপের সমতুল্য । আমি var source = ...;পরিবর্তে এটি ব্যবহার করলে সি # সংকলকটি এটি করতে পারে । .NET ফ্রেমওয়ার্কের আমার বর্তমান সংস্করণে এখানে ব্যবহৃত প্রকৃত গণকটি একটি জন-পাবলিক রেফারেন্স-টাইপ System.SZArrayHelper+SZGenericArrayEnumerator`1[System.Int32]তবে অবশ্যই এটি বাস্তবায়নের বিশদ।

এখন, আমি যদি পরিবর্তন .ToArray()মধ্যে .ToList(), আমি শুধুমাত্র পাবেন:

1
2
3
4
5

একটি System.InvalidOperationExceptionধাক্কা বলার পরে:

সংগ্রহটি পরিবর্তন করা হয়েছিল; গণনা ক্রিয়াকলাপ চালানো হতে পারে না।

এই ক্ষেত্রে অন্তর্নিহিত গণক হ'ল সর্বজনীন পরিবর্তনীয় মান-প্রকার System.Collections.Generic.List`1+Enumerator[System.Int32]( IEnumerator<int>এই ক্ষেত্রে কোনও বাক্সের ভিতরে বাক্সযুক্ত কারণ আমি ব্যবহার করি IList<int>)।

উপসংহারে, একটি সূচক দ্বারা উত্পাদিত গণকList<T>তালিকাটি গণনার সময় তালিকাটি পরিবর্তন করে কিনা তা পরীক্ষা করে রাখে, অন্যদিকে উত্পাদিত পরিগণকT[]তা না করে। তাই এই পার্থক্য যখন মধ্যবর্তী নির্বাচন বিবেচনা.ToList()এবং.ToArray()

লোকেরা প্রায়শই একটি অতিরিক্ত যোগ করে .ToArray()বা .ToList()কোনও সংগ্রহকে আটকায় যা এটি একটি গণকের জীবনকালীন সময়ে সংশোধিত হয়েছিল কিনা তা ট্র্যাক করে।

(কেহ জানতে চায় তাহলে কিভাবেList<> কিনা সংগ্রহ পরিবর্তিত হয়েছিল ট্র্যাক রাখে, সেখানে একটি বেসরকারী ক্ষেত্র _versionএই শ্রেণীর যা সব পরিবর্তন করা হয় List<>আপডেট করা হয়।)


28

আমি @ এমকেন্ডারের সাথে একমত যে পারফরম্যান্সের পার্থক্য তুচ্ছ হওয়া উচিত। যাইহোক, আমি এটি নিশ্চিত হওয়ার জন্য বেঞ্চমার্ক করতে চেয়েছিলাম, তাই আমি করেছি - এবং এটি তাত্পর্যপূর্ণ নয়।

Testing with List<T> source:
ToArray time: 1934 ms (0.01934 ms/call), memory used: 4021 bytes/array
ToList  time: 1902 ms (0.01902 ms/call), memory used: 4045 bytes/List

Testing with array source:
ToArray time: 1957 ms (0.01957 ms/call), memory used: 4021 bytes/array
ToList  time: 2022 ms (0.02022 ms/call), memory used: 4045 bytes/List

প্রতিটি উত্স অ্যারে / তালিকায় 1000 টি উপাদান রয়েছে। সুতরাং আপনি দেখতে পাচ্ছেন যে সময় এবং মেমরির উভয়ই পার্থক্য নগণ্য।

আমার উপসংহার: আপনি টোলিস্ট ()ও ব্যবহার করতে পারেন , যেহেতু List<T>কোনও অ্যারের চেয়ে আরও বেশি কার্যকারিতা সরবরাহ করে, যদি না সত্যিকারের কিছু বাইট স্মৃতি আপনার কাছে আসে really


1
আমি আশ্চর্য হয়েছি যদি আপনি structকোনও আদিম ধরণের বা শ্রেণীর পরিবর্তে একটি বৃহত ব্যবহার করেন তবে এই ফলাফলটি আলাদা হবে ।
স্কট রিপ্পি

12
তালিকা <T>। তালিকাস্ত্র ???? কী বুঝ? আপনি এটিতে একটি IEnumerable দেওয়ার আরও ভাল চেষ্টা করবেন, যা আইকোলিকেশন ইন্টারফেস বাস্তবায়ন করে না।
গ্রিগরি

8
আমি নিশ্চিত করতে চেয়েছিলাম যে আমি কেবলমাত্র ToListবা ToArrayকল করার সময়টিই পরিমাপ করছি এবং কোনওটির গণনা নয় IEnumerable। তালিকা <T> .ToList () এখনও একটি নতুন তালিকা তৈরি করে <T> - এটি কেবল "এটিকে ফেরত" দেয় না।
EMP

23
-1 যখন প্যারামিটার সরবরাহ করা হয় তখন এর আচরণগুলি ToArray()এবং ToList()খুব বেশি পার্থক্য হয় ICollection<T>- তারা কেবল একটি একক বরাদ্দ এবং একটি একক অনুলিপি অপারেশন করে। উভয় List<T>এবং Arrayবাস্তবায়ন ICollection<T>, তাই আপনার benchmarks এ সব বৈধ নয়।
মোহাম্মদ দেহগান

1
আগ্রহী প্রত্যেকের জন্য, আমি পৃথক উত্তর হিসাবে আমার নিজস্ব বেঞ্চমার্ক পোস্ট করেছি । এটি বাস্তবায়নের সমস্যা .Select(i => i)এড়াতে ব্যবহার করে ICollection<T>এবং একটি নিয়ন্ত্রণ গোষ্ঠী অন্তর্ভুক্ত করে এটি দেখার জন্য যে কতটা সময় IEnumerable<>প্রথমদিকে উত্স থেকে পুনরাবৃত্তি করা হয় ।
স্ট্রিপলিং ওয়ারিয়র

19

ToList()আপনি যদি এটি ব্যবহার করেন তবে সাধারণত এটি পছন্দ করা হয় IEnumerable<T>(উদাহরণস্বরূপ, ওআরএম থেকে)। যদি ক্রমের দৈর্ঘ্য শুরুতে জানা না যায়, ToArray()তালিকার মতো গতিশীল দৈর্ঘ্যের সংগ্রহ তৈরি করে এবং তারপরে এটি অ্যারে রূপান্তর করে, যা অতিরিক্ত সময় নেয়।


26
আমি সিদ্ধান্ত নিয়েছি যে এই ক্ষেত্রে পাঠযোগ্যতার কর্মক্ষমতা হ্রাস পাবে umps আমি এখন কেবলমাত্র ToList ব্যবহার করি যখন আমি উপাদানগুলি যোগ করা চালিয়ে যাওয়ার আশা করি। অন্যান্য সমস্ত ক্ষেত্রে (বেশিরভাগ ক্ষেত্রে) আমি টোআর্রে ব্যবহার করি। কিন্তু ইনপুট জন্য ধন্যবাদ!
ফ্র্যাঙ্ক ক্রুয়েজার

5
আইএলএসপি সন্ধান, Enumerable.ToArray()কল new Buffer<TSource>(source).ToArray()। বাফার কনস্ট্রাক্টরে যদি উত্সটি আইকোলিকেশনটি প্রয়োগ করে তবে এটি উত্সকে বলে op কপিটো (আইটেমগুলি, 0), এবং তারপরে .ToArray () সরাসরি অভ্যন্তরীণ আইটেম অ্যারে প্রদান করে। সুতরাং কোনও রূপান্তর নেই যা ক্ষেত্রে অতিরিক্ত সময় নেয়। যদি উত্স আইকোলিকেশনটি বাস্তবায়ন করে না তবে উপরে স্কট রিপির মন্তব্য দ্বারা বর্ণিত বর্ণনামূলকভাবে অ্যারের শেষ থেকে অতিরিক্ত অব্যবহৃত অবস্থানগুলি ছাঁটাই করার জন্য টোআর্রে একটি অ্যারে অনুলিপি তৈরি করবে।
ব্র্যান্ডনএগ্রার

19

স্মৃতি সর্বদা দুবার বরাদ্দ হবে - বা এর কাছাকাছি কিছু something যেহেতু আপনি কোনও অ্যারের আকার পরিবর্তন করতে পারবেন না, উভয় পদ্ধতিই ক্রমবর্ধমান সংগ্রহে ডেটা সংগ্রহ করার জন্য কিছু প্রকারের পদ্ধতি ব্যবহার করবে। (ঠিক আছে, তালিকাটি নিজের মধ্যে ক্রমবর্ধমান সংগ্রহ))

তালিকাটি অভ্যন্তরীণ স্টোরেজ হিসাবে একটি অ্যারে ব্যবহার করে এবং যখন প্রয়োজন হয় তখন ক্ষমতা দ্বিগুণ করে। এর অর্থ এই যে আইটেমগুলির গড় 2/3 কমপক্ষে একবারে পুনঃনির্ধারণ করা হয়েছে, তাদের মধ্যে অর্ধেক কমপক্ষে দু'বার পুনঃব্যবস্থাপন করা হয়েছে, কমপক্ষে তিনবারের মধ্যে অর্ধেক এবং আরও অনেক কিছু। এর অর্থ হ'ল প্রতিটি আইটেম গড়ে গড়ে 1.3 বার পুনঃনির্ধারণ করা হয়েছে, যা খুব বেশি ওভারহেড নয়।

এও মনে রাখবেন যে আপনি স্ট্রিং সংগ্রহ করছেন, সংগ্রহে কেবল স্ট্রিংয়ের উল্লেখ রয়েছে, স্ট্রিংগুলি নিজেই পুনরায় স্থানান্তরিত হয় না।


এটি জিজ্ঞাসা করার জন্য একটি অজ্ঞাত জিনিস হতে পারে, তবে 2/3, 1/3, 1/6 আপনি যে লজিকের বাহ্যরেখা মনে করছেন তা তালিকার অ্যারেটি বাড়ানো যেতে পারে? এটি হ'ল অ্যারের শেষে মুক্ত স্থান রয়েছে যাতে বিদ্যমান বরাদ্দটি সরানো না যায়?

@ জোনফএল ট্রেডস: না, অ্যারেটি কখনও স্থানে বাড়ানো হয় না। নেট এ মেমরি ম্যানেজমেন্ট সহজভাবে এটি করে না। যদি এটির জায়গায় প্রসারিত করা হয় তবে আইটেমগুলি পুনরায় স্থান দেওয়ার প্রয়োজন হবে না।
গুফা

আহ, আমি দেখছি: যে আইটেমগুলি পুনরায় স্থানান্তরিত হয় না তাদের তা করতে হয়নি কারণ তারা চূড়ান্ত বরাদ্দে ছিল in পূর্ববর্তী বরাদ্দগুলিতে বরাদ্দকৃত সমস্ত আইটেম সরানো হয়েছে তবে অ্যারে দৈর্ঘ্যে লোগারিথমিক বৃদ্ধির কারণে এটি একটি গণনাকারী ভগ্নাংশ। স্পষ্ট করার জন্য ধন্যবাদ!

19

এটি 2020 এর বাইরে এবং প্রত্যেকে .NET কোর 3.1 ব্যবহার করছে তাই আমি বেঞ্চমার্ক.নেট দিয়ে কিছু বেঞ্চমার্ক চালানোর সিদ্ধান্ত নিয়েছি।

টিএল; ডিআর: টুআর () আরও ভাল পারফরম্যান্স ভিত্তিক এবং আপনি যদি সংগ্রহটি পরিবর্তনের পরিকল্পনা না করেন তবে আরও ভাল কাজ করে।


    [MemoryDiagnoser]
    public class Benchmarks
    {
        [Params(0, 1, 6, 10, 39, 100, 666, 1000, 1337, 10000)]
        public int Count { get; set; }

        public IEnumerable<int> Items => Enumerable.Range(0, Count);

        [Benchmark(Description = "ToArray()", Baseline = true)]
        public int[] ToArray() => Items.ToArray();

        [Benchmark(Description = "ToList()")]
        public List<int> ToList() => Items.ToList();

        public static void Main() => BenchmarkRunner.Run<Benchmarks>();
    }

ফলাফলগুলি হ'ল:


    BenchmarkDotNet=v0.12.0, OS=Windows 10.0.14393.3443 (1607/AnniversaryUpdate/Redstone1)
    Intel Core i5-4460 CPU 3.20GHz (Haswell), 1 CPU, 4 logical and 4 physical cores
    Frequency=3124994 Hz, Resolution=320.0006 ns, Timer=TSC
    .NET Core SDK=3.1.100
      [Host]     : .NET Core 3.1.0 (CoreCLR 4.700.19.56402, CoreFX 4.700.19.56404), X64 RyuJIT
      DefaultJob : .NET Core 3.1.0 (CoreCLR 4.700.19.56402, CoreFX 4.700.19.56404), X64 RyuJIT


    |    Method | Count |          Mean |       Error |      StdDev |        Median | Ratio | RatioSD |   Gen 0 | Gen 1 | Gen 2 | Allocated |
    |---------- |------ |--------------:|------------:|------------:|--------------:|------:|--------:|--------:|------:|------:|----------:|
    | ToArray() |     0 |      7.357 ns |   0.2096 ns |   0.1960 ns |      7.323 ns |  1.00 |    0.00 |       - |     - |     - |         - |
    |  ToList() |     0 |     13.174 ns |   0.2094 ns |   0.1958 ns |     13.084 ns |  1.79 |    0.05 |  0.0102 |     - |     - |      32 B |
    |           |       |               |             |             |               |       |         |         |       |       |           |
    | ToArray() |     1 |     23.917 ns |   0.4999 ns |   0.4676 ns |     23.954 ns |  1.00 |    0.00 |  0.0229 |     - |     - |      72 B |
    |  ToList() |     1 |     33.867 ns |   0.7350 ns |   0.6876 ns |     34.013 ns |  1.42 |    0.04 |  0.0331 |     - |     - |     104 B |
    |           |       |               |             |             |               |       |         |         |       |       |           |
    | ToArray() |     6 |     28.242 ns |   0.5071 ns |   0.4234 ns |     28.196 ns |  1.00 |    0.00 |  0.0280 |     - |     - |      88 B |
    |  ToList() |     6 |     43.516 ns |   0.9448 ns |   1.1949 ns |     42.896 ns |  1.56 |    0.06 |  0.0382 |     - |     - |     120 B |
    |           |       |               |             |             |               |       |         |         |       |       |           |
    | ToArray() |    10 |     31.636 ns |   0.5408 ns |   0.4516 ns |     31.657 ns |  1.00 |    0.00 |  0.0331 |     - |     - |     104 B |
    |  ToList() |    10 |     53.870 ns |   1.2988 ns |   2.2403 ns |     53.415 ns |  1.77 |    0.07 |  0.0433 |     - |     - |     136 B |
    |           |       |               |             |             |               |       |         |         |       |       |           |
    | ToArray() |    39 |     58.896 ns |   0.9441 ns |   0.8369 ns |     58.548 ns |  1.00 |    0.00 |  0.0713 |     - |     - |     224 B |
    |  ToList() |    39 |    138.054 ns |   2.8185 ns |   3.2458 ns |    138.937 ns |  2.35 |    0.08 |  0.0815 |     - |     - |     256 B |
    |           |       |               |             |             |               |       |         |         |       |       |           |
    | ToArray() |   100 |    119.167 ns |   1.6195 ns |   1.4357 ns |    119.120 ns |  1.00 |    0.00 |  0.1478 |     - |     - |     464 B |
    |  ToList() |   100 |    274.053 ns |   5.1073 ns |   4.7774 ns |    272.242 ns |  2.30 |    0.06 |  0.1578 |     - |     - |     496 B |
    |           |       |               |             |             |               |       |         |         |       |       |           |
    | ToArray() |   666 |    569.920 ns |  11.4496 ns |  11.2450 ns |    571.647 ns |  1.00 |    0.00 |  0.8688 |     - |     - |    2728 B |
    |  ToList() |   666 |  1,621.752 ns |  17.1176 ns |  16.0118 ns |  1,623.566 ns |  2.85 |    0.05 |  0.8793 |     - |     - |    2760 B |
    |           |       |               |             |             |               |       |         |         |       |       |           |
    | ToArray() |  1000 |    796.705 ns |  16.7091 ns |  19.8910 ns |    796.610 ns |  1.00 |    0.00 |  1.2951 |     - |     - |    4064 B |
    |  ToList() |  1000 |  2,453.110 ns |  48.1121 ns |  65.8563 ns |  2,460.190 ns |  3.09 |    0.10 |  1.3046 |     - |     - |    4096 B |
    |           |       |               |             |             |               |       |         |         |       |       |           |
    | ToArray() |  1337 |  1,057.983 ns |  20.9810 ns |  41.4145 ns |  1,041.028 ns |  1.00 |    0.00 |  1.7223 |     - |     - |    5416 B |
    |  ToList() |  1337 |  3,217.550 ns |  62.3777 ns |  61.2633 ns |  3,203.928 ns |  2.98 |    0.13 |  1.7357 |     - |     - |    5448 B |
    |           |       |               |             |             |               |       |         |         |       |       |           |
    | ToArray() | 10000 |  7,309.844 ns | 160.0343 ns | 141.8662 ns |  7,279.387 ns |  1.00 |    0.00 | 12.6572 |     - |     - |   40064 B |
    |  ToList() | 10000 | 23,858.032 ns | 389.6592 ns | 364.4874 ns | 23,759.001 ns |  3.26 |    0.08 | 12.6343 |     - |     - |   40096 B |

    // * Hints *
    Outliers
      Benchmarks.ToArray(): Default -> 2 outliers were removed (35.20 ns, 35.29 ns)
      Benchmarks.ToArray(): Default -> 2 outliers were removed (38.51 ns, 38.88 ns)
      Benchmarks.ToList(): Default  -> 1 outlier  was  removed (64.69 ns)
      Benchmarks.ToArray(): Default -> 1 outlier  was  removed (67.02 ns)
      Benchmarks.ToArray(): Default -> 1 outlier  was  removed (130.08 ns)
      Benchmarks.ToArray(): Default -> 1 outlier  was  detected (541.82 ns)
      Benchmarks.ToArray(): Default -> 1 outlier  was  removed (7.82 us)

    // * Legends *
      Count     : Value of the 'Count' parameter
      Mean      : Arithmetic mean of all measurements
      Error     : Half of 99.9% confidence interval
      StdDev    : Standard deviation of all measurements
      Median    : Value separating the higher half of all measurements (50th percentile)
      Ratio     : Mean of the ratio distribution ([Current]/[Baseline])
      RatioSD   : Standard deviation of the ratio distribution ([Current]/[Baseline])
      Gen 0     : GC Generation 0 collects per 1000 operations
      Gen 1     : GC Generation 1 collects per 1000 operations
      Gen 2     : GC Generation 2 collects per 1000 operations
      Allocated : Allocated memory per single operation (managed only, inclusive, 1KB = 1024B)
      1 ns      : 1 Nanosecond (0.000000001 sec)

1
আপনি যদি সংগ্রহটি পরিবর্তনের পরিকল্পনা না করে থাকেন তবে আমার ধারণা ToImmutableArray()হ'ল (সিস্টেম.কলেশনগুলি থেকে.অনামনীয় প্যাকেজ থেকে) আরও ভালভাবে লক্ষ্য করা যেতে পারে 😉
আর্টুরো টরেস সানচেজ

@ আর্টুরো টরেস সানচেজ সত্য, তবে যদি সংগ্রহটি কোনও পদ্ধতির বাইরে প্রকাশ না করা হয় তবে আমি কেবল একটি অ্যারে ব্যবহার করব।
Tyrrrz

2
এর জন্য ধন্যবাদ. নির্বাচিত উত্তরটি কেবল একটি যুক্তি এবং সেই যুক্তি অনুসরণ করে ফলাফল অনুমান করে। এটি বৈজ্ঞানিকভাবে করার জন্য এবং বোনাস হিসাবে কতটা পার্থক্য রয়েছে তা জানেন, কেবল একটি আসল উপায় জানতে হবে।
জোনাস

15

সম্পাদনা করুন : এই উত্তরের শেষ অংশটি বৈধ নয়। তবে, বাকিটি এখনও দরকারী তথ্য, তাই আমি এটি ছেড়ে দেব।

আমি জানি এটি একটি পুরানো পোস্ট, তবে একই প্রশ্ন থাকার পরে এবং কিছু গবেষণা করার পরে, আমি একটি আকর্ষণীয় কিছু পেয়েছি যা ভাগ করে নেওয়ার মতো হতে পারে।

প্রথমত, আমি @ মাকান্দার এবং তার উত্তরের সাথে একমত। তিনি পারফরম্যান্স অনুযায়ী বলার ক্ষেত্রে সঠিক, দু'জন একরকম।

যাইহোক, আমি System.Linq.Enumerableএক্সটেনশানগুলির নেমস্পেসের পদ্ধতিগুলি একবার দেখার জন্য রিফ্লেক্টরটি ব্যবহার করছি এবং আমি খুব সাধারণ অপ্টিমাইজেশন লক্ষ্য করেছি।
যখনই সম্ভব, IEnumerable<T>উত্সটি পদ্ধতিতে অনুকূলকরণ করতে IList<T>বা কাস্ট করা হয় ICollection<T>। উদাহরণস্বরূপ, দেখুন ElementAt(int)

মজার কথা, মাইক্রোসফ্ট কেবলমাত্র এর জন্য অনুকূলিতকরণ বেছে নিয়েছিল IList<T>, তবে তা নয় IList। দেখে মনে হচ্ছে মাইক্রোসফ্ট IList<T>ইন্টারফেসটি ব্যবহার করতে পছন্দ করে ।

System.Arrayকেবল প্রয়োগগুলি IList, সুতরাং এটি কোনও এক্সটেনশন অপটিমাইজেশন থেকে উপকৃত হবে না।
অতএব, আমি জমা দিচ্ছি যে .ToList()পদ্ধতিটি ব্যবহার করা সবচেয়ে ভাল অনুশীলন ।
আপনি যদি কোনও এক্সটেনশন পদ্ধতি ব্যবহার করেন, বা অন্য পদ্ধতিতে তালিকাটি পাস করেন তবে এটির জন্য অনুকূলিত হওয়ার সম্ভাবনা রয়েছে IList<T>


16
আমি একটি পরীক্ষা করেছি এবং অবাক করার মতো কিছু খুঁজে পেয়েছি। একটি অ্যারে IList <T> প্রয়োগ করে! সিস্টেমটি বিশ্লেষণ করতে রিফ্লেক্টর ব্যবহার করে r অ্যারে কেবল আইলিস্ট, আইকোলিকেশন, আইনিউমারেবল তবে রানটাইম রিফ্লেকশন ব্যবহার করে জানতে পেরেছিলাম যে স্ট্রিং [] এর আইলিস্ট, আইকোলিকেশন, আইনিউমারেবল, আইলিস্ট <স্ট্রিং> আইকোলিকেশন <স্ট্রিংয়ের একটি উত্তরাধিকার শৃঙ্খলা রয়েছে >, অনুমিত <স্ট্রিং>। অতএব, আমার কাছে @ এমকুন্ডারের চেয়ে ভাল উত্তর নেই!
স্কট রিপ্পি

@ স্কটআরপি হ্যাঁ আপনি যে অদ্ভুত পর্যবেক্ষণটি লক্ষ্য করেছেন এটি আসলে একটি "হ্যাক" এরই অংশ - এবং এটি "স্থির আকার" এবং অনুরূপ বৈশিষ্ট্যগুলি (আপনি কীভাবে এটি ছড়িয়ে দিয়েছেন তার উপর নির্ভর করে কিছু অসঙ্গতি সহ) এর সাথে কিছু অদ্ভুত প্রভাব রয়েছে। নেট নেট সোর্স-কোডের অভ্যন্তরে এই বিষয়টিকে স্পর্শ করে কিছু মোটামুটি বড় মন্তব্য রয়েছে। সংযোগ না দেওয়ার জন্য দুঃখিত তবে আমি যদি সঠিকভাবে মনে করি তবে এটি সন্ধান করা বেশ সহজ (অ্যারে-শ্রেণীর ভিতরে)। (এবং এখানে আরও একটি বড় অসঙ্গতি নিয়ে আলোচনা নিয়ে একটি প্রশ্ন রয়েছে .... কোথাও ...> __>)
অ্যানোরজাকান

: @ScottRippey শুধুমাত্র FYI আমি এই উত্তর আপনার মন্তব্য কি আছে যা পাওয়া stackoverflow.com/a/4482567/2063755
ডেভিড Klempfner

14

আমি এখানে অন্যান্য মানদণ্ডের লোকদের অভাবের দেখা পেয়েছি, সুতরাং এটিতে আমার ক্র্যাক এখানে। আপনি যদি আমার পদ্ধতিতে কোনও ভুল খুঁজে পান তবে আমাকে জানান।

/* This is a benchmarking template I use in LINQPad when I want to do a
 * quick performance test. Just give it a couple of actions to test and
 * it will give you a pretty good idea of how long they take compared
 * to one another. It's not perfect: You can expect a 3% error margin
 * under ideal circumstances. But if you're not going to improve
 * performance by more than 3%, you probably don't care anyway.*/
void Main()
{
    // Enter setup code here
    var values = Enumerable.Range(1, 100000)
        .Select(i => i.ToString())
        .ToArray()
        .Select(i => i);
    values.GetType().Dump();
    var actions = new[]
    {
        new TimedAction("ToList", () =>
        {
            values.ToList();
        }),
        new TimedAction("ToArray", () =>
        {
            values.ToArray();
        }),
        new TimedAction("Control", () =>
        {
            foreach (var element in values)
            {
                // do nothing
            }
        }),
        // Add tests as desired
    };
    const int TimesToRun = 1000; // Tweak this as necessary
    TimeActions(TimesToRun, actions);
}


#region timer helper methods
// Define other methods and classes here
public void TimeActions(int iterations, params TimedAction[] actions)
{
    Stopwatch s = new Stopwatch();
    int length = actions.Length;
    var results = new ActionResult[actions.Length];
    // Perform the actions in their initial order.
    for (int i = 0; i < length; i++)
    {
        var action = actions[i];
        var result = results[i] = new ActionResult { Message = action.Message };
        // Do a dry run to get things ramped up/cached
        result.DryRun1 = s.Time(action.Action, 10);
        result.FullRun1 = s.Time(action.Action, iterations);
    }
    // Perform the actions in reverse order.
    for (int i = length - 1; i >= 0; i--)
    {
        var action = actions[i];
        var result = results[i];
        // Do a dry run to get things ramped up/cached
        result.DryRun2 = s.Time(action.Action, 10);
        result.FullRun2 = s.Time(action.Action, iterations);
    }
    results.Dump();
}

public class ActionResult
{
    public string Message { get; set; }
    public double DryRun1 { get; set; }
    public double DryRun2 { get; set; }
    public double FullRun1 { get; set; }
    public double FullRun2 { get; set; }
}

public class TimedAction
{
    public TimedAction(string message, Action action)
    {
        Message = message;
        Action = action;
    }
    public string Message { get; private set; }
    public Action Action { get; private set; }
}

public static class StopwatchExtensions
{
    public static double Time(this Stopwatch sw, Action action, int iterations)
    {
        sw.Restart();
        for (int i = 0; i < iterations; i++)
        {
            action();
        }
        sw.Stop();

        return sw.Elapsed.TotalMilliseconds;
    }
}
#endregion

আপনি লিনিকপ্যাড স্ক্রিপ্টটি এখানে ডাউনলোড করতে পারেন ।

ফলাফল: ToArray বনাম ToList কর্মক্ষমতা

উপরের কোডটি টুইঙ্ক করে, আপনি এটি আবিষ্কার করতে পারবেন:

  1. ছোট অ্যারে নিয়ে কাজ করার সময় পার্থক্যটি কম তাত্পর্যপূর্ণ । আরও পুনরাবৃত্তি, তবে ছোট অ্যারে
  2. intS এর চেয়ে strings এর সাথে আচরণ করার সময় পার্থক্যটি কম তাত্পর্যপূর্ণ ।
  3. structS এর পরিবর্তে বৃহত গুলি ব্যবহার করতে stringসাধারণত অনেক বেশি সময় লাগে তবে অনুপাতটি আসলে খুব বেশি পরিবর্তন করে না।

এটি শীর্ষ ভোট প্রাপ্ত উত্তরের সিদ্ধান্তের সাথে একমত:

  1. আপনার কোডটি প্রায়শই ডেটার অনেক বড় তালিকা তৈরি না করে আপনি পারফরম্যান্সের পার্থক্যটি লক্ষ্য করবেন না। (প্রায় 100 কে স্ট্রিংয়ের 1000 তালিকা তৈরি করার সময় কেবলমাত্র 200 মিমের পার্থক্য ছিল))
  2. ToList() ধারাবাহিকভাবে দ্রুত চালিত হয়, এবং যদি আপনি দীর্ঘ সময়ের জন্য ফলাফলগুলিতে ঝুলিয়ে রাখার পরিকল্পনা না করেন তবে এটি একটি ভাল পছন্দ হবে।

হালনাগাদ

@ জোনা হান্না উল্লেখ করেছিলেন যে এটি কার্যকর করার উপর নির্ভর করে বা বাস্তবায়নের পক্ষে ফলাফল সংগ্রহের আকারের আগে ভবিষ্যদ্বাণী করা Selectসম্ভব । উপরের কোডটিতে প্রতিস্থাপন করা এই মুহুর্তে খুব একই রকমের ফলনের ফলস্বরূপ এবং NET বাস্তবায়ন নির্বিশেষে তা করার সম্ভাবনা বেশি।ToList()ToArray().Select(i => i)Where(i => true)

সিলেক্টের পরিবর্তে কোথাও বেঞ্চমার্ক ব্যবহার করুন


.NET কেন্দ্রের উভয় ক্ষেত্রেই ভাল netfx চেয়ে এখানে থাকা উচিত, কারণ এটি বুঝতে পারবেন আকার হতে যাচ্ছে 100000ব্যবহার এই নিখুত এবং উভয় ToList()এবং ToArray()সঙ্গে, ToArray()খুব সামান্য লাইটার হচ্ছে কারণ এটি সঙ্কুচিত অপারেশন দরকার নেই এটা হবে অন্যথায়, এক জায়গা ToList()যা সুবিধা আছে। প্রশ্নের উদাহরণটি এখনও হারাবে, কারণ Whereএরকম আকারের পূর্বাভাস দেওয়া যায় না।
জন হানা

@ জনহানা: দ্রুত প্রতিক্রিয়া জানাতে ধন্যবাদ। আমি জানতাম না। নেট কোর সেই অপ্টিমাইজেশন করছিল। চমৎকার. আমার কোডে, .Select(i => i)এটির .Where(i => true)জন্য সংশোধন করা যেতে পারে ।
স্ট্রিপলিং ওয়ারিয়র

হ্যাঁ, এটি কোরফেক্সে এটি প্রভাবিত করে এমন অপ্টিমাইজেশন বন্ধ করবে। দুটির শক্তির আকার (যা ToArray()একটি সুবিধা দেওয়া উচিত ) এবং একটি যা উপরে হিসাবে নেই, এবং ফলাফলগুলি তুলনা করে উভয়ই আকর্ষণীয় হতে পারে ।
জন হান্না

@ জোহান্না: মজার বিষয় হল, ToArray() এখনও সবচেয়ে সেরা ক্ষেত্রে হেরে গেছেন । সঙ্গে Math.Pow(2, 15)উপাদান, এটা (ToList: 700 মিঃসে, ToArray: 900ms)। আরও একটি উপাদান যুক্ত করা এতে এতে বাধা দেয় (টোলিস্ট: 925, টোআরে: 1350)। আমি ভাবছি যদি ToArrayইতিমধ্যে নিখুঁত আকারের পরেও অ্যারেটি অনুলিপি করে থাকে? তারা সম্ভবত অনুভব করেছেন যে এটি একটি বিরল যথেষ্ট ঘটনা যা এটি অতিরিক্ত শর্তযুক্তের জন্য মূল্যবান নয়।
স্ট্রিপলিং ওয়ারিয়র

কোরফেক্সে আমরা এটির অনুকূলকরণ শুরু করার আগেও এটি সঠিক আকারের মিলের অনুলিপি করেনি, তাই এটি যেখানে সবচেয়ে বেশি বিরতি লাভ করে।
জন হান্না

12

আপনার সিদ্ধান্ত নেওয়ার সিদ্ধান্ত নেওয়া উচিত ToListবা ToArrayডিজাইনের পছন্দটি কী আদর্শ on আপনি যদি এমন কোনও সংগ্রহ চান যা কেবল পুনরাবৃত্তি হতে পারে এবং সূচক দ্বারা অ্যাক্সেস করা যায় তবে চয়ন করুন ToArray। আপনি যদি পরে কোনও ঝামেলা ছাড়াই সংগ্রহ থেকে যোগ করার এবং অপসারণের অতিরিক্ত দক্ষতা চান তবে একটি করুন ToList(আসলেই নয় যে আপনি কোনও অ্যারে যুক্ত করতে পারবেন না, তবে এটি সাধারণত এটি সঠিক সরঞ্জাম নয়)।

যদি পারফরম্যান্সের বিষয়টি গুরুত্বপূর্ণ হয় তবে আপনার কী পরিচালনা করতে হবে তা আরও দ্রুত বিবেচনা করা উচিত। বাস্তবে, আপনি কল করবেন না ToListবা ToArrayএক মিলিয়ন বার, তবে প্রাপ্ত সংগ্রহটিতে মিলিয়ন বার কাজ করতে পারে । যে সম্মান []সাল থেকে উত্তম List<>হয় []কিছু উপরি সঙ্গে। কিছু দক্ষতার তুলনা করার জন্য এই থ্রেডটি দেখুন: কোনটি আরও দক্ষ: তালিকা <int> বা int []

কিছুক্ষণ আগে আমার নিজের পরীক্ষায় আমি ToArrayদ্রুত খুঁজে পেয়েছি । এবং আমি নিশ্চিত নই যে পরীক্ষাগুলি কীভাবে ত্রুটিযুক্ত ছিল। পারফরম্যান্স পার্থক্য যদিও এত তুচ্ছ, আপনি লক্ষ লক্ষ বার লুপে এই প্রশ্নগুলি চালাচ্ছেন তবেই তা লক্ষণীয়।


2
হ্যাঁ - যদি সংকলকটি যদি জেনে থাকে যে আপনি কোনও অ্যারেতে পুনরাবৃত্তি করছেন (একটি আইএনিউমারেবল <> নয়), তবে এটি পুনরাবৃত্তিকে উল্লেখযোগ্যভাবে অনুকূল করতে পারে।
রবসিক্লোস

12

খুব দেরিতে উত্তর তবে আমি মনে করি এটি গুগলদের জন্য সহায়ক হবে।

লিনক ব্যবহার করে তৈরি করার সময় তারা উভয় স্তন্যপান করে। তারা উভয়ই প্রয়োজনে বাফারকে পুনরায় আকার দিতে একই কোড প্রয়োগ করে । ToArrayঅভ্যন্তরীণভাবে IEnumerable<>4 টি উপাদানের অ্যারে বরাদ্দ করে অ্যারে রূপান্তর করতে একটি শ্রেণি ব্যবহার করে। যদি এটি যথেষ্ট না হয় তবে এটির চেয়ে দ্বিগুণ নতুন অ্যারে তৈরি করে বর্তমানের আকার দ্বিগুণ করে এবং এতে বর্তমান অ্যারে অনুলিপি করে। শেষে এটি আপনার আইটেমগুলির একটি নতুন অ্যারে গণনা করে। যদি আপনার কোয়েরিতে 129 টি উপাদান ফেরত আসে তবে টুআর 256 উপাদান অ্যারে তৈরি করতে 6 বরাদ্দ এবং মেমরি অনুলিপি অপারেশন করবে এবং 129 এর আর অ্যারে হিসাবে ফিরে আসবে। মেমরি দক্ষতার জন্য অনেক।

টোলিস্ট একই কাজ করে তবে আপনি ভবিষ্যতে আইটেম যুক্ত করতে পারছেন বলে এটি শেষ বরাদ্দটি এড়িয়ে যায়। যদি এটি লিনক ক্যোয়ারী থেকে তৈরি করা হয় বা ম্যানুয়ালি তৈরি করা হয় তবে তালিকার কোনও যত্ন নেই।

তৈরির জন্য তালিকা মেমরির সাথে আরও ভাল তবে সিপিইউর সাথে খারাপ কারণ তালিকাটি একটি জেনেরিক সমাধান যা প্রতিটি ক্রমের জন্য অ্যারেগুলির জন্য। নেট এর অভ্যন্তরীণ পরিসীমা চেকগুলিতে অতিরিক্ত পরিসীমা চেকের প্রয়োজন।

সুতরাং আপনি যদি নিজের ফলাফলটি অনেক বার পুনরুক্ত করেন তবে অ্যারেগুলি ভাল হয় কারণ এর অর্থ তালিকার চেয়ে কম পরিসরের চেক থাকে এবং সংকলকরা সাধারণত ক্রমক্রমিক অ্যাক্সেসের জন্য অ্যারে অনুকূল করে তোলে।

তালিকার আরম্ভের বরাদ্দ যদি আপনি তৈরি করার সময় সক্ষমতা পরামিতি নির্দিষ্ট করে থাকেন তবে তা আরও ভাল হতে পারে। এক্ষেত্রে এটি ফলাফলের আকারটি জেনে ধরেই কেবল একবারে অ্যারে বরাদ্দ করবে। ToListলিনক এর সরবরাহের জন্য কোনও ওভারলোড নির্দিষ্ট করে না, তাই আমাদের বর্ধিত পদ্ধতি তৈরি করতে হবে যা প্রদত্ত ক্ষমতা সহ একটি তালিকা তৈরি করে এবং তারপরে ব্যবহার করে List<>.AddRange

এই উত্তরটি শেষ করতে আমাকে নীচের বাক্যগুলি লিখতে হবে

  1. শেষে, আপনি কোনও ToArray, বা ToList ব্যবহার করতে পারেন, পারফরম্যান্স এত আলাদা হবে না (@ এমপি এর উত্তর দেখুন)।
  2. আপনি সি # ব্যবহার করছেন। আপনার যদি পারফরম্যান্সের প্রয়োজন হয় তবে উচ্চ পারফরম্যান্স কোড সম্পর্কে লেখার বিষয়ে চিন্তা করবেন না, তবে খারাপ পারফরম্যান্স কোডটি না লিখে চিন্তিত হন।
  3. উচ্চ পারফরম্যান্স কোডের জন্য সর্বদা x64 লক্ষ্য করুন। আফাইক, এক্স 6464 জেআইটি সি ++ সংকলকের উপর ভিত্তি করে তৈরি এবং টেল রিকার্সন অপ্টিমাইজেশনের মতো কিছু মজার কাজ করে।
  4. 4.5 এর সাথে আপনি প্রোফাইল গাইডড অপটিমাইজেশন এবং মাল্টি কোর জেআইটি উপভোগ করতে পারেন।
  5. শেষ পর্যন্ত, আপনি এটিকে আরও দ্রুত প্রক্রিয়া করার জন্য async / অপেক্ষার প্যাটার্ন ব্যবহার করতে পারেন।

ওরা দুজন চুষে? আপনার কি এমন কোনও বিকল্প ধারণা আছে যা অপ্রয়োজনীয় মেমরি বরাদ্দের প্রয়োজন হয় না?
নওফাল

প্রশ্নের প্রসঙ্গে, হ্যাঁ, তারা দু'জন স্তন্যপায়ী বরাদ্দের কারণে কিন্তু অন্য কিছু নয়। অপ্রয়োজনীয় বরাদ্দ কমাতে মেমরি এবং পুনরাবৃত্তির গতি ব্যয় করে লিঙ্কযুক্ত তালিকাগুলি ব্যবহার করতে পারেন। দিনের শেষে, এটি আমরা যা করি, আমরা বাণিজ্য বন্ধ করি। আরেকটি ধারণা যদি 200 এর ক্ষমতা সহ উদাহরণ তৈরি করে (উদাহরণস্বরূপ) এবং তারপরে আইটেমগুলি লোড করা হয়। এটি অপ্রয়োজনীয়তাও হ্রাস করবে, তবে অ্যারেগুলি সর্বদা দ্রুত হয়, সুতরাং এটি অন্য বাণিজ্য।
এরদোগান কুর্তুর

200 এর একটি তালিকা তৈরি করবেন ? যে পারে মাপ এড়াতে, কিন্তু আমি ব্যবহার অপ্রয়োজনীয় মেমরির সম্পর্কে কথা ছিল। আপনি এটি সহায়তা করতে পারবেন না কারণ আকারটি কী হতে পারে সে সম্পর্কে কোনও পূর্ব জ্ঞান নেই। আপনি ইতিমধ্যে একটি এর কন্সট্রাক্টরে ক্ষমতা সুনির্দিষ্ট করতে পারেন List<T>, কিন্তু যখন আপনি করবেন না বা যখন আপনি পারবেন না তখন আপনি এটি সাহায্য করতে পারবেন না।
নওফাল

2
মেমরির একমাত্র অপ্রয়োজনীয় ডেটা হ'ল অ্যারের সামগ্রী যা পয়েন্টারগুলির একটি তালিকা (এই ক্ষেত্রে)। এক মিলিয়ন bit৪ বিট পয়েন্টার 8 এমবি মেমরি হিসাবে নেয় যা তারা দেখায় এমন এক মিলিয়ন অবজেক্টের তুলনায় কিছুই নয়। 200 টি কেবল একটি সংখ্যা, এবং এতে সর্বাধিক 5 বার পুনরায় আকারের কলগুলি হ্রাস করার সুযোগ রয়েছে। এবং হ্যাঁ, আমরা এটি সাহায্য করতে পারি না। আমাদের কাছে এর চেয়ে ভাল বিকল্প নেই। আমার কাছে এর চেয়ে ভাল সমাধান নেই, তবে এর অর্থ এই নয় যে সমস্যাটি কোথায় তা আমাকে বলার অনুমতি নেই।
এরদোগান কুর্তুর

1
হুম শেষে আপনি লাইন আঁকেন যেখানে। আমি বর্তমান বাস্তবায়ন পছন্দ। আপনার উত্তরের সুর আমাকে ভাবতে বাধ্য করেছে যে সমস্যাটি যেখানে রয়েছে তার চেয়ে বরং এটি সমালোচনা ছিল :)
নওফাল

7

এটি একটি পুরানো প্রশ্ন - তবে যে ব্যবহারকারীরা এতে হোঁচট খায় তাদের উপকারের জন্য, গণ্যমান্যদের 'মেমোজাইজ' করার বিকল্পও রয়েছে - যা লিনক বিবৃতিতে একাধিক গণনা ক্যাশে এবং বন্ধ করে দেয়, যা টোআরাই () তালিকা বা অ্যারের সংগ্রহের বৈশিষ্ট্যগুলি কখনও ব্যবহার না করা সত্ত্বেও টোললিস্ট () প্রচুর জন্য ব্যবহৃত হয়।

মেমোয়েজ আরএক্স / সিস্টেমে উপলব্ধ n ইন্টারেক্টিভ লাইব, এবং এখানে ব্যাখ্যা করা হয়েছে: সিস্টেমের সাথে আরও লিনকিউ.এন্টিেক্টেভ

( বার্ট ডি'সমেটের ব্লগটি যা আপনি লিঙ্কের সাথে প্রচুর অবজেক্টে কাজ করছেন যদি এটি অত্যন্ত প্রস্তাবিত পড়া হয়)


4

একটি বিকল্প হ'ল আপনার নিজস্ব এক্সটেনশন পদ্ধতি যুক্ত করুন যা কেবলমাত্র পাঠ্যকে ফেরত দেয় ICollection<T>। এটি ব্যবহার করা ToListবা ToArrayআপনি যখন কোনও অ্যারে / তালিকার ইনডেক্সিং বৈশিষ্ট্যগুলি ব্যবহার করতে বা কোনও তালিকা থেকে যুক্ত / সরিয়ে রাখতে চান না তার চেয়ে ভাল can

public static class EnumerableExtension
{
    /// <summary>
    /// Causes immediate evaluation of the linq but only if required.
    /// As it returns a readonly ICollection, is better than using ToList or ToArray
    /// when you do not want to use the indexing properties of an IList, or add to the collection.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="enumerable"></param>
    /// <returns>Readonly collection</returns>
    public static ICollection<T> Evaluate<T>(this IEnumerable<T> enumerable)
    {
        //if it's already a readonly collection, use it
        var collection = enumerable as ICollection<T>;
        if ((collection != null) && collection.IsReadOnly)
        {
            return collection;
        }
        //or make a new collection
        return enumerable.ToList().AsReadOnly();
    }
}

ইউনিট পরীক্ষা:

[TestClass]
public sealed class EvaluateLinqTests
{
    [TestMethod]
    public void EvalTest()
    {
        var list = new List<int> {1, 2, 3};
        var linqResult = list.Select(i => i);
        var linqResultEvaluated = list.Select(i => i).Evaluate();
        list.Clear();
        Assert.AreEqual(0, linqResult.Count());
        //even though we have cleared the underlying list, the evaluated list does not change
        Assert.AreEqual(3, linqResultEvaluated.Count());
    }

    [TestMethod]
    public void DoesNotSaveCreatingListWhenHasListTest()
    {
        var list = new List<int> {1, 2, 3};
        var linqResultEvaluated = list.Evaluate();
        //list is not readonly, so we expect a new list
        Assert.AreNotSame(list, linqResultEvaluated);
    }

    [TestMethod]
    public void SavesCreatingListWhenHasReadonlyListTest()
    {
        var list = new List<int> {1, 2, 3}.AsReadOnly();
        var linqResultEvaluated = list.Evaluate();
        //list is readonly, so we don't expect a new list
        Assert.AreSame(list, linqResultEvaluated);
    }

    [TestMethod]
    public void SavesCreatingListWhenHasArrayTest()
    {
        var list = new[] {1, 2, 3};
        var linqResultEvaluated = list.Evaluate();
        //arrays are readonly (wrt ICollection<T> interface), so we don't expect a new object
        Assert.AreSame(list, linqResultEvaluated);
    }

    [TestMethod]
    [ExpectedException(typeof (NotSupportedException))]
    public void CantAddToResultTest()
    {
        var list = new List<int> {1, 2, 3};
        var linqResultEvaluated = list.Evaluate();
        Assert.AreNotSame(list, linqResultEvaluated);
        linqResultEvaluated.Add(4);
    }

    [TestMethod]
    [ExpectedException(typeof (NotSupportedException))]
    public void CantRemoveFromResultTest()
    {
        var list = new List<int> {1, 2, 3};
        var linqResultEvaluated = list.Evaluate();
        Assert.AreNotSame(list, linqResultEvaluated);
        linqResultEvaluated.Remove(1);
    }
}

এটি লক্ষণীয় যে কেবল পঠন-পঠন সংগ্রহের চুক্তিতে কেবলমাত্র এটির নির্দেশ দেওয়া হয় যে অবজেক্টের ব্যবহারকারী এটি সংশোধন করতে পারে না, তবে মালিক তারপরে এটি পরিবর্তন করতে পারে যদি এটি কোনও মিউটিয়েবল ইন্টারফেস সরবরাহ করে। ইন্টারফেসগুলির জন্য যে গ্যারান্টি দেয় যে অন্তর্নিহিত কাঠামোটি কখনই পরিবর্তিত হবে না, অপরিবর্তনীয় সংগ্রহগুলি দেখুন। কেন অপরিবর্তনীয়, বা কেবল পঠনযোগ্য, বা সরল পঠন-লেখার সংগ্রহগুলি আরও ভাল বা খারাপ, তুলনার জন্য কারও একটি রেফারেন্স পয়েন্ট প্রয়োজন; কোনও চূড়ান্ত উত্তর নেই (অন্যথায় আমাদের পছন্দ করতে হবে না)।
tne

@ টীন নোট আমি AsReadOnly এর আগে টোলিস্ট করি, সুতরাং অন্তর্নিহিত মিউটটেবলের কোনও উল্লেখ নেই।
ওয়েস্টন

আপনি সম্পূর্ণরূপে সঠিক, এবং বিসিএলে অপরিবর্তনীয় সংগ্রহ আসার আগে জিনিসগুলি করার সম্ভবত এটি সর্বোত্তম উপায় ছিল (আমি দেখতে পাচ্ছি আপনার উত্তরের এক মাস পরে প্রথম বিটা প্রকাশিত হয়েছিল)।
tne

থ্রেড সুরক্ষার জন্য অপরিবর্তনীয় সংগ্রহগুলি বিদ্যমান, যেখানে থ্রেডগুলি ধরে নিতে পারে যে এটি পরিবর্তন হবে না এবং যদি এটি হয় তবে পাঠকদের বিরুদ্ধে রেসিং করা এবং এটি ব্যবহার করার সময় পরিবর্তন করার পরিবর্তে একটি নতুন সংস্করণ তৈরি করা হবে। এইভাবে, কারও কখনও লক অর্জন করার প্রয়োজন হয় না।
doug65536

4

ToListAsync<T>() পছন্দসই

সত্তা ফ্রেমওয়ার্ক 6 এ উভয় পদ্ধতি অবশেষে একই অভ্যন্তরীণ পদ্ধতিতে ToArrayAsync<T>()কল list.ToArray()করে , তবে শেষে কল করে, যা হিসাবে প্রয়োগ করা হয়

T[] array = new T[_size];
Array.Copy(_items, 0, array, 0, _size);
return array;

সুতরাং ToArrayAsync<T>()কিছু ওভারহেড রয়েছে, যার ফলে ToListAsync<T>()পছন্দসই হয়।


1
এটি আসলে আমি উত্তরটি খুঁজছিলাম, EF এটি কীভাবে করে E আমি কৌতূহল হব এটি কীভাবে EF কোর এর মধ্যে রয়েছে।
শিমি ওয়েটজ্যান্ডলার

3

পুরানো প্রশ্ন তবে সর্বদা নতুন প্রশ্নকর্তা।

সিস্টেম.লিংক.অনুসংখ্যার উত্স অনুসারে , ToListকেবল একটি ফিরে আসুনnew List(source) , যখন ToArrayএকটি new Buffer<T>(source).ToArray()ফিরে আসার জন্য একটি ব্যবহার করুন T[]

মেমরি বরাদ্দ সম্পর্কে:

IEnumerable<T>একটিমাত্র অবজেক্টে চলার সময় , ToArrayমেমরির চেয়ে আরও একবার বরাদ্দ করুন ToList। তবে বেশিরভাগ ক্ষেত্রে আপনার এটির যত্ন নেওয়ার দরকার নেই, কারণ জিসি যখন প্রয়োজন তখন আবর্জনা সংগ্রহ করবেন।

রানটাইম দক্ষ সম্পর্কে:

যারা এই প্রশ্নটি নিয়ে প্রশ্ন করছেন তারা আপনার নিজের মেশিনে নিম্নলিখিত কোডটি চালাতে পারেন এবং আপনি আপনার উত্তর পেয়ে যাবেন।

class PersonC
{
    public Guid uuid;
    public string name;
    public int age;
    public bool sex;
    public DateTime BirthDay;
    public double weight;
}

struct PersonS
{
    public Guid uuid;
    public string name;
    public int age;
    public bool sex;
    public DateTime BirthDay;
    public double weight;
}

class PersonT<T> : IEnumerable<T>
{
    private List<T> items;
    public PersonT(IEnumerable<T> init)
    {
        items = new List<T>(init);
    }

    public IEnumerator<T> GetEnumerator() => items.GetEnumerator();
    IEnumerator IEnumerable.GetEnumerator() => items.GetEnumerator();
}

private IEnumerable<PersonC> C(int count)
{
    for (var i = 0; i < count; ++i)
    {
        var guid = Guid.NewGuid();
        var guidBytes = guid.ToByteArray(); //16 bytes
        yield return new PersonC
        {
            uuid = guid,
            name = guid.ToString(),
            age = guidBytes[0] ^ guidBytes[7],
            sex = guidBytes[14] % 2 == 0,
            BirthDay = DateTime.Now.AddDays(-guidBytes[11] * 18),
            weight = guidBytes[12] * 100
        };
    }
}

private IEnumerable<PersonS> S(int count)
{
    for (var i = 0; i < count; ++i)
    {
        var guid = Guid.NewGuid();
        var guidBytes = guid.ToByteArray(); //16 bytes
        yield return new PersonS
        {
            uuid = guid,
            name = guid.ToString(),
            age = guidBytes[0] ^ guidBytes[7],
            sex = guidBytes[14] % 2 == 0,
            BirthDay = DateTime.Now.AddDays(-guidBytes[11] * 18),
            weight = guidBytes[12] * 100
        };
    }
}

private void MakeLog(string test, List<long> log) =>
    Console.WriteLine("{0} {1} ms -> [{2}]",
        test,
        log.Average(),
        string.Join(", ", log)
    );

private void Test1(int times, int count)
{
    var test = Enumerable.Range(1, times).ToArray();

    MakeLog("C.ToList", test.Select(o =>
    {
        var sw = new Stopwatch();
        GC.Collect();
        sw.Start();
        var ret = C(count).ToList();
        sw.Stop();
        return sw.ElapsedMilliseconds;
    }).ToList());

    MakeLog("C.ToArray", test.Select(o =>
    {
        var sw = new Stopwatch();
        GC.Collect();
        sw.Start();
        var ret = C(count).ToArray();
        sw.Stop();
        return sw.ElapsedMilliseconds;
    }).ToList());

    MakeLog("S.ToList", test.Select(o =>
    {
        var sw = new Stopwatch();
        GC.Collect();
        sw.Start();
        var ret = S(count).ToList();
        sw.Stop();
        return sw.ElapsedMilliseconds;
    }).ToList());

    MakeLog("S.ToArray", test.Select(o =>
    {
        var sw = new Stopwatch();
        GC.Collect();
        sw.Start();
        var ret = S(count).ToArray();
        sw.Stop();
        return sw.ElapsedMilliseconds;
    }).ToList());
}

private void Test2(int times, int count)
{
    var test = Enumerable.Range(1, times).ToArray();

    var dataC1 = new PersonT<PersonC>(C(count));
    var dataS1 = new PersonT<PersonS>(S(count));

    MakeLog("C1.ToList", test.Select(o =>
    {
        var sw = new Stopwatch();
        GC.Collect();
        sw.Start();
        var ret = dataC1.ToList();
        sw.Stop();
        return sw.ElapsedMilliseconds;
    }).ToList());

    MakeLog("C1.ToArray", test.Select(o =>
    {
        var sw = new Stopwatch();
        GC.Collect();
        sw.Start();
        var ret = dataC1.ToArray();
        sw.Stop();
        return sw.ElapsedMilliseconds;
    }).ToList());

    MakeLog("S1.ToList", test.Select(o =>
    {
        var sw = new Stopwatch();
        GC.Collect();
        sw.Start();
        var ret = dataS1.ToList();
        sw.Stop();
        return sw.ElapsedMilliseconds;
    }).ToList());

    MakeLog("S1.ToArray", test.Select(o =>
    {
        var sw = new Stopwatch();
        GC.Collect();
        sw.Start();
        var ret = dataS1.ToArray();
        sw.Stop();
        return sw.ElapsedMilliseconds;
    }).ToList());
}

private void Test3(int times, int count)
{
    var test = Enumerable.Range(1, times).ToArray();

    var dataC2 = (ICollection<PersonC>) new List<PersonC>(C(count));
    var dataS2 = (ICollection<PersonS>) new List<PersonS>(S(count));

    MakeLog("C2.ToList", test.Select(o =>
    {
        var sw = new Stopwatch();
        GC.Collect();
        sw.Start();
        var ret = dataC2.ToList();
        sw.Stop();
        return sw.ElapsedMilliseconds;
    }).ToList());

    MakeLog("C2.ToArray", test.Select(o =>
    {
        var sw = new Stopwatch();
        GC.Collect();
        sw.Start();
        var ret = dataC2.ToArray();
        sw.Stop();
        return sw.ElapsedMilliseconds;
    }).ToList());

    MakeLog("S2.ToList", test.Select(o =>
    {
        var sw = new Stopwatch();
        GC.Collect();
        sw.Start();
        var ret = dataS2.ToList();
        sw.Stop();
        return sw.ElapsedMilliseconds;
    }).ToList());

    MakeLog("S2.ToArray", test.Select(o =>
    {
        var sw = new Stopwatch();
        GC.Collect();
        sw.Start();
        var ret = dataS2.ToArray();
        sw.Stop();
        return sw.ElapsedMilliseconds;
    }).ToList());
}

private void TestMain()
{
    const int times = 100;
    const int count = 1_000_000 + 1;
    Test1(times, count);
    Test2(times, count);
    Test3(times, count);
}

আমি আমার মেশিনে এই ফলাফলগুলি পেয়েছি:

1 নং দল:

C.ToList 761.79 ms -> [775, 755, 759, 759, 756, 759, 765, 750, 757, 762, 759, 754, 757, 753, 763, 753, 759, 756, 768, 754, 763, 757, 757, 777, 780, 758, 754, 758, 762, 754, 758, 757, 763, 758, 760, 754, 761, 755, 764, 847, 952, 755, 747, 763, 760, 758, 754, 763, 761, 758, 750, 764, 757, 763, 762, 756, 753, 759, 759, 757, 758, 779, 765, 760, 760, 756, 760, 756, 755, 764, 759, 753, 757, 760, 752, 764, 758, 760, 758, 760, 755, 761, 751, 753, 761, 762, 761, 758, 759, 752, 765, 756, 760, 755, 757, 753, 760, 751, 755, 779]
C.ToArray 782.56 ms -> [783, 774, 771, 771, 773, 774, 775, 775, 772, 770, 771, 774, 771, 1023, 975, 772, 767, 776, 771, 779, 772, 779, 775, 771, 775, 773, 775, 771, 765, 774, 770, 781, 772, 771, 781, 762, 817, 770, 775, 779, 769, 774, 763, 775, 777, 769, 777, 772, 775, 778, 775, 771, 770, 774, 772, 769, 772, 769, 774, 775, 768, 775, 769, 774, 771, 776, 774, 773, 778, 769, 778, 767, 770, 787, 783, 779, 771, 768, 805, 780, 779, 767, 773, 771, 773, 785, 1044, 853, 775, 774, 775, 771, 770, 769, 770, 776, 770, 780, 821, 770]
S.ToList 704.2 ms -> [687, 702, 709, 691, 694, 710, 696, 698, 700, 694, 701, 719, 706, 694, 702, 699, 699, 703, 704, 701, 703, 705, 697, 707, 691, 697, 707, 692, 721, 698, 695, 700, 704, 700, 701, 710, 700, 705, 697, 711, 694, 700, 695, 698, 701, 692, 696, 702, 690, 699, 708, 700, 703, 714, 701, 697, 700, 699, 694, 701, 697, 696, 699, 694, 709, 1068, 690, 706, 699, 699, 695, 708, 695, 704, 704, 700, 695, 704, 695, 696, 702, 700, 710, 708, 693, 697, 702, 694, 700, 706, 699, 695, 706, 714, 704, 700, 695, 697, 707, 704]
S.ToArray 742.5 ms -> [742, 743, 733, 745, 741, 724, 738, 745, 728, 732, 740, 727, 739, 740, 726, 744, 758, 732, 744, 745, 730, 739, 738, 723, 745, 757, 729, 741, 736, 724, 744, 756, 739, 766, 737, 725, 741, 742, 736, 748, 742, 721, 746, 1043, 806, 747, 731, 727, 742, 742, 726, 738, 746, 727, 739, 743, 730, 744, 753, 741, 739, 746, 728, 740, 744, 734, 734, 738, 731, 747, 736, 731, 765, 735, 726, 740, 743, 730, 746, 742, 725, 731, 757, 734, 738, 741, 732, 747, 744, 721, 742, 741, 727, 745, 740, 730, 747, 760, 737, 740]

C1.ToList 32.34 ms -> [35, 31, 31, 31, 32, 31, 31, 31, 31, 31, 31, 31, 31, 31, 33, 32, 31, 31, 31, 31, 30, 32, 31, 31, 31, 31, 32, 30, 31, 31, 31, 30, 32, 31, 31, 31, 36, 31, 31, 31, 32, 30, 31, 32, 31, 31, 31, 31, 31, 32, 31, 31, 31, 31, 33, 32, 31, 32, 31, 31, 33, 31, 31, 31, 31, 31, 32, 31, 32, 31, 34, 38, 68, 42, 79, 33, 31, 31, 31, 31, 31, 30, 30, 30, 30, 31, 31, 31, 31, 32, 31, 32, 31, 31, 31, 32, 33, 33, 31, 31]
C1.ToArray 56.32 ms -> [57, 56, 59, 54, 54, 55, 56, 57, 54, 54, 55, 55, 57, 56, 59, 57, 56, 58, 56, 56, 54, 56, 57, 55, 55, 55, 57, 58, 57, 58, 55, 55, 56, 55, 57, 56, 56, 59, 56, 56, 56, 56, 58, 56, 57, 56, 56, 57, 56, 55, 56, 56, 56, 59, 56, 56, 56, 55, 55, 54, 55, 54, 57, 56, 56, 56, 55, 55, 56, 56, 56, 59, 56, 56, 57, 56, 57, 56, 56, 56, 56, 62, 55, 56, 56, 56, 69, 57, 58, 56, 57, 58, 56, 57, 56, 56, 56, 56, 56, 56]
S1.ToList 88.69 ms -> [96, 90, 90, 89, 91, 88, 89, 90, 96, 89, 89, 89, 90, 90, 90, 89, 90, 90, 89, 90, 89, 91, 89, 91, 89, 91, 89, 90, 90, 89, 87, 88, 87, 88, 87, 87, 87, 87, 88, 88, 87, 87, 89, 87, 87, 87, 91, 88, 87, 86, 89, 87, 90, 89, 89, 90, 89, 87, 87, 87, 86, 87, 88, 90, 88, 87, 87, 92, 87, 87, 88, 88, 88, 86, 86, 87, 88, 87, 87, 87, 89, 87, 89, 87, 90, 89, 89, 89, 91, 89, 90, 89, 90, 88, 90, 90, 90, 88, 89, 89]
S1.ToArray 143.26 ms -> [130, 129, 130, 131, 133, 130, 131, 130, 135, 137, 130, 136, 132, 131, 130, 131, 132, 130, 132, 136, 130, 131, 157, 153, 194, 364, 176, 189, 203, 194, 189, 192, 183, 140, 142, 147, 145, 134, 159, 158, 142, 167, 130, 143, 145, 144, 160, 154, 156, 153, 153, 164, 142, 145, 137, 134, 145, 143, 142, 135, 133, 133, 135, 134, 134, 139, 139, 133, 134, 141, 133, 132, 133, 132, 133, 131, 135, 132, 133, 132, 128, 128, 130, 132, 129, 129, 129, 129, 129, 128, 134, 129, 129, 129, 129, 128, 128, 137, 130, 131]

C2.ToList 3.25 ms -> [5, 3, 3, 3, 3, 4, 3, 4, 3, 4, 3, 3, 3, 4, 4, 3, 3, 3, 4, 3, 3, 3, 3, 4, 3, 4, 3, 4, 3, 3, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 3, 4, 3, 3, 3, 3, 3, 4, 3, 4, 3, 3, 3, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 3, 4, 3, 4, 3, 3, 3, 4, 3, 3, 4, 3, 3, 3, 4, 3, 3, 3, 3, 3]
C2.ToArray 3.37 ms -> [4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 3, 4, 3, 5, 4, 9, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 3, 3, 3, 3, 3, 4, 4, 3, 3, 4, 4, 3, 3, 3, 4, 3, 3, 3, 3, 4, 3, 3, 3, 3, 3, 4, 4, 3, 4, 4, 3, 3, 4, 3, 3, 4, 3, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 3, 3, 4, 3, 3, 3, 3, 3, 4, 4, 3, 3, 3, 3, 3, 4, 3, 4, 3, 3, 3]
S2.ToList 37.72 ms -> [38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 40, 38, 38, 39, 39, 38, 38, 38, 38, 37, 37, 37, 37, 39, 37, 37, 39, 38, 37, 37, 37, 37, 39, 38, 37, 37, 38, 37, 38, 37, 37, 38, 37, 37, 37, 38, 37, 37, 36, 37, 38, 37, 39, 37, 39, 38, 37, 38, 38, 38, 38, 38, 38, 37, 38, 38, 38, 38, 38, 37, 38, 37, 37, 38, 37, 37, 39, 41, 37, 38, 38, 37, 37, 37, 37, 38, 37, 37, 37, 40, 37, 37, 37, 37, 39, 38]
S2.ToArray 38.86 ms -> [39, 37, 39, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 39, 38, 38, 38, 38, 38, 38, 38, 38, 39, 39, 38, 38, 38, 39, 37, 38, 38, 38, 38, 38, 37, 37, 38, 37, 37, 38, 38, 40, 38, 38, 38, 38, 38, 39, 38, 38, 39, 38, 38, 39, 38, 38, 40, 38, 39, 38, 38, 39, 38, 38, 38, 38, 38, 39, 38, 38, 38, 39, 39, 37, 38, 38, 39, 71, 78, 37, 37, 37, 39, 38, 38, 39, 38, 38, 38, 38, 38, 39, 38, 38, 38, 39, 38, 38, 38]

GROUP2:

C.ToList 756.81 ms
C.ToArray 774.21 ms
S.ToList 709.7 ms
S.ToArray 753.51 ms

C1.ToList 32.06 ms
C1.ToArray 56.58 ms
S1.ToList 89.43 ms
S1.ToArray 132.85 ms

C2.ToList 3.45 ms
C2.ToArray 3.36 ms
S2.ToList 41.43 ms
S2.ToArray 40.84 ms

GROUP3:

C.ToList 756.64 ms
C.ToArray 771.56 ms
S.ToList 705.42 ms
S.ToArray 749.59 ms

C1.ToList 31.45 ms
C1.ToArray 57.03 ms
S1.ToList 91.26 ms
S1.ToArray 129.77 ms

C2.ToList 3.26 ms
C2.ToArray 3.29 ms
S2.ToList 41.57 ms
S2.ToArray 40.69 ms

Group4:

C.ToList 729.65 ms -> [749, 730, 721, 719, 723, 743, 721, 724, 727, 722, 716, 725, 723, 726, 718, 722, 731, 722, 723, 725, 723, 722, 728, 726, 728, 718, 726, 1088, 788, 737, 729, 710, 730, 728, 717, 723, 728, 721, 722, 728, 722, 736, 723, 729, 732, 724, 726, 727, 728, 728, 726, 726, 725, 727, 725, 728, 728, 718, 724, 725, 726, 724, 726, 729, 727, 722, 722, 725, 725, 728, 724, 727, 738, 717, 726, 723, 725, 725, 727, 724, 720, 726, 726, 723, 727, 730, 723, 721, 725, 727, 727, 733, 720, 722, 722, 725, 722, 725, 728, 726]
C.ToArray 788.36 ms -> [748, 740, 742, 797, 1090, 774, 781, 787, 784, 786, 786, 782, 781, 781, 784, 783, 783, 781, 783, 787, 783, 784, 775, 789, 784, 785, 778, 774, 781, 783, 786, 781, 780, 788, 778, 785, 777, 781, 786, 782, 781, 787, 782, 787, 784, 773, 783, 782, 781, 777, 783, 781, 785, 788, 777, 776, 784, 784, 783, 789, 778, 781, 791, 768, 779, 783, 781, 787, 786, 781, 784, 781, 785, 781, 780, 809, 1155, 780, 790, 789, 783, 776, 785, 783, 786, 787, 782, 782, 787, 777, 779, 784, 783, 776, 786, 775, 782, 779, 784, 784]
S.ToList 705.54 ms -> [690, 705, 709, 708, 702, 707, 703, 696, 703, 702, 700, 703, 700, 707, 705, 699, 697, 703, 695, 698, 707, 697, 711, 710, 699, 700, 708, 707, 693, 710, 704, 691, 702, 700, 703, 700, 705, 700, 703, 695, 709, 705, 698, 699, 709, 700, 699, 704, 691, 705, 703, 700, 708, 1048, 710, 706, 706, 692, 702, 705, 695, 701, 710, 697, 698, 706, 705, 707, 707, 695, 698, 704, 698, 699, 705, 698, 703, 702, 701, 697, 702, 702, 704, 703, 699, 707, 703, 705, 701, 717, 698, 695, 713, 696, 708, 705, 697, 699, 700, 698]
S.ToArray 745.01 ms -> [751, 743, 727, 734, 736, 745, 739, 750, 739, 750, 758, 739, 744, 738, 730, 744, 745, 739, 744, 750, 733, 735, 743, 731, 749, 748, 727, 746, 749, 731, 737, 803, 1059, 756, 769, 748, 740, 745, 741, 746, 749, 732, 741, 742, 732, 744, 746, 737, 742, 739, 733, 744, 741, 729, 746, 760, 725, 741, 764, 739, 750, 751, 727, 745, 738, 727, 735, 741, 720, 736, 740, 733, 741, 746, 731, 749, 756, 740, 738, 736, 732, 741, 741, 733, 741, 744, 736, 742, 742, 735, 743, 746, 729, 748, 765, 743, 734, 742, 728, 749]

C1.ToList 32.27 ms -> [36, 31, 31, 32, 31, 32, 31, 30, 32, 30, 30, 30, 34, 32, 31, 31, 31, 31, 31, 31, 31, 32, 38, 51, 68, 57, 35, 30, 31, 31, 30, 30, 33, 30, 31, 34, 31, 34, 32, 31, 31, 31, 31, 32, 30, 30, 31, 30, 31, 31, 32, 31, 31, 31, 32, 31, 31, 31, 32, 31, 33, 31, 31, 32, 30, 30, 30, 30, 30, 33, 30, 33, 32, 31, 30, 31, 31, 32, 32, 31, 35, 31, 34, 31, 31, 32, 31, 31, 32, 31, 32, 31, 31, 35, 31, 31, 31, 31, 31, 32]
C1.ToArray 56.72 ms -> [58, 56, 57, 57, 59, 58, 58, 57, 56, 59, 57, 55, 55, 54, 56, 55, 56, 56, 57, 59, 56, 55, 58, 56, 55, 55, 55, 55, 58, 58, 55, 57, 57, 56, 57, 57, 57, 57, 59, 59, 56, 57, 56, 57, 57, 56, 57, 59, 58, 56, 57, 57, 57, 58, 56, 56, 59, 56, 59, 57, 57, 57, 57, 59, 57, 56, 57, 56, 58, 56, 57, 56, 57, 59, 55, 58, 55, 55, 56, 56, 56, 56, 56, 56, 56, 56, 56, 57, 56, 56, 57, 56, 56, 57, 58, 57, 57, 57, 57, 57]
S1.ToList 90.72 ms -> [95, 90, 90, 89, 89, 89, 91, 89, 89, 87, 91, 89, 89, 89, 91, 89, 89, 89, 90, 89, 89, 90, 88, 89, 88, 90, 89, 90, 89, 89, 90, 90, 89, 89, 90, 91, 89, 91, 89, 90, 89, 89, 90, 91, 89, 89, 89, 89, 89, 89, 90, 89, 89, 89, 90, 89, 90, 89, 91, 89, 90, 89, 90, 89, 90, 89, 96, 89, 90, 89, 89, 89, 89, 89, 90, 89, 89, 89, 90, 87, 89, 90, 90, 91, 89, 91, 89, 89, 90, 91, 90, 89, 93, 144, 149, 90, 90, 89, 89, 89]
S1.ToArray 131.4 ms -> [130, 128, 127, 134, 129, 129, 130, 136, 131, 130, 132, 132, 133, 131, 132, 131, 133, 132, 130, 131, 132, 131, 130, 133, 133, 130, 130, 131, 131, 131, 132, 134, 131, 131, 132, 131, 132, 131, 134, 131, 131, 130, 131, 131, 130, 132, 129, 131, 131, 131, 132, 131, 133, 134, 131, 131, 132, 132, 131, 133, 131, 131, 130, 133, 131, 130, 134, 132, 131, 132, 132, 131, 131, 134, 131, 131, 132, 132, 131, 130, 138, 130, 130, 131, 132, 132, 130, 134, 131, 131, 132, 131, 130, 132, 133, 131, 131, 131, 130, 131]

C2.ToList 3.21 ms -> [4, 3, 3, 3, 4, 3, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 3, 3, 3, 3, 4, 3, 3, 3, 3, 3, 4, 3, 4, 3, 3, 3, 3, 3, 4, 3, 3, 4, 3, 3, 3, 3, 3, 3, 3, 4, 3, 3, 4, 3, 3, 3, 3, 3, 3, 4, 3, 4, 3, 3, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 3, 3, 3, 4, 4, 3, 3, 3, 3, 3, 4, 3, 3, 3]
C2.ToArray 3.22 ms -> [4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 5, 4, 3, 3, 3, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 3, 3, 3, 3, 3, 3, 4, 3, 4, 3, 3, 3, 4, 3, 4, 3, 3, 3, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 3, 3, 3, 4, 3, 4, 3, 3, 3, 3, 3, 4, 3, 3, 3, 4, 3, 4, 3, 3, 3, 3, 4]
S2.ToList 41.46 ms -> [42, 40, 41, 40, 42, 40, 40, 40, 40, 40, 40, 40, 40, 41, 40, 40, 41, 40, 40, 40, 39, 41, 41, 39, 40, 40, 43, 40, 39, 40, 40, 40, 40, 40, 40, 41, 40, 40, 40, 43, 40, 43, 75, 76, 47, 39, 40, 40, 40, 40, 42, 40, 41, 40, 40, 40, 44, 41, 40, 42, 42, 40, 41, 41, 41, 41, 41, 40, 41, 41, 41, 41, 42, 41, 40, 41, 41, 42, 42, 41, 40, 41, 41, 41, 41, 41, 40, 42, 40, 42, 41, 41, 41, 43, 41, 41, 41, 41, 42, 41]
S2.ToArray 41.14 ms -> [42, 41, 41, 40, 40, 40, 40, 41, 41, 42, 41, 42, 41, 41, 41, 42, 41, 41, 42, 41, 41, 41, 41, 41, 42, 40, 41, 40, 42, 40, 42, 41, 40, 42, 41, 41, 43, 42, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 40, 40, 41, 41, 41, 40, 42, 41, 41, 41, 41, 41, 40, 41, 41, 42, 41, 41, 41, 42, 41, 41, 41, 41, 41, 41, 42, 42, 42, 41, 45, 46, 41, 40, 41, 41, 42, 41, 41, 41, 41, 41, 41, 40, 41, 43, 40, 40, 40, 40, 43, 41]

Group5:

C.ToList 757.06 ms -> [770, 752, 752, 751, 778, 763, 761, 763, 747, 758, 748, 747, 754, 749, 752, 753, 756, 762, 750, 753, 756, 749, 755, 757, 755, 756, 755, 744, 753, 758, 747, 751, 759, 751, 761, 755, 746, 752, 752, 749, 746, 752, 753, 755, 752, 755, 754, 754, 966, 937, 749, 759, 748, 747, 754, 749, 755, 750, 746, 754, 757, 752, 753, 745, 758, 755, 761, 753, 751, 755, 755, 752, 746, 756, 755, 746, 742, 751, 751, 749, 752, 751, 756, 756, 755, 742, 749, 754, 749, 756, 753, 751, 754, 752, 751, 754, 753, 749, 755, 756]
C.ToArray 772.8 ms -> [766, 772, 755, 763, 758, 767, 763, 762, 761, 768, 769, 763, 770, 757, 765, 760, 766, 759, 764, 761, 760, 777, 1102, 881, 759, 765, 758, 762, 772, 761, 758, 757, 765, 769, 769, 761, 762, 762, 763, 760, 770, 764, 760, 768, 758, 766, 763, 770, 769, 761, 764, 761, 761, 767, 761, 762, 764, 757, 765, 766, 767, 771, 753, 762, 769, 768, 759, 764, 764, 760, 763, 763, 763, 763, 763, 767, 761, 771, 760, 765, 760, 758, 768, 770, 751, 771, 767, 771, 765, 763, 760, 765, 765, 769, 767, 767, 1193, 774, 767, 764]
S.ToList 704.73 ms -> [682, 708, 705, 699, 705, 704, 695, 703, 702, 699, 701, 708, 699, 702, 703, 701, 701, 699, 701, 707, 707, 700, 701, 705, 700, 697, 706, 702, 701, 706, 699, 692, 702, 697, 707, 704, 697, 698, 699, 699, 702, 703, 698, 697, 702, 703, 702, 704, 694, 697, 707, 695, 711, 710, 700, 693, 703, 699, 699, 706, 698, 701, 703, 704, 698, 706, 700, 704, 701, 699, 702, 705, 694, 698, 709, 736, 1053, 704, 694, 700, 698, 696, 701, 700, 700, 706, 706, 692, 698, 707, 703, 695, 703, 699, 694, 708, 695, 694, 706, 695]
S.ToArray 744.17 ms -> [746, 740, 725, 740, 739, 731, 746, 760, 735, 738, 740, 734, 744, 748, 737, 744, 745, 727, 736, 738, 728, 743, 745, 735, 748, 760, 739, 748, 762, 742, 741, 747, 733, 746, 758, 742, 742, 741, 724, 744, 747, 727, 740, 740, 729, 742, 757, 741, 740, 742, 726, 739, 746, 1133, 749, 737, 730, 740, 747, 733, 747, 752, 731, 747, 742, 730, 741, 749, 731, 749, 743, 730, 747, 742, 731, 737, 745, 734, 739, 735, 727, 743, 752, 731, 744, 742, 729, 740, 746, 731, 739, 746, 733, 745, 743, 733, 739, 742, 727, 737]

C1.ToList 31.71 ms -> [35, 32, 32, 30, 31, 33, 31, 32, 32, 31, 31, 32, 32, 33, 32, 31, 31, 32, 31, 32, 32, 32, 31, 32, 33, 32, 31, 31, 31, 32, 31, 34, 31, 31, 32, 33, 32, 32, 31, 32, 34, 32, 31, 32, 33, 31, 32, 32, 31, 32, 32, 32, 32, 32, 32, 31, 31, 32, 31, 33, 30, 31, 32, 30, 30, 33, 32, 32, 34, 31, 31, 31, 31, 32, 31, 31, 31, 31, 32, 31, 31, 33, 31, 32, 32, 32, 33, 32, 31, 31, 31, 31, 31, 32, 32, 33, 32, 31, 31, 32]
C1.ToArray 59.53 ms -> [63, 57, 58, 58, 57, 59, 59, 57, 60, 131, 127, 67, 58, 56, 59, 56, 57, 58, 58, 58, 57, 59, 60, 57, 57, 59, 60, 57, 57, 57, 58, 58, 58, 58, 57, 57, 61, 57, 58, 57, 57, 57, 57, 57, 58, 58, 58, 58, 57, 58, 59, 57, 58, 57, 57, 59, 58, 58, 59, 57, 59, 57, 56, 56, 59, 56, 56, 59, 57, 58, 58, 58, 57, 58, 59, 59, 58, 57, 58, 62, 65, 57, 57, 57, 58, 60, 59, 58, 59, 57, 58, 57, 58, 59, 58, 58, 58, 59, 60, 58]
S1.ToList 82.78 ms -> [87, 82, 83, 83, 82, 82, 83, 84, 82, 83, 84, 84, 84, 82, 82, 84, 82, 84, 83, 84, 82, 82, 82, 81, 83, 83, 83, 84, 84, 82, 82, 83, 83, 83, 82, 83, 85, 83, 82, 82, 84, 82, 82, 83, 83, 83, 82, 82, 82, 83, 82, 83, 82, 84, 82, 83, 82, 83, 82, 82, 82, 84, 82, 83, 82, 82, 86, 83, 83, 82, 83, 83, 83, 82, 84, 82, 83, 81, 82, 82, 82, 82, 83, 83, 83, 82, 83, 84, 83, 82, 83, 83, 83, 82, 83, 84, 82, 82, 83, 83]
S1.ToArray 122.3 ms -> [122, 119, 119, 120, 119, 120, 120, 121, 119, 119, 122, 120, 120, 120, 122, 120, 123, 120, 120, 120, 121, 123, 120, 120, 120, 121, 120, 121, 122, 120, 123, 119, 121, 118, 121, 120, 120, 120, 119, 124, 119, 121, 119, 120, 120, 120, 120, 120, 122, 121, 123, 230, 203, 123, 119, 119, 122, 119, 120, 120, 120, 122, 120, 121, 120, 121, 120, 121, 120, 121, 120, 120, 120, 121, 122, 121, 123, 119, 119, 119, 119, 121, 120, 120, 120, 122, 121, 122, 119, 120, 120, 121, 121, 120, 121, 120, 121, 118, 118, 118]

C2.ToList 3.43 ms -> [5, 3, 4, 4, 4, 3, 4, 4, 4, 4, 4, 3, 3, 3, 4, 3, 3, 3, 4, 3, 4, 3, 4, 3, 4, 4, 3, 3, 3, 3, 4, 3, 3, 3, 4, 3, 4, 3, 3, 3, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 3, 3, 6, 4, 4, 3, 3, 4, 3, 3, 4, 3, 3, 3, 3, 3, 3, 3, 4, 3, 3, 3, 3, 3, 3, 4, 3, 4, 4, 4, 3, 4, 4, 3, 4, 4, 4, 4, 4, 4, 3, 3, 3, 4, 4, 3, 3, 3, 3]
C2.ToArray 3.48 ms -> [3, 3, 3, 3, 4, 4, 3, 4, 4, 4, 3, 4, 3, 3, 4, 3, 3, 4, 3, 4, 3, 3, 3, 4, 3, 3, 3, 4, 3, 3, 3, 3, 4, 3, 4, 3, 3, 4, 3, 4, 3, 3, 3, 3, 4, 3, 3, 3, 3, 4, 3, 4, 3, 3, 4, 3, 3, 4, 3, 3, 4, 4, 3, 3, 4, 3, 4, 4, 3, 4, 4, 4, 4, 4, 3, 3, 3, 4, 4, 3, 4, 4, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 3, 4, 4, 4, 4, 3]
S2.ToList 41.47 ms -> [41, 41, 49, 67, 82, 41, 41, 40, 40, 40, 40, 40, 41, 40, 40, 40, 40, 40, 41, 40, 42, 42, 40, 40, 41, 41, 41, 40, 41, 40, 41, 40, 41, 40, 42, 41, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 41, 41, 41, 41, 41, 42, 41, 41, 41, 42, 40, 41, 40, 40, 40, 42, 40, 41, 42, 41, 42, 41, 42, 40, 41, 41, 41, 41, 41, 41, 41, 41, 40, 41, 40, 41, 41, 41, 40, 41, 41, 40, 40, 41, 41, 41, 41, 41, 43, 40, 40, 41, 42, 41]
S2.ToArray 40.62 ms -> [42, 41, 44, 40, 40, 40, 40, 41, 41, 40, 41, 41, 41, 40, 41, 41, 40, 41, 41, 40, 41, 40, 40, 41, 42, 41, 41, 41, 40, 40, 40, 40, 40, 41, 41, 42, 40, 41, 41, 41, 41, 41, 40, 42, 40, 40, 41, 41, 41, 40, 41, 40, 40, 40, 40, 40, 41, 40, 40, 41, 40, 40, 40, 40, 41, 40, 41, 41, 41, 40, 41, 41, 40, 41, 40, 41, 42, 40, 41, 41, 42, 41, 41, 40, 41, 40, 41, 40, 41, 41, 40, 40, 40, 41, 41, 40, 40, 40, 40, 40]

উত্তরের অক্ষরের পরিমাণের স্ট্যাকওভারফ্লো সীমাবদ্ধতার কারণে, গ্রুপ 2 এবং গ্রুপ 3 এর নমুনা তালিকা বাদ দেওয়া হয়েছে।

আপনি দেখতে পাচ্ছেন যে এটি ব্যবহার করা ToListবা ToArryবেশিরভাগ ক্ষেত্রেই সত্যই গুরুত্বপূর্ণ নয় ।

রানটাইম-গণনা করা IEnumerable<T>অবজেক্টগুলি প্রক্রিয়া করার সময় , গণনার দ্বারা আনা লোড যদি মেমরির বরাদ্দ এবং কপির অপারেশনগুলির চেয়ে ভারী হয় ToListএবং ToArray, বৈষম্য তুচ্ছ ( C.ToList vs C.ToArrayএবং S.ToList vs S.ToArray)।

পার্থক্যটি কেবলমাত্র রান-টাইম-গণনা করা IEnumerable<T>কেবলমাত্র অবজেক্টগুলিতে ( C1.ToList vs C1.ToArrayএবং S1.ToList vs S1.ToArray) লক্ষ্য করা যায়। তবে এক মিলিয়ন ছোট বস্তুতে পরম পার্থক্য (<60 মিমি) এখনও গ্রহণযোগ্য IEnumerable<T>। আসলে, পার্থক্য বাস্তবায়ন দ্বারা সিদ্ধান্ত নেওয়া হয় Enumerator<T>এর IEnumerable<T>। সুতরাং, যদি আপনার প্রোগ্রামটি সত্যিই সত্যিই সংবেদনশীল হয় তবে আপনাকে প্রোফাইল, প্রোফাইল, প্রোফাইল করতে হবে ! শেষ পর্যন্ত আপনি সম্ভবত দেখতে পাবেন যে বাধাটি চালু নেই ToListবা নয় ToArray, তবে গণকের বিশদ।

এবং এর ফলাফল C2.ToList vs C2.ToArrayএবং এটি S2.ToList vs S2.ToArrayদেখায় যে, আপনাকে সত্যিই যত্ন নেওয়ার ToListবা ToArrayঅ-রানটাইম-গণনা করা ICollection<T>অবজেক্টগুলির দরকার নেই।

অবশ্যই এটি আমার মেশিনে কেবল ফলাফল, বিভিন্ন মেশিনে এই অপারেশনগুলির আসল সময় ব্যয় একই রকম হবে না, আপনি উপরের কোডটি ব্যবহার করে আপনার মেশিনে খুঁজে পেতে পারেন।

আপনার পছন্দ করার একমাত্র কারণ হ'ল @ জেপি স্টিগ নীলসেনের উত্তর দ্বারা বর্ণিত হিসাবে আপনার নির্দিষ্ট প্রয়োজনীয়তা রয়েছে List<T>বা ।T[]


1

এই ফলাফলটি ব্যবহার করতে আগ্রহী যে কেউ লিনাক-টু-এসকিউএল যেমন

from q in context.MyTable
where myListOrArray.Contains(q.someID)
select q;

তারপরে যে এসকিউএল উত্পন্ন হয় তা হ'ল আপনি মাইলিস্টঅরারের জন্য তালিকা বা অ্যারে ব্যবহার করেছেন কিনা। এখন আমি জানি যে কেউ কেউ জিজ্ঞাসা করতে পারে যে কেন এই বিবৃতি দেওয়ার আগেও গণনা করা যেতে পারে তবে আইকিউয়েরেবল বনাম (তালিকা বা অ্যারে) থেকে উত্পন্ন এসকিউএল মধ্যে পার্থক্য রয়েছে।

আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.