🧕🏿 🔴 🧒🏾 वस्तुओं के लिए लाइनक की सरल या सुविधाओं के बारे में मुश्किल है ✋🏾 🤺 👦

LINQ to ऑब्जेक्ट्स ने अब पूरी तरह से हमारे जीवन में प्रवेश कर लिया है, नेट अनुप्रयोगों के पूरे ढेर में विजयी रूप से घूम रहा है। इस लेख में, मैं कई स्पष्ट चीजों का उदाहरण देना चाहूंगा जिन्हें मुझे LINQ के साथ काम करते समय निपटना था। दिलचस्प - कृपया, बिल्ली के नीचे।

1. सूची <टी> के साथ काम करने की सुविधा

LINQ इसके कार्यान्वयन में भिन्न है जब IEnumerable <T> प्रकार की कोई वस्तु उस पर आती है और जब सूची <T> आती है। यहां तक कि सरल जहां विधि अलग पुनरावृत्तियों बनाता है:

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); * This source code was highlighted with Source Code Highlighter .
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); * This source code was highlighted with Source Code Highlighter .
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); * This source code was highlighted with Source Code Highlighter .
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); * This source code was highlighted with Source Code Highlighter .
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); * This source code was highlighted with Source Code Highlighter .

वैसे, ध्यान दें कि सरणी का अपना इट्रेटर भी होगा, इसका अंतर यह है कि यह तत्वों को सीधे एक इंडेक्स कॉल के माध्यम से प्राप्त करेगा।

यह सुविधा हमारे लिए क्या दिलचस्प बनाती है? ठीक है, उदाहरण के लिए, मैं आमतौर पर अंतिम निर्माण को कॉल करने के बारे में उलझन में था, क्योंकि विचार के अनुसार, यह पूरे गणनाकर्ता के माध्यम से अंत तक जाना चाहिए। हालांकि, यदि आप इसे उस वस्तु पर लागू करते हैं जो IList <T> इंटरफ़ेस को लागू करता है, तो अंतिम तत्व इंडेक्सर के माध्यम से प्राप्त किया जाएगा, जो निश्चित रूप से इतना बुरा नहीं है।

सार्वजनिक स्थिर TSource LastOrDefault <TSource> ( यह IEnumerable <TSource> स्रोत) {
अगर (स्रोत == null ) थ्रो एर। अर्गनमेंट नॉल ( "स्रोत" );
IList <TSource> सूची = IList <TSource> के रूप में स्रोत;
अगर (सूची! = अशक्त ) {
int count = list.Count;
अगर (गिनती> 0) वापसी सूची [गिनती - 1];
}
और {
* इस सोर्स कोड को सोर्स कोड हाइलाइटर के साथ हाइलाइट किया गया था।

इसी प्रकार का अनुकूलन एकल प्रकार के तरीकों के लिए किया जाता है

सार्वजनिक स्थिर TSource सिंगल <TSource> ( यह IEnumerable <TSource> स्रोत) {
अगर (स्रोत == null ) थ्रो एर। अर्गनमेंट नॉल ( "स्रोत" );
IList <TSource> सूची = IList <TSource> के रूप में स्रोत;
अगर (सूची! = अशक्त ) {
स्विच (सूची.काउंट) {
केस 0: एरर फेंको। नोएसेल्स ();
स्थिति 1: वापसी सूची [0];
* इस सोर्स कोड को सोर्स कोड हाइलाइटर के साथ हाइलाइट किया गया था।

2. GroupBy का काम

मान लें कि हमारे पास एक कोड है:

क्लास की
{
निजी आसानी से int _number;
सार्वजनिक स्थैतिक int HashCallsCount;
सार्वजनिक स्थिर int EqualsCountCount;
सार्वजनिक कुंजी ( int संख्या)
{
_number = संख्या;
}
सार्वजनिक बूल बराबर (मुख्य अन्य)
{
यदि (संदर्भ-संबंधी ( अशक्त , अन्य))
{
झूठे लौटना ;
}
अगर (संदर्भ ( यह , अन्य))
{
सच लौटना ;
}
अन्य लौटें। _number == _number;
}
सार्वजनिक ओवरराइड बूल बराबर ( ऑब्जेक्ट ओब्ज)
{
बराबरी का केंद्र ++;
यदि (संदर्भ-संबंधी ( अशक्त , अप्रिय))
{
झूठे लौटना ;
}
अगर (संदर्भ संदर्भ ( यह , obj))
{
सच लौटना ;
}
if (obj.GetType) (! = typeof (Key))
{
झूठे लौटना ;
}
बराबर ( वापसी ) (कुंजी) obj);
}
सार्वजनिक ओवरराइड int GetHashCode ()
{
HashCallsCount ++;
वापसी _number;
}
}
कक्षा परीक्षण
{
सार्वजनिक int नंबर { get ; सेट ; }
सार्वजनिक स्ट्रिंग नाम { प्राप्त करें ; सेट ; }
सार्वजनिक कुंजी
{
{ वापसी नई कुंजी (संख्या) ;;
}
सार्वजनिक ओवरराइड स्ट्रिंग ToString ()
{
वापसी स्ट्रिंग .Format ( "संख्या: {0}, नाम: {1}" , संख्या, नाम);
}
}
आंतरिक वर्ग कार्यक्रम
{
निजी स्थिर शून्य मुख्य ( स्ट्रिंग [] args)
{
var आइटम = Enumerable.Range (1, 20)। चयन (x => नया परीक्षण {संख्या = x% 3});
foreach (आइटम्स में var समूह । GroupBy (x => x.Key))
{
कंसोल .WriteLine ( "समूह कुंजी: {0}" , group.Key);
foreach (समूह में var आइटम)
{
कंसोल .WriteLine (आइटम);
}
}
कंसोल .WriteLine ( "EqualsCallsCount {0}" , Key.EqualsCallsCount);
कंसोल .WriteLine ( "HashCallsCount {0}" , Key.HashCallsCount);
}
}
* इस सोर्स कोड को सोर्स कोड हाइलाइटर के साथ हाइलाइट किया गया था।

EqualsCallsCount और HashCallsCount वेरिएबल्स के लिए क्या मूल्य प्रदर्शित किया जाएगा? क्रमशः 17 और 20। 17 - के रूप में मान जो समूह कुंजी बन गए हैं, उनकी तुलना अन्य कुंजियों के साथ नहीं की जाएगी (बस मामले में, मैं इंगित करूंगा कि इस उदाहरण में समूह बिल्कुल 3 है)। 20 एक चुनौती है, क्योंकि मुख्य ऑब्जेक्ट से हैश कोड का उपयोग यह निर्धारित करने के लिए किया जाता है कि टेस्ट ऑब्जेक्ट को किस समूह में रखा जाए। यहां यह ध्यान दिया जाना चाहिए कि यदि हैशकोड अद्वितीय मान देना बंद कर देता है (उदाहरण के लिए, यह हमेशा 0 वापस आ जाएगा), तो बराबर की कॉल की संख्या बढ़कर 38 हो जाएगी। मुझे लगता है कि कारण स्पष्ट हैं। एक और दिलचस्प विवरण यह है कि समूहों की डिफ़ॉल्ट सरणी 7 है

लुकअप (IEqualityComparer <TKey> तुलनित्र) {
if (तुलना == null ) तुलनाकर्ता = EqualityComparer <TKey> .Default;
this .comparer = तुलना;
समूह = नया समूहन [7];
}
* इस सोर्स कोड को सोर्स कोड हाइलाइटर के साथ हाइलाइट किया गया था।

और फिर यह रैखिक रूप से बढ़ता है, इस चरण में पूरे सरणी की प्रतिलिपि बनाता है।

शून्य आकार () {
int newSize = चेक किया गया (गणना * 2 + 1);
समूहीकरण [] newGroupings = नया समूहीकरण [newSize];
ग्रुपिंग जी = lastGrouping;
करो {
g = g.next;
int index = g.hashCode% newSize;
g.hashNext = newGroupings [सूचकांक];
newGroupings [सूचकांक] = जी;
} जबकि (जी! = lastGrouping);
समूहीकरण = newGroupings;
}
* इस सोर्स कोड को सोर्स कोड हाइलाइटर के साथ हाइलाइट किया गया था।

क्योंकि आप GroupBy विधि के लिए क्षमता निर्दिष्ट नहीं कर सकते, बड़ी संख्या में कुंजियों के साथ समूहीकरण करने से बचना बेहतर है, अन्यथा मुझे मेमोरी के साथ समस्या हो सकती है (ठीक है, निश्चित रूप से, गति समाप्त हो जाएगी)।

3. एन्यूमरेटर भी एक वस्तु है

आइए दो कार्यों पर विचार करें:

निजी स्थिर IEnumerable <Test> SortTest (Func < IEnumerable <Test >> list)
{
foreach (सूची में var आइटम) ()। OrderBy (x => x.Number) .ThenBy (x => x.Name))
{
उपज वापसी आइटम;
}
}
* इस सोर्स कोड को सोर्स कोड हाइलाइटर के साथ हाइलाइट किया गया था।

और

निजी स्थिर IEnumerable <Test> SortTest2 (Func < IEnumerable <Test >> list)
{
वापसी सूची ()। ऑर्डरबी (x => x.Number) .ThenBy (x => x.Name);
}
* इस सोर्स कोड को सोर्स कोड हाइलाइटर के साथ हाइलाइट किया गया था।

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

निष्कर्ष

मुझे उम्मीद है कि यह छोटा लेख किसी के लिए उपयोगी होगा और लिनक के साथ काम करने पर त्रुटियों से बचने में मदद करेगा। टिप्पणियाँ और परिवर्धन का स्वागत है।

संदर्भ

MSDN ओ LINQ

आपका ध्यान देने के लिए धन्यवाद।

वस्तुओं के लिए लाइनक की सरल या सुविधाओं के बारे में मुश्किल है

1. सूची <टी> के साथ काम करने की सुविधा

2. GroupBy का काम

3. एन्यूमरेटर भी एक वस्तु है

निष्कर्ष

संदर्भ

More articles: