LINQ के लिए खराब शब्द कहे

एक c # प्रोग्रामर के रूप में मेरा सारा जीवन, मुझे लगा कि LINQ मुख्य रूप से कोड के प्रदर्शन के बारे में नहीं है, लेकिन प्रोग्रामर के प्रदर्शन के बारे में, वह कितनी तेजी से कोड लिखता है, न कि प्रोसेसर कितनी तेजी से इस कोड को निष्पादित करता है। और कोड और प्रोग्रामर दोनों की प्रदर्शन समस्याओं को बाधाओं की पहचान करने के बाद हल किया जाता है। इसलिए, मैं अक्सर var groupedByDate = lst.GroupBy(item => item.IssueTime.Date).Select(…).ToList()नुकसान या दुर्भावनापूर्ण इरादे के कारण ऐसा लिखता हूं और करता हूं , लेकिन कोड को डीबग करना आसान है। सूची के लिए, बस चर के पाठ पर माउस कर्सर रखें और आप तुरंत देख सकते हैं कि वहां कुछ है या नहीं।

शुरू

" प्रतिबिंब को तेज करने के बारे में असफल लेख " और "इंटरनेट पर कोई व्यक्ति गलत है" के बारे में भावनाओं को शांत करने वाले लेख को पढ़ने के बाद , मुझे आश्चर्य हुआ कि क्या "मैनुअल के लिए प्रदर्शन में कोड" ऑब्जेक्ट्स के लिए "LINQ" बनाना संभव है। वस्तुओं के लिए बिल्कुल LINQ क्यों? अपने काम में, मैं अक्सर केवल LINQ को ऑब्जेक्ट्स और LINQ को एंटिटीज प्रदाताओं को उपयोग करता हूं। LINQ to Entities का प्रदर्शन मेरे लिए महत्वपूर्ण नहीं है; यह महत्वपूर्ण है कि लक्ष्य डेटाबेस सर्वर के लिए उत्पन्न SQL क्वेरी कितनी इष्टतम है और सर्वर कितनी जल्दी इसे निष्पादित करेगा।

एक आधार के रूप में, मैंने लेख के लेखक की परियोजना का उपयोग करने का निर्णय लिया। इंटरनेट से उदाहरणों के विपरीत, जहां एक कोड की तुलना मुख्य रूप से integerList.Where(item => item > 5).Sum()"मैन्युअल" कोड वाले कोड से की जाती है foreach, ifऔर इसी तरह, लेख से उदाहरण मुझे रोचक और महत्वपूर्ण लगा।

पहली चीज जो मैंने की थी, वह एक स्ट्रिंग तुलनात्मक फ़ंक्शन का उपयोग करना था। स्रोत कोड में, एक ही कार्य करने वाले तरीकों में, लेकिन अंगूठी के विपरीत कोनों में स्थित, विभिन्न तरीकों का उपयोग किया जाता है, एक मामले में variable0.Equals(constant0, StringComparison.InvariantCultureIgnoreCase)और दूसरे में variable0.ToUpperInvariant() ==constant0.ToUpperInvariant()। यह विशेष रूप से निरंतर के लिए कष्टप्रद है कि प्रत्येक विधि कॉल अपरकेस में परिवर्तित हो जाती है। मैंने दोनों ही मामलों में तीसरा विकल्प चुना variable0.ToUpperInvariant() ==constant0InUpperCaseInvariant।

तब सभी कोड जो सीधे LINQ प्रदर्शन और मैनुअल कोड की तुलना करने से संबंधित नहीं थे, को बाहर फेंक दिया गया था। पकड़ा जाने वाला पहला कोड था जो क्लास ऑब्जेक्ट बनाता है और इनिशियलाइज़ करता है Mock<HabraDbContext>। प्रत्येक परीक्षण के लिए एक बार एक डेटाबेस कनेक्शन बनाने के लिए क्या पर्याप्त है? इसे प्रदर्शन परीक्षणों से परे ले जाया गया है।

IStorage _db;

[GlobalSetup]
public void Setup()
{
    _db = MockHelper.InstanceDb();
}

private IStorage DBInstance => _db;

… — , ! Linq «» !

« - » . LINQ . , — .

, , LINQ vs «» . . . .

, , , ([Params(1, 10, 100, 1000)]). . . . StatisticColumnRelStdDev.

— FastHydrationLinq, ManualHydrationLinq — . , , (Fast)(Manual)(Slow)HydrationLinq vs (Fast)(Manual)(Slow)Hydration, ManualHydrationLinq. FastHydrationLinq - . .

ToArray, ToDictionary IEnumerable<T> . , FastContactHydrator2. - Action<Contact, string> c ConcurrentDictionary<string, Action<Contact, string>> IEnumerable<KeyValuePair<string, Action<Contact, string>>>. GetContact2, Sum, .

protected override Contact GetContact2(IEnumerable<PropertyToValueCorrelation> correlations)
{
    var contact = new Contact();
    int dummySum = _propertySettersArray.Join(correlations, propItem => propItem.Key, corrItem => corrItem.PropertyName, (prop, corr) => { prop.Value(contact, corr.Value); return 1; }).Sum();
    return contact;
}

ParseWithLinq

public static IEnumerable<KeyValuePair<string, string>> ParseWithLinq2(string rawData, string keyValueDelimiter = ":", string pairDelimiter = ";")
    => rawData.Split(pairDelimiter)
    .Select(x => x.Split(keyValueDelimiter, StringSplitOptions.RemoveEmptyEntries))
    .Select(x => x.Length == 2 ? new KeyValuePair<string, string>(x[0].Trim(), x[1].Trim())
                                : new KeyValuePair<string, string>(_unrecognizedKey, x[0].Trim()));

.

FastContactHydrator2, , , , -, ( ParseWithLinq ParseWithoutLinq). . , , ToArray. 10 var result = new List<PropertyToValueCorrelation>(10). 10? 42 , 10 . Fair .

. . GetFakeData . , .
, , « » (RelStdDev). N=1000.

:

-  `ManualHydration`, `SlowHydration`, `FastHydration`, `ManualHydrationLinq`, `SlowHydrationLinq`, `FastHydrationLinq` -     ,  ;

• ManualHydrationFair, ManualHydrationFairLinq, FastHydrationFairLinq — , ;
• FastHydrationLinq2 — , , - , LINQ;
• N , ;
• Ratio FastHydrationLinq2.

Linq-

? — FastHydrationLinq2 ManualHydrationLinq Ratio. 26,361.37 μs 26,422.17 μs N=1000. / N. ManualHydrationFairLinq, 8% , . FastHydrationFairLinq, 1% -.

Fair-. , ManualHydrationFairLinq 8% . FastHydrationFairLinq FastHydrationLinq 12%. Linq .

, . . , MockHelper.InstanceDb() Setup, . — , GetFakeData, . , — . MockHelper.InstanceDb() .

N, MakeGarbage. False , True — .

Voilà, , . — N=1. 10% 82% .

… .

, , «» — Linq-, :

N=1 MakeGarbage=True «»

, , , LINQ .
«Gen X» «Allocated» N=1 MakeGarbage=True o , FastHydrationLinq2

|                                |      Gen 0 |   Gen 1 | Gen 2 |   Allocated |
|«»     |    20.5078 |  0.4883 |     - |    63.95 KB |
|Linq-        |    20.7520 |       - |     - |    63.69 KB |

ManualHydrationFairLinq .

. , , — .
, ? . , N [Params(1, 100)] MakeGargabe=True. «» — Linq-, . — , — Linq-, Linq — — — Linq. — . .

, , — Linq- . , . paint.net, . paint.net — paint.net . paint.net — «» , — Linq- .

— N 1, 10, 100, 1000 MakeGarbage [ParamsAllValues]. paint.net, — «» . — Linq- . paint.net Visual Studio — «» . , 80- . , Linq- 2%.

परीक्षणों को लिखने और परिणामों का विश्लेषण करने के बाद, LINQ के बारे में मेरी राय नहीं बदली है - इसका उपयोग लेखन कोड में मेरी उत्पादकता इसके बिना अधिक है; LINQ से ऑब्जेक्ट्स का प्रदर्शन ठीक है। प्रदर्शन में सुधार के साधन के रूप में LINQ कोड के विलंबित निष्पादन का उपयोग करने का कोई मतलब नहीं है।

यदि किसी परियोजना में कचरा संग्रहकर्ता - .net जन्म की चोट के कारण प्रदर्शन की समस्याएं हैं, तो शायद इस तकनीक को चुनना सबसे अच्छा समाधान नहीं था।

मेरा परीक्षण कोड यहाँ उपलब्ध है ।