.NET Framework
LINQ

परिचय

वाक्य - विन्यास

• सार्वजनिक स्थिर TSource एग्रीगेट <TSource> (यह IEnumerable <TSource> स्रोत, फ़ंक <TSource, TSource, TSource> func)
• सार्वजनिक स्थिर TAccumulate सकल <TSource, TAccumulate> (यह IEnumerable <TSource> स्रोत, TAccumulate बीज, Func <TAccumulate, TSource, TAccumulate> func)
• सार्वजनिक स्थैतिक ट्रेसॉल्ट एग्रीगेट <TSource, TAccumulate, TResult> (यह IEnumerable <TSource> स्रोत, TAccumulate बीज, Func <TAccumulate, TSource, TAccumulate, func, Func <TAccumulate, TResult> resultSelector)
• सार्वजनिक स्थैतिक बूलियन सभी <TSource> (यह IEnumerable <TSource> स्रोत, फ़ंक <TSource, Boolean> विधेय)
• सार्वजनिक स्थैतिक बूलियन कोई <TSource> (यह IEnumerable <TSource> स्रोत)
• सार्वजनिक स्थैतिक बूलियन कोई <TSource> (यह IEnumerable <TSource> स्रोत, फ़ंक <TSource, Boolean> विधेय)
• सार्वजनिक स्थैतिक IEnumerable <TSource> AsEnumerable <TSource> (यह IEnumerable <TSource> स्रोत)
• सार्वजनिक स्थैतिक दशमलव औसत (यह IEnumerable <दशमलव> स्रोत)
• सार्वजनिक स्थिर डबल औसत (यह IEnumerable <Double> स्रोत)
• सार्वजनिक स्थिर डबल औसत (यह IEnumerable <Int32> स्रोत)
• सार्वजनिक स्थिर डबल औसत (यह IEnumerable <Int64> स्रोत)
• सार्वजनिक स्थिर Nullable <Decimal> औसत (यह IEnumerable <Nullable <Decimal >> source)
• सार्वजनिक स्थिर Nullable <Double> औसत (यह IEnumerable <Nullable <Double >> स्रोत)
• सार्वजनिक स्थिर Nullable <Double> औसत (यह IEnumerable <Nullable <Int32 >> स्रोत)
• सार्वजनिक स्थिर Nullable <Double> औसत (यह IEnumerable <Nullable <Int64 >> source)
• सार्वजनिक स्थैतिक अशक्त <एकल> औसत (यह IEnumerable <अशक्त <एकल> स्रोत)
• सार्वजनिक स्थिर एकल औसत (यह IEnumerable <एकल> स्रोत)
• सार्वजनिक स्थैतिक दशमलव औसत <TSource> (यह IEnumerable <TSource> स्रोत, फ़ंक <TSource, दशमलव> चयनकर्ता)
• सार्वजनिक स्थिर डबल औसत <TSource> (यह IEnumerable <TSource> स्रोत, फ़ंक <TSource, डबल> चयनकर्ता)
• सार्वजनिक स्थिर डबल औसत <TSource> (यह IEnumerable <TSource> स्रोत, फ़ंक <TSource, Int32) चयनकर्ता)
• सार्वजनिक स्थिर डबल औसत <TSource> (यह IEnumerable <TSource> स्रोत, फ़ंक <TSource, Int64) चयन करें)
• सार्वजनिक स्थिर Nullable <Decimal> औसत <TSource> (यह IEnumerable <TSource> स्रोत, Func <TSource, Nullable <Decimal >> selector)
• सार्वजनिक स्थैतिक Nullable <Double> औसत <TSource> (यह IEnumerable <TSource> स्रोत, Func <TSource, Nullable <Double >> चयनकर्ता)
• सार्वजनिक स्थिर Nullable <Double> औसत <TSource> (यह IEnumerable <TSource> स्रोत, Func <TSource, Nullable <Int32 >> चयनकर्ता)
• सार्वजनिक स्थिर Nullable <Double> औसत <TSource> (यह IEnumerable <TSource> स्रोत, Func <TSource, Nullable <Int64 >> चयनकर्ता)
• सार्वजनिक स्थैतिक अशक्त <एकल> औसत <TSource> (यह IEnumerable <TSource> स्रोत, फ़ंक <TSource, Nullable <Single> चयनकर्ता)
• सार्वजनिक स्थिर एकल औसत <TSource> (यह IEnumerable <TSource> स्रोत, फ़ंक <TSource, एकल> चयनकर्ता)
• सार्वजनिक स्थैतिक IEnumerable <TResult> कास्ट <TResult> (यह IEnumerable स्रोत)
• सार्वजनिक स्थिर IEnumerable <TSource> Concat <TSource> (यह IEnumerable <TSource> पहला, IEnumerable <TSource> दूसरा)
• सार्वजनिक स्थैतिक बूलियन में <TSource> (यह IEnumerable <TSource> स्रोत, TSource मान) शामिल है
• सार्वजनिक स्थैतिक बूलियन में <TSource> (यह IEnumerable <TSource> स्रोत, TSource मूल्य, IEqualityComparer <TSource> तुलनित्र) शामिल है
• सार्वजनिक स्थिर Int32 गणना <TSource> (यह IEnumerable <TSource> स्रोत)
• सार्वजनिक स्थिर Int32 काउंट <TSource> (यह IEnumerable <TSource> स्रोत, फ़ंक <TSource, Boolean> विधेय)
• सार्वजनिक स्थैतिक IEnumerable <TSource> DefaultIfEmpty <TSource> (यह IEnumerable <TSource> स्रोत)
• सार्वजनिक स्थैतिक IEnumerable <TSource> DefaultIfEmpty <TSource> (यह IEnumerable <TSource> स्रोत, TSource defaultValue)
• सार्वजनिक स्थैतिक IEnumerable <TSource> विशिष्ट <TSource> (यह IEnumerable <TSource> स्रोत)
• सार्वजनिक स्थैतिक IEnumerable <TSource> डिस्टिक्ट <TSource> (यह IEnumerable <TSource> स्रोत, IEqualityComparer <TSource> तुलनित्र)
• सार्वजनिक स्थिर TSource ElementAt <TSource> (यह IEnumerable <TSource> स्रोत, Int32 सूचकांक)
• सार्वजनिक स्थिर TSource ElementAtOrDefault <TSource> (यह IEnumerable <TSource> स्रोत, Int3253)
• सार्वजनिक स्थैतिक IEnumerable <TResult> खाली <TResult> ()
• सार्वजनिक स्थैतिक IEnumerable <TSource> छोड़कर <TSource> (यह IEnumerable <TSource> पहले, IEnumerable <TSource> दूसरा)
• सार्वजनिक स्थैतिक IEnumerable <TSource> छोड़कर <TSource> (यह IEnumerable <TSource> पहला, IEnumerable <TSource> दूसरा, IEqualityComparer <TSource> तुलनित्र)
• सार्वजनिक स्थिर TSource पहले <TSource> (यह IEnumerable <TSource> स्रोत)
• सार्वजनिक स्थैतिक TSource पहले <TSource> (यह IEnumerable <TSource> स्रोत, Func <TSource, Boolean> विधेय)
• सार्वजनिक स्थैतिक TSource FirstOrDefault <TSource> (यह IEnumerable <TSource> स्रोत)
• सार्वजनिक स्थिर TSource FirstOrDefault <TSource> (यह IEnumerable <TSource> स्रोत, Func <TSource, Boolean> predicate)
• सार्वजनिक स्थिर IEnumerable <IGrouping <TKey, TSource >> GroupBy <TSource, TKey> (यह IEnumerable <TSource> स्रोत, फ़ंक <TSource, TKey> keySelector)
• सार्वजनिक स्थैतिक IEnumerable <IGrouping <TKey, TSource >> GroupBy <TSource, TKey> (यह IEnumerable <TSource> स्रोत, फ़ंक <TSource, TKey> keySelector, IEqualityComparer <TKey> तुलनित्र)
• सार्वजनिक स्थैतिक IEnumerable <IGeying <TKey, Telement >> GroupBy <TSource, TKey, Telement> (यह IEnumerable <TSource> स्रोत, Func <TSource, TKey> keySeoror, Func <TSource, TElement> elementSelector)
• सार्वजनिक स्थैतिक IEnumerable <IGrouping <TKey, Telement >> GroupBy <TSource, TKey, Telement> (यह IEnumerable <TSource> स्रोत, Func <TSource, TKey> keySeffor, Func <TSource, TElement> elementSelector, IEqualityComparer <TKey> तुलना करें)
• सार्वजनिक स्थैतिक IEnumerable <TResult> GroupBy <TSource, TKey, TResult> (यह IEnumerable <TSource> स्रोत, Func <TSource, TKey> keySelector, Func / TKey, IEnumerable <TSource>, TResult> resultSelector)
• सार्वजनिक स्थैतिक IEnumerable <TResult> GroupBy <TSource, TKey, TResult> (यह IEnumerable <TSource> स्रोत, Func <TSource, TKey> keySelector, Func / TKey, IEnumerable <TSource>, TResult> resultSelector, IEqualityCompowerer)
• सार्वजनिक स्थैतिक IEnumerable <TResult> GroupBy <TSource, TKey, Telement, TResult> (यह IEnumerable <TSource> स्रोत, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector, Func <TKey, IEnumerable) > परिणामकर्ता
• सार्वजनिक स्थैतिक IEnumerable <TResult> GroupBy <TSource, TKey, Telement, TResult> (यह IEnumerable <TSource> स्रोत, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector, Func <TKey, IEnumerable) > परिणामकर्ता, IEqualityComparer <TKey> तुलनित्र)
• सार्वजनिक स्थैतिक IEnumerable <TResult> GroupJoin <Touter, TInner, TKey, TResult> (यह IEnumerable <TOuter> बाहरी, IEnumerable <TInner> भीतरी, फ़न <<uter, TKey> externalKeySlector, Func <TInner, TKey> फ़िक्सी) जैसे कई फ़ीचर्स IEnumerable <TInner>, TResult> resultSelector)
• सार्वजनिक स्थैतिक IEnumerable <TResult> GroupJoin <Touter, TInner, TKey, TResult> (यह IEnumerable <TOuter> बाहरी, IEnumerable <TInner> भीतरी, फ़न <<uter, TKey> externalKeySlector, Func <TInner, TKey> फ़िक्सी) जैसे कई फ़ीचर्स IEnumerable <TInner>, TResult> resultSelector, IEqualityComparer <TKey> तुलनित्र)
• सार्वजनिक स्थैतिक IEnumerable <TSource> Intersect <TSource> (यह IEnumerable <TSource> पहला, IEnumerable <TSource> दूसरा)
• सार्वजनिक स्थिर IEnumerable <TSource> Intersect <TSource> (यह IEnumerable <TSource> पहला, IEnumerable <TSource> दूसरा, IEqualityComparer <TSource> तुलनित्र)
• सार्वजनिक स्थैतिक IEnumerable <TResult> सम्मिलित हों <TOuter, TInner, TKey, TResult> (यह IEnumerable <TOuter> बाहरी, IEnumerable <TInner> आंतरिक, Func <touter, TKey> externalKeySlector, Func <TInner, TKey> InnerKeylectorSellectors/ TInner, TResult> परिणामकर्ता
• सार्वजनिक स्थैतिक IEnumerable <TResult> सम्मिलित हों <TOuter, TInner, TKey, TResult> (यह IEnumerable <TOuter> बाहरी, IEnumerable <TInner> आंतरिक, Func <touter, TKey> externalKeySlector, Func <TInner, TKey> InnerKeylectorSellectors/ TInner, TResult> resultSelector, IEqualityComparer <TKey> तुलनित्र)
• सार्वजनिक स्थिर TSource अंतिम <TSource> (यह IEnumerable <TSource> स्रोत)
• सार्वजनिक स्थिर TSource अंतिम <TSource> (यह IEnumerable <TSource> स्रोत, फ़ंक <TSource, Boolean> विधेय)
• सार्वजनिक स्थिर TSource LastOrDefault <TSource> (यह IEnumerable <TSource> स्रोत)
• सार्वजनिक स्थिर TSource LastOrDefault <TSource> (यह IEnumerable <TSource> स्रोत, Func <TSource, Boolean> predicate)
• सार्वजनिक स्थिर Int64 LongCount <TSource> (यह IEnumerable <TSource> स्रोत)
• सार्वजनिक स्थैतिक Int64 LongCount <TSource> (यह IEnumerable <TSource> स्रोत, Func <TSource, Boolean> predicate)
• सार्वजनिक स्थैतिक दशमलव अधिकतम (यह IEnumerable <दशमलव> स्रोत)
• सार्वजनिक स्थैतिक डबल मैक्स (यह IEnumerable <Double> स्रोत)
• सार्वजनिक स्थिर Int32 मैक्स (यह IEnumerable <Int32> स्रोत)
• सार्वजनिक स्थैतिक Int64 अधिकतम (यह IEnumerable <Int64> स्रोत)
• सार्वजनिक स्थैतिक अशक्त <दशमलव> अधिकतम (यह IEnumerable <अशक्त <दशमलव >> स्रोत)
• सार्वजनिक स्थिर Nullable <Double> Max (यह IEnumerable <Nullable <Double >> source)
• सार्वजनिक स्थिर Nullable <Int32> अधिकतम (यह IEnumerable <Nullable <Int32 >> स्रोत)
• सार्वजनिक स्थिर Nullable <Int64> अधिकतम (यह IEnumerable <Nullable <Int64 >> स्रोत)
• सार्वजनिक स्थैतिक अशक्त <एकल> अधिकतम (यह IEnumerable <अशक्त <एकल> स्रोत)
• सार्वजनिक स्थैतिक एकल अधिकतम (यह IEnumerable <एकल> स्रोत)
• सार्वजनिक स्थैतिक TSource मैक्स <TSource> (यह IEnumerable <TSource> स्रोत)
• सार्वजनिक स्थैतिक दशमलव अधिकतम <TSource> (यह IEnumerable <TSource> स्रोत, फ़ंक <TSource, Decimal> चयनकर्ता)
• सार्वजनिक स्थैतिक डबल मैक्स <TSource> (यह IEnumerable <TSource> स्रोत, Func <TSource, Double> चयनकर्ता)
• सार्वजनिक स्थिर Int32 अधिकतम <TSource> (यह IEnumerable <TSource> स्रोत, फ़ंक <TSource, Int32> चयनकर्ता)
• सार्वजनिक स्थैतिक Int64 मैक्स <TSource> (यह IEnumerable <TSource> स्रोत, Func <TSource, Int64> चयनकर्ता)
• सार्वजनिक स्थिर Nullable <Decimal> Max <TSource> (यह IEnumerable <TSource> स्रोत, Func <TSource, Nullable <Decimal >> selector)
• सार्वजनिक स्थिर Nullable <Double> Max <TSource> (यह IEnumerable <TSource> स्रोत, Func <TSource, Nullable <Double >> चयनकर्ता)
• सार्वजनिक स्थिर Nullable <Int32> Max <TSource> (यह IEnumerable <TSource> स्रोत, Func <TSource, Nullable <Int32 >> चयनकर्ता)
• सार्वजनिक स्थिर Nullable <Int64> Max <TSource> (यह IEnumerable <TSource> स्रोत, Func <TSource, Nullable <Int64 >> चयनकर्ता)
• सार्वजनिक स्थिर Nullable <Single> Max <TSource> (यह IEnumerable <TSource> स्रोत, Func <TSource, Nullable <Single> चयनकर्ता)
• सार्वजनिक स्थिर एकल अधिकतम <TSource> (यह IEnumerable <TSource> स्रोत, फ़ंक <TSource, एकल> चयनकर्ता)
• सार्वजनिक स्थैतिक TResult Max <TSource, TResult> (यह IEnumerable <TSource> स्रोत, Func <TSource, TResult> चयनकर्ता)
• सार्वजनिक स्थैतिक दशमलव न्यूनतम (यह IEnumerable <दशमलव> स्रोत)
• सार्वजनिक स्थिर डबल मिन (यह IEnumerable <Double> स्रोत)
• सार्वजनिक स्थिर Int32 मिन (यह IEnumerable <Int32> स्रोत)
• सार्वजनिक स्थैतिक Int64 मिन (यह IEnumerable <Int64> स्रोत)
• सार्वजनिक स्थिर अशक्त <दशमलव> न्यूनतम (यह IEnumerable <अशक्त <दशमलव >> स्रोत)
• सार्वजनिक स्थिर Nullable <Double> Min (यह IEnumerable <Nullable <Double >> स्रोत)
• सार्वजनिक स्थिर Nullable <Int32> Min (यह IEnumerable <Nullable <Int32 >> स्रोत)
• सार्वजनिक स्थिर Nullable <Int64> Min (यह IEnumerable <Nullable <Int64 >> स्रोत)
• सार्वजनिक स्थिर Nullable <Single> Min (यह IEnumerable <Nullable <Single> स्रोत)
• सार्वजनिक स्थिर एकल मिन (यह IEnumerable <एकल> स्रोत)
• सार्वजनिक स्थैतिक TSource मिन <TSource> (यह IEnumerable <TSource> स्रोत)
• सार्वजनिक स्थैतिक दशमलव न्यूनतम <TSource> (यह IEnumerable <TSource> स्रोत, फ़ंक <TSource, दशमलव> चयनकर्ता)
• सार्वजनिक स्थिर डबल मिन <TSource> (यह IEnumerable <TSource> स्रोत, फ़ंक <TSource, डबल> चयनकर्ता)
• सार्वजनिक स्थिर Int32 Min <TSource> (यह IEnumerable <TSource> स्रोत, Func <TSource, Int32> चयनकर्ता)
• सार्वजनिक स्थैतिक Int64 मिन <TSource> (यह IEnumerable <TSource> स्रोत, फ़ंक <TSource, Int64> चयनकर्ता)
• सार्वजनिक स्थिर Nullable <Decimal> Min <TSource> (यह IEnumerable <TSource> स्रोत, Func <TSource, Nullable <Decimal >> selector)
• सार्वजनिक स्थिर Nullable <Double> Min <TSource> (यह IEnumerable <TSource> स्रोत, Func <TSource, Nullable <Double >> चयनकर्ता)
• सार्वजनिक स्थिर Nullable <Int32> Min <TSource> (यह IEnumerable <TSource> स्रोत, फ़ंक <TSource, Nullable <Int32 >> चयनकर्ता)
• सार्वजनिक स्थिर Nullable <Int64> Min <TSource> (यह IEnumerable <TSource> स्रोत, फ़ंक <TSource, Nullable <Int64 >> चयनकर्ता)
• सार्वजनिक स्थिर Nullable <Single> Min <TSource> (यह IEnumerable <TSource> स्रोत, Func <TSource, Nullable <Single> चयनकर्ता)
• सार्वजनिक स्थिर एकल मिन <टीएसओआरएस> (यह IEnumerable <TSource> स्रोत, फ़ंक <TSource, सिंगल> चयनकर्ता)
• सार्वजनिक स्थैतिक TResult Min <TSource, TResult> (यह IEnumerable <TSource> स्रोत, Func <TSource, TResult> चयनकर्ता)
• सार्वजनिक स्थैतिक IEnumerable <TResult> टाइप का <TResult> (यह IEnumerable स्रोत)
• सार्वजनिक स्थैतिक IOrderedEnumerable <TSource> OrderBy <TSource, TKey> (यह IEnumerable <TSource> स्रोत, फ़ंक <TSource, TKey> keySelector)
• सार्वजनिक स्थैतिक IOrderedEnumerable <TSource> OrderBy <TSource, TKey> (यह IEnumerable <TSource> स्रोत, फ़ंक <TSource, TKey> keySelector, IComoder <TKey> तुलनित्र)
• सार्वजनिक स्थैतिक IOrderedEnumerable <TSource> OrderByDescending <TSource, TKey> (यह IEnumerable <TSource> स्रोत, फ़ंक <TSource, TKey> keySelector)
• सार्वजनिक स्थैतिक IOrderedEnumerable <TSource> OrderByDescending <TSource, TKey> (यह IEnumerable <TSource> स्रोत, फ़ंक <TSource, TKey> keySelector, IComparer <TKey> तुलनित्र)
• सार्वजनिक स्थिर IEnumerable <Int32> रेंज (Int32 शुरू, Int32 गिनती)
• सार्वजनिक स्थिर IEnumerable <TResult> दोहराएँ <TResult> (TResult तत्व, Int32 गिनती)
• सार्वजनिक स्थैतिक IEnumerable <TSource> <TSource> (यह IEnumerable <TSource> स्रोत) रिवर्स करें
• सार्वजनिक स्थिर IEnumerable <TResult> चयन करें <TSource, TResult> (यह IEnumerable <TSource> स्रोत, Func <TSource, TResult> चयनकर्ता)
• सार्वजनिक स्थैतिक IEnumerable <TResult> चयन करें <TSource, TResult> (यह IEnumerable <TSource> स्रोत, Func <TSource, Int32, TResult> चयनकर्ता)
• सार्वजनिक स्थैतिक IEnumerable <TResult> SelectMany <TSource, TResult> (यह IEnumerable <TSource> स्रोत, Func <TSource, IEnumerable <TResult >> चयनकर्ता)
• सार्वजनिक स्थैतिक IEnumerable <TResult> SelectMany <TSource, TResult> (यह IEnumerable <TSource> स्रोत, Func <TSource, Int32, IEnumerable <TResult >> चयनकर्ता)
• सार्वजनिक स्थैतिक IEnumerable <TResult> SelectMany <TSource, TCollection, TResult> (यह IEnumerable <TSource> स्रोत, फ़ंक <TSource, IEnumerable <TCollection >> संग्रहSelector, Func <TSource, TCollection, TResult> resultSelector)
• सार्वजनिक स्थैतिक IEnumerable <TResult> SelectMany <TSource, TCollection, TResult> (यह IEnumerable <TSource> स्रोत, फ़ंक <TSource, Int32, IEnumerable / TSollection >> संग्रहSelector, Func <TSource, TCollection, TResult> परिणाम)
• सार्वजनिक स्थैतिक बूलियन अनुक्रम <TSource> (यह IEnumerable <TSource> पहले, IEnumerable <TSource> दूसरा)
• सार्वजनिक स्थैतिक बूलियन अनुक्रम <TSource> (यह IEnumerable <TSource> पहले, IEnumerable <TSource> दूसरा, IEqualityComparer <TSource> तुलनित्र)
• सार्वजनिक स्थिर TSource सिंगल <TSource> (यह IEnumerable <TSource> स्रोत)
• सार्वजनिक स्थिर TSource सिंगल <TSource> (यह IEnumerable <TSource> स्रोत, फ़ंक <TSource, Boolean> predicate)
• सार्वजनिक स्थिर TSource SingleOrDefault <TSource> (यह IEnumerable <TSource> स्रोत)
• सार्वजनिक स्थिर TSource SingleOrDefault <TSource> (यह IEnumerable <TSource> स्रोत, Func <TSource, Boolean> predicate)
• सार्वजनिक स्थैतिक IEnumerable <TSource> छोड़ें <TSource> (यह IEnumerable <TSource> स्रोत, Int323)
• सार्वजनिक स्थिर IEnumerable <TSource> SkipWhile <TSource> (यह IEnumerable <TSource> स्रोत, Func <TSource, Boolean> विधेय)
• सार्वजनिक स्थिर IEnumerable <TSource> SkipWhile <TSource> (यह IEnumerable <TSource> स्रोत, Func <TSource, Int32, Boolean> विधेय)
• सार्वजनिक स्थैतिक दशमलव योग (यह IEnumerable <दशमलव> स्रोत)
• सार्वजनिक स्थिर डबल सम (यह IEnumerable <डबल> स्रोत)
• सार्वजनिक स्थिर Int32 Sum (यह IEnumerable <Int32> स्रोत)
• सार्वजनिक स्थिर Int64 योग (यह IEnumerable <Int64> स्रोत)
• सार्वजनिक स्थिर अशक्त <दशमलव> योग (यह IEnumerable <अशक्त <दशमलव >> स्रोत)
• सार्वजनिक स्थिर Nullable <Double> Sum (यह IEnumerable <Nullable <Double >> स्रोत)
• सार्वजनिक स्थिर Nullable <Int32> Sum (यह IEnumerable <Nullable <Int32 >> स्रोत)
• सार्वजनिक स्थिर Nullable <Int64> Sum (यह IEnumerable <Nullable <Int64 >> स्रोत)
• सार्वजनिक स्थिर Nullable <Single> Sum (यह IEnumerable <Nullable <Single> स्रोत)
• सार्वजनिक स्थिर एकल योग (यह IEnumerable <एकल> स्रोत)
• सार्वजनिक स्थैतिक दशमलव योग <TSource> (यह IEnumerable <TSource> स्रोत, फ़ंक <TSource, दशमलव> चयनकर्ता)
• सार्वजनिक स्थिर डबल सम <TSource> (यह IEnumerable <TSource> स्रोत, Func <TSource, Double> चयनकर्ता)
• सार्वजनिक स्थिर Int32 Sum <TSource> (यह IEnumerable <TSource> स्रोत, फ़ंक <TSource, Int32> चयनकर्ता)
• सार्वजनिक स्थैतिक Int64 Sum <TSource> (यह IEnumerable <TSource> स्रोत, Func <TSource, Int64> चयनकर्ता)
• सार्वजनिक स्थिर Nullable <Decimal> Sum <TSource> (यह IEnumerable <TSource> स्रोत, Func <TSource, Nullable <Decimal >> selector)
• सार्वजनिक स्थिर Nullable <Double> Sum <TSource> (यह IEnumerable <TSource> स्रोत, Func <TSource, Nullable <Double >> चयनकर्ता)
• सार्वजनिक स्थिर Nullable <Int32> Sum <TSource> (यह IEnumerable <TSource> स्रोत, Func <TSource, Nullable <Int32 >> चयनकर्ता)
• सार्वजनिक स्थिर Nullable <Int64> Sum <TSource> (यह IEnumerable <TSource> स्रोत, Func <TSource, Nullable <Int64 >> चयनकर्ता)
• सार्वजनिक स्थिर Nullable <Single> Sum <TSource> (यह IEnumerable <TSource> स्रोत, Func <TSource, Nullable <Single> चयनकर्ता)
• सार्वजनिक स्थिर एकल योग <TSource> (यह IEnumerable <TSource> स्रोत, फ़ंक <TSource, एकल> चयनकर्ता)
• सार्वजनिक स्थैतिक IEnumerable <TSource> ले <TSource> (यह IEnumerable <TSource> स्रोत, Int323)
• सार्वजनिक स्थिर IEnumerable <TSource> TakeWhile <TSource> (यह IEnumerable <TSource> स्रोत, Func <TSource, Boolean> predicate)
• सार्वजनिक स्थिर IEnumerable <TSource> TakeWhile <TSource> (यह IEnumerable <TSource> स्रोत, Func <TSource, Int32, Boolean> predicate)
• सार्वजनिक स्थैतिक IOrderedEnumerable <TSource> ThenBy <TSource, TKey> (यह IOrderedEnumerable <TSource> स्रोत, फ़ंक <TSource, TKey> keySeer)
• सार्वजनिक स्थैतिक IOrderedEnumerable <TSource> ThenBy <TSource, TKey> (यह IOrderedEnumerable <TSource> स्रोत, फ़ंक <TSource, TKey> keySeoror, IComparer <TKey> तुलनित्र)
• सार्वजनिक स्थैतिक IOrderedEnumerable <TSource> तत्पश्चात <TSource, TKey> (यह IOrderedEnumerable <TSource> स्रोत, फ़ंक <TSource, TKey - keySelector)
• सार्वजनिक स्थैतिक IOrderedEnumerable <TSource> ThenByDescending <TSource, TKey> (यह IOrderedEnumerable <TSource> स्रोत, फ़ंक <TSource, TKey - keySelector, IComparer <TKey> तुलनित्र)
• सार्वजनिक स्थिर TSource [] ToArray <TSource> (यह IEnumerable <TSource> स्रोत)
• पब्लिक स्टेटिक डिक्शनरी <TKey, TSource> To मंद <TSource, TKey> (यह IEnumerable <TSource> स्रोत, Func <TSource, TKey> keySelector)
• सार्वजनिक स्थैतिक शब्दकोश <TKey, TSource> To मंद <TSource, TKey> (यह IEnumerable <TSource> स्रोत, फ़ंक <TSource, TKey> keySelector, IEqualityComparer <TKey (तुलनाकर्ता)
• पब्लिक स्टेटिक डिक्शनरी <TKey, Telement>> टोब्रोन <TSource, TKey, Telement> (यह IEnumerable <TSource> स्रोत, फ़ंक <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector)
• पब्लिक स्टेटिक डिक्शनरी <TKey, Telement>> टोब्रेंड <TSource, TKey, Telement> (यह IEnumerable <TSource> स्रोत, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector, IEqualityComparer <TKey> तुलनित्र)
• सार्वजनिक स्थैतिक सूची <TSource> ToList <TSource> (यह IEnumerable <TSource> स्रोत)
• सार्वजनिक स्थिर ILookup <TKey, TSource> ToLookup <TSource, TKey> (यह IEnumerable <TSource> स्रोत, फ़ंक <TSource, TKey> keySelector)
• सार्वजनिक स्थिर ILookup <TKey, TSource> ToLookup <TSource, TKey> (यह IEnumerable <TSource> स्रोत, फ़ंक <TSource, TKey> keySelector, IEqualityComparent <TKey> तुलनित्र)
• सार्वजनिक स्थिर ILookup <TKey, Telement> ToLookup <TSource, TKey, Telement> (यह IEnumerable <TSource> स्रोत, फ़ंक <TSource, TKey> keySelector, Func / TSource, TElement> elementSelector)
• सार्वजनिक स्थिर ILookup <TKey, TElement> ToLookup <TSource, TKey, Telement> (यह IEnumerable <TSource> स्रोत, फ़ंक <TSource, TKey> keySelector, Func / TSource, TElement> elementSelector, IEqualityComparer <TKey> तुलनित्र)
• सार्वजनिक स्थैतिक IEnumerable <TSource> संघ <TSource> (यह IEnumerable <TSource> पहला, IEnumerable <TSource> दूसरा)
• सार्वजनिक स्थैतिक IEnumerable <TSource> संघ <TSource> (यह IEnumerable <TSource> पहला, IEnumerable <TSource> दूसरा, IEqualityComparer <TSource> तुलनित्र)
• सार्वजनिक स्थैतिक IEnumerable <TSource> कहाँ <TSource> (यह IEnumerable <TSource> स्रोत, फ़ंक <TSource, Boolean> विधेय)
• सार्वजनिक स्थैतिक IEnumerable <TSource> कहाँ <TSource> (यह IEnumerable <TSource> स्रोत, Func <TSource, Int32, Boolean> विधेय)
• सार्वजनिक स्थैतिक IEnumerable <TResult> ज़िप <TFirstond, TResult> (यह IEnumerable <TFirst> पहला, IEnumerable <TSecond> दूसरा, Func <TFirst, TSecond, TResult> resultSelector)

टिप्पणियों

चुनें (नक्शा)

var persons = new[] 
{
    new {Id = 1, Name = "Foo"},
    new {Id = 2, Name = "Bar"},
    new {Id = 3, Name = "Fizz"},
    new {Id = 4, Name = "Buzz"}
};

var names = persons.Select(p => p.Name);
Console.WriteLine(string.Join(",", names.ToArray()));

//Foo,Bar,Fizz,Buzz

इस प्रकार के फ़ंक्शन को आमतौर पर कार्यात्मक प्रोग्रामिंग भाषाओं में map कहा जाता है।

कहां (फिल्टर)

यह विधि सभी तत्वों के साथ एक IEnumerable लौटाती है जो लंबोदर अभिव्यक्ति से मिलती है

उदाहरण

var personNames = new[] 
{
    "Foo", "Bar", "Fizz", "Buzz"
};

var namesStartingWithF = personNames.Where(p => p.StartsWith("F"));
Console.WriteLine(string.Join(",", namesStartingWithF));

आउटपुट:

फू, सीटी

डेमो देखें

द्वारा आदेश

var persons = new[] 
{
    new {Id = 1, Name = "Foo"},
    new {Id = 2, Name = "Bar"},
    new {Id = 3, Name = "Fizz"},
    new {Id = 4, Name = "Buzz"}
};

var personsSortedByName = persons.OrderBy(p => p.Name);

Console.WriteLine(string.Join(",", personsSortedByName.Select(p => p.Id).ToArray()));

//2,4,3,1

OrderByDescending

var persons = new[] 
{
    new {Id = 1, Name = "Foo"},
    new {Id = 2, Name = "Bar"},
    new {Id = 3, Name = "Fizz"},
    new {Id = 4, Name = "Buzz"}
};

var personsSortedByNameDescending = persons.OrderByDescending(p => p.Name);

Console.WriteLine(string.Join(",", personsSortedByNameDescending.Select(p => p.Id).ToArray()));

//1,3,4,2

शामिल

var numbers = new[] {1,2,3,4,5};
Console.WriteLine(numbers.Contains(3)); //True
Console.WriteLine(numbers.Contains(34)); //False

के सिवाय

var numbers = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
var evenNumbersBetweenSixAndFourteen = new[] { 6, 8, 10, 12 };

var result = numbers.Except(evenNumbersBetweenSixAndFourteen);

Console.WriteLine(string.Join(",", result));

//1, 2, 3, 4, 5, 7, 9

इंटरसेक्ट

var numbers1to10 = new[] {1,2,3,4,5,6,7,8,9,10};
var numbers5to15 = new[] {5,6,7,8,9,10,11,12,13,14,15};

var numbers5to10 = numbers1to10.Intersect(numbers5to15);

Console.WriteLine(string.Join(",", numbers5to10));

//5,6,7,8,9,10

concat

var numbers1to5 = new[] {1, 2, 3, 4, 5};
var numbers4to8 = new[] {4, 5, 6, 7, 8};

var numbers1to8 = numbers1to5.Concat(numbers4to8);

Console.WriteLine(string.Join(",", numbers1to8));

//1,2,3,4,5,4,5,6,7,8

ध्यान दें कि परिणाम में डुप्लिकेट रखे गए हैं। यदि यह अवांछनीय है, तो इसके बजाय Union उपयोग करें।

पहला (खोजें)

var numbers = new[] {1,2,3,4,5};

var firstNumber = numbers.First();
Console.WriteLine(firstNumber); //1

var firstEvenNumber = numbers.First(n => (n & 1) == 0);
Console.WriteLine(firstEvenNumber); //2

निम्न फेंकता है InvalidOperationException संदेश के साथ "अनुक्रम में कोई मिलान तत्व नहीं है":

var firstNegativeNumber = numbers.First(n => n < 0);

एक

var oneNumber = new[] {5};
var theOnlyNumber = oneNumber.Single();
Console.WriteLine(theOnlyNumber);  //5

var numbers = new[] {1,2,3,4,5};

var theOnlyNumberSmallerThanTwo = numbers.Single(n => n < 2);
Console.WriteLine(theOnlyNumberSmallerThanTwo);  //1

अनुक्रम में एक से अधिक तत्व होने के बाद निम्न InvalidOperationException फेंकता है:

var theOnlyNumberInNumbers = numbers.Single();
var theOnlyNegativeNumber = numbers.Single(n => n < 0);

अंतिम

var numbers = new[] {1,2,3,4,5};

var lastNumber = numbers.Last();
Console.WriteLine(lastNumber); //5

var lastEvenNumber = numbers.Last(n => (n & 1) == 0);
Console.WriteLine(lastEvenNumber); //4

निम्न फेंकता है InvalidOperationException :

var lastNegativeNumber = numbers.Last(n => n < 0);

LastOrDefault

var numbers = new[] {1,2,3,4,5};

var lastNumber = numbers.LastOrDefault();
Console.WriteLine(lastNumber); //5

var lastEvenNumber = numbers.LastOrDefault(n => (n & 1) == 0);
Console.WriteLine(lastEvenNumber); //4

var lastNegativeNumber = numbers.LastOrDefault(n => n < 0);
Console.WriteLine(lastNegativeNumber); //0

var words = new[] { "one", "two", "three", "four", "five" };

var lastWord = words.LastOrDefault();
Console.WriteLine(lastWord); // five

var lastLongWord = words.LastOrDefault(w => w.Length > 4);
Console.WriteLine(lastLongWord); // three

var lastMissingWord = words.LastOrDefault(w => w.Length > 5);
Console.WriteLine(lastMissingWord); // null

SingleOrDefault

var oneNumber = new[] {5};
var theOnlyNumber = oneNumber.SingleOrDefault();
Console.WriteLine(theOnlyNumber);  //5

var numbers = new[] {1,2,3,4,5};

var theOnlyNumberSmallerThanTwo = numbers.SingleOrDefault(n => n < 2);
Console.WriteLine(theOnlyNumberSmallerThanTwo);  //1

var theOnlyNegativeNumber = numbers.SingleOrDefault(n => n < 0);
Console.WriteLine(theOnlyNegativeNumber);  //0

निम्न फेंकता है InvalidOperationException :

var theOnlyNumberInNumbers = numbers.SingleOrDefault();

FirstOrDefault

var numbers = new[] {1,2,3,4,5};

var firstNumber = numbers.FirstOrDefault();
Console.WriteLine(firstNumber); //1

var firstEvenNumber = numbers.FirstOrDefault(n => (n & 1) == 0);
Console.WriteLine(firstEvenNumber); //2

var firstNegativeNumber = numbers.FirstOrDefault(n => n < 0);
Console.WriteLine(firstNegativeNumber); //0

var words = new[] { "one", "two", "three", "four", "five" };

var firstWord = words.FirstOrDefault();
Console.WriteLine(firstWord); // one

var firstLongWord = words.FirstOrDefault(w => w.Length > 3);
Console.WriteLine(firstLongWord); // three

var firstMissingWord = words.FirstOrDefault(w => w.Length > 5);
Console.WriteLine(firstMissingWord); // null

कोई भी

यदि संग्रह में कोई भी तत्व है जो लंबोदर अभिव्यक्ति में स्थिति से मिलता है, तो यह true :

var numbers = new[] {1,2,3,4,5};

var isNotEmpty = numbers.Any();
Console.WriteLine(isNotEmpty); //True

var anyNumberIsOne = numbers.Any(n => n == 1);
Console.WriteLine(anyNumberIsOne); //True

var anyNumberIsSix = numbers.Any(n => n == 6);
Console.WriteLine(anyNumberIsSix); //False    

var anyNumberIsOdd = numbers.Any(n => (n & 1) == 1);
Console.WriteLine(anyNumberIsOdd); //True

var anyNumberIsNegative = numbers.Any(n => n < 0);
Console.WriteLine(anyNumberIsNegative); //False

सब

var numbers = new[] {1,2,3,4,5};

var allNumbersAreOdd = numbers.All(n => (n & 1) == 1);
Console.WriteLine(allNumbersAreOdd); //False

var allNumbersArePositive = numbers.All(n => n > 0);
Console.WriteLine(allNumbersArePositive); //True

ध्यान दें कि All विधि विधेय के अनुसार पहले तत्व के लिए false रूप में मूल्यांकन करने के लिए जाँच कर रही है। इसलिए, इस मामले में किसी भी विधेय के लिए यह पद्धति true होगी कि सेट खाली है:

var numbers = new int[0];
var allNumbersArePositive = numbers.All(n => n > 0);
Console.WriteLine(allNumbersArePositive); //True

SelectMany (फ्लैट नक्शा)

Enumerable.Select प्रत्येक इनपुट तत्व के लिए एक आउटपुट तत्व देता है। जबकि Enumerable.SelectMany प्रत्येक इनपुट तत्व के लिए आउटपुट तत्वों की एक चर संख्या का उत्पादन करता है। इसका अर्थ है कि इनपुट अनुक्रम में आउटपुट अनुक्रम में अधिक या कम तत्व हो सकते हैं।

Lambda expressions Enumerable.Select को दिया गया था जो एक आइटम वापस करना चाहिए। Enumerable.SelectMany लिए पारित लैम्ब्डा भाव एक बच्चे के अनुक्रम का उत्पादन करना चाहिए। इस बाल अनुक्रम में इनपुट अनुक्रम में प्रत्येक तत्व के लिए अलग-अलग संख्या हो सकती है।

उदाहरण

class Invoice
{
    public int Id { get; set; }
}

class Customer
{
    public Invoice[] Invoices {get;set;}
}

var customers = new[] {
    new Customer {
        Invoices = new[] {
            new Invoice {Id=1},
            new Invoice {Id=2},
        }
    },
    new Customer {
        Invoices = new[] {
            new Invoice {Id=3},
            new Invoice {Id=4},
        }
    },
    new Customer {
        Invoices = new[] {
            new Invoice {Id=5},
            new Invoice {Id=6},
        }
    }
};

var allInvoicesFromAllCustomers = customers.SelectMany(c => c.Invoices);

Console.WriteLine(
    string.Join(",", allInvoicesFromAllCustomers.Select(i => i.Id).ToArray()));

आउटपुट:

1,2,3,4,5,6

डेमो देखें

Enumerable.SelectMany को सिंटैक्स-आधारित क्वेरी के साथ Enumerable.SelectMany from लगातार दो का उपयोग करके भी प्राप्त किया जा सकता है:

var allInvoicesFromAllCustomers
    = from customer in customers
      from invoice in customer.Invoices
      select invoice;

योग

var numbers = new[] {1,2,3,4};

var sumOfAllNumbers = numbers.Sum();
Console.WriteLine(sumOfAllNumbers); //10

var cities = new[] {
    new {Population = 1000},
    new {Population = 2500},
    new {Population = 4000}
};

var totalPopulation = cities.Sum(c => c.Population);
Console.WriteLine(totalPopulation); //7500

छोड़ें

छोड़ें उन्हें वापस किए बिना पहले N आइटम को एन्यूमरेट करेंगे। आइटम नंबर N + 1 पहुँच जाने के बाद, छोड़ें प्रत्येक प्रगणित आइटम वापस करना शुरू कर देता है:

var numbers = new[] {1,2,3,4,5};

var allNumbersExceptFirstTwo = numbers.Skip(2);
Console.WriteLine(string.Join(",", allNumbersExceptFirstTwo.ToArray()));

//3,4,5

लेना

यह विधि एक एन्यूमरेबल से पहले n तत्वों को लेती है।

var numbers = new[] {1,2,3,4,5};

var threeFirstNumbers = numbers.Take(3);
Console.WriteLine(string.Join(",", threeFirstNumbers.ToArray()));

//1,2,3

SequenceEqual

var numbers = new[] {1,2,3,4,5};
var sameNumbers = new[] {1,2,3,4,5};
var sameNumbersInDifferentOrder = new[] {5,1,4,2,3};

var equalIfSameOrder = numbers.SequenceEqual(sameNumbers);
Console.WriteLine(equalIfSameOrder); //True

var equalIfDifferentOrder = numbers.SequenceEqual(sameNumbersInDifferentOrder);
Console.WriteLine(equalIfDifferentOrder); //False

रिवर्स

var numbers = new[] {1,2,3,4,5};
var reversed = numbers.Reverse();

Console.WriteLine(string.Join(",", reversed.ToArray()));

//5,4,3,2,1

OfType

var mixed = new object[] {1,"Foo",2,"Bar",3,"Fizz",4,"Buzz"};
var numbers = mixed.OfType<int>();

Console.WriteLine(string.Join(",", numbers.ToArray()));

//1,2,3,4

मैक्स

var numbers = new[] {1,2,3,4};

var maxNumber = numbers.Max();
Console.WriteLine(maxNumber); //4

var cities = new[] {
    new {Population = 1000},
    new {Population = 2500},
    new {Population = 4000}
};

var maxPopulation = cities.Max(c => c.Population);
Console.WriteLine(maxPopulation); //4000

मिन

var numbers = new[] {1,2,3,4};

var minNumber = numbers.Min();
Console.WriteLine(minNumber); //1

var cities = new[] {
    new {Population = 1000},
    new {Population = 2500},
    new {Population = 4000}
};

var minPopulation = cities.Min(c => c.Population);
Console.WriteLine(minPopulation); //1000

औसत

var numbers = new[] {1,2,3,4};

var averageNumber = numbers.Average();
Console.WriteLine(averageNumber); 
// 2,5

यह विधि संख्याओं की गणना के औसत की गणना करती है।

var cities = new[] {
    new {Population = 1000},
    new {Population = 2000},
    new {Population = 4000}
};

var averagePopulation = cities.Average(c => c.Population);
Console.WriteLine(averagePopulation);
// 2333,33

यह विधि प्रत्यायोजित फ़ंक्शन का उपयोग करके गणना करने योग्य औसत की गणना करती है।

ज़िप

var tens = new[] {10,20,30,40,50};
var units = new[] {1,2,3,4,5};

var sums = tens.Zip(units, (first, second) => first + second);

Console.WriteLine(string.Join(",", sums));

//11,22,33,44,55

अलग

var numbers = new[] {1, 1, 2, 2, 3, 3, 4, 4, 5, 5};
var distinctNumbers = numbers.Distinct();

Console.WriteLine(string.Join(",", distinctNumbers));

//1,2,3,4,5

समूह द्वारा

var persons = new[] {
    new { Name="Fizz", Job="Developer"},
    new { Name="Buzz", Job="Developer"},
    new { Name="Foo", Job="Astronaut"},
    new { Name="Bar", Job="Astronaut"},
};

var groupedByJob = persons.GroupBy(p => p.Job);

foreach(var theGroup in groupedByJob)
{
    Console.WriteLine(
        "{0} are {1}s", 
        string.Join(",", theGroup.Select(g => g.Name).ToArray()),
        theGroup.Key);
}

//Fizz,Buzz are Developers
//Foo,Bar are Astronauts

देश द्वारा समूह चालान, रिकॉर्ड की संख्या, कुल भुगतान और औसत भुगतान के साथ एक नई वस्तु का निर्माण

var a = db.Invoices.GroupBy(i => i.Country)
          .Select(g => new { Country = g.Key,
                             Count = g.Count(),
                             Total = g.Sum(i => i.Paid),
                             Average = g.Average(i => i.Paid) });

यदि हम केवल योग चाहते हैं, तो कोई समूह नहीं

var a = db.Invoices.GroupBy(i => 1)
          .Select(g => new { Count = g.Count(),
                             Total = g.Sum(i => i.Paid),
                             Average = g.Average(i => i.Paid) });

अगर हमें कई मायने हैं

var a = db.Invoices.GroupBy(g => 1)
          .Select(g => new { High = g.Count(i => i.Paid >= 1000),
                             Low = g.Count(i => i.Paid < 1000),
                             Sum = g.Sum(i => i.Paid) });

ToDictionary

कुंजी को निर्धारित करने के लिए दिए गए keySelector फ़ंक्शन का उपयोग करके स्रोत IEnumerable से एक नया शब्दकोश देता है। यदि ArgumentException फेंक देंगे यदि KeySelector इंजेक्टिव नहीं है (स्रोत संग्रह के प्रत्येक सदस्य के लिए एक अद्वितीय मान लौटाता है।) ऐसे अधिभार हैं जो किसी को मान के साथ-साथ कुंजी को संग्रहीत करने के लिए निर्दिष्ट करने की अनुमति देते हैं।

var persons = new[] {
    new { Name="Fizz", Id=1},
    new { Name="Buzz", Id=2},
    new { Name="Foo", Id=3},
    new { Name="Bar", Id=4},
};

बस एक प्रमुख चयनकर्ता समारोह को निर्दिष्ट करना एक पैदा करेगा Dictionary<TKey,TVal> साथ TKey कुंजी चयनकर्ता, की वापसी प्रकार TVal मूल वस्तु प्रकार, और संग्रहीत मूल्य के रूप में मूल वस्तु।

var personsById = persons.ToDictionary(p => p.Id);
// personsById is a Dictionary<int,object>

Console.WriteLine(personsById[1].Name); //Fizz
Console.WriteLine(personsById[2].Name); //Buzz

साथ ही एक मूल्य के चयनकर्ता समारोह को निर्दिष्ट करना एक पैदा करेगा Dictionary<TKey,TVal> साथ TKey अभी भी प्रमुख चयनकर्ता की वापसी प्रकार है, लेकिन TVal अब मूल्य चयनकर्ता समारोह की वापसी प्रकार, और संग्रहीत मूल्य के रूप में दिए गए मान।

var namesById = persons.ToDictionary(p => p.Id, p => p.Name);
//namesById is a Dictionary<int,string>

Console.WriteLine(namesById[3]); //Foo
Console.WriteLine(namesById[4]); //Bar

जैसा कि ऊपर कहा गया है, कुंजी चयनकर्ता द्वारा दी गई कुंजी अद्वितीय होनी चाहिए। निम्नलिखित एक अपवाद फेंक देगा।

var persons = new[] {
    new { Name="Fizz", Id=1},
    new { Name="Buzz", Id=2},
    new { Name="Foo", Id=3},
    new { Name="Bar", Id=4},
    new { Name="Oops", Id=4}
};

var willThrowException = persons.ToDictionary(p => p.Id)

यदि स्रोत संग्रह के लिए एक अद्वितीय कुंजी नहीं दी जा सकती है, तो इसके बजाय ToLookup का उपयोग करने पर विचार करें। सतह पर, ToLookup, To retard के समान व्यवहार करता है, हालाँकि, परिणामी लुकअप में प्रत्येक कुंजी को मिलान कुंजी के साथ मानों के संग्रह के साथ रखा जाता है।

संघ

var numbers1to5 = new[] {1,2,3,4,5};
var numbers4to8 = new[] {4,5,6,7,8};

var numbers1to8 = numbers1to5.Union(numbers4to8);

Console.WriteLine(string.Join(",", numbers1to8));

//1,2,3,4,5,6,7,8

ध्यान दें कि परिणाम से डुप्लिकेट हटा दिए जाते हैं। यदि यह अवांछनीय है, तो इसके बजाय Concat उपयोग करें।

toArray

var numbers = new[] {1,2,3,4,5,6,7,8,9,10};
var someNumbers = numbers.Where(n => n < 6);

Console.WriteLine(someNumbers.GetType().Name);
//WhereArrayIterator`1

var someNumbersArray = someNumbers.ToArray();

Console.WriteLine(someNumbersArray.GetType().Name);
//Int32[]

सूची बनाने के लिए

var numbers = new[] {1,2,3,4,5,6,7,8,9,10};
var someNumbers = numbers.Where(n => n < 6);

Console.WriteLine(someNumbers.GetType().Name);
//WhereArrayIterator`1

var someNumbersList = someNumbers.ToList();

Console.WriteLine(
    someNumbersList.GetType().Name + " - " +
    someNumbersList.GetType().GetGenericArguments()[0].Name);
//List`1 - Int32

गिनती

IEnumerable<int> numbers = new[] {1,2,3,4,5,6,7,8,9,10};

var numbersCount = numbers.Count();
Console.WriteLine(numbersCount); //10

var evenNumbersCount = numbers.Count(n => (n & 1) == 0);
Console.WriteLine(evenNumbersCount); //5

ElementAt

var names = new[] {"Foo","Bar","Fizz","Buzz"};

var thirdName = names.ElementAt(2);
Console.WriteLine(thirdName); //Fizz

//The following throws ArgumentOutOfRangeException

var minusOnethName = names.ElementAt(-1);
var fifthName = names.ElementAt(4);

ElementAtOrDefault

var names = new[] {"Foo","Bar","Fizz","Buzz"};

var thirdName = names.ElementAtOrDefault(2);
Console.WriteLine(thirdName); //Fizz

var minusOnethName = names.ElementAtOrDefault(-1);
Console.WriteLine(minusOnethName); //null

var fifthName = names.ElementAtOrDefault(4);
Console.WriteLine(fifthName); //null

SkipWhile

var numbers = new[] {2,4,6,8,1,3,5,7};

var oddNumbers = numbers.SkipWhile(n => (n & 1) == 0);

Console.WriteLine(string.Join(",", oddNumbers.ToArray()));

//1,3,5,7

TakeWhile

var numbers = new[] {2,4,6,1,3,5,7,8};

var evenNumbers = numbers.TakeWhile(n => (n & 1) == 0);

Console.WriteLine(string.Join(",", evenNumbers.ToArray()));

//2,4,6

DefaultIfEmpty

var numbers = new[] {2,4,6,8,1,3,5,7};

var numbersOrDefault = numbers.DefaultIfEmpty();
Console.WriteLine(numbers.SequenceEqual(numbersOrDefault)); //True

var noNumbers = new int[0];

var noNumbersOrDefault = noNumbers.DefaultIfEmpty();
Console.WriteLine(noNumbersOrDefault.Count()); //1
Console.WriteLine(noNumbersOrDefault.Single()); //0

var noNumbersOrExplicitDefault = noNumbers.DefaultIfEmpty(34);
Console.WriteLine(noNumbersOrExplicitDefault.Count()); //1
Console.WriteLine(noNumbersOrExplicitDefault.Single()); //34

अलग करना (गुना)

प्रत्येक चरण में एक नई वस्तु बनाना:

var elements = new[] {1,2,3,4,5};

var commaSeparatedElements = elements.Aggregate(
    seed: "",
    func: (aggregate, element) => $"{aggregate}{element},");
    
Console.WriteLine(commaSeparatedElements);  //1,2,3,4,5,

सभी चरणों में एक ही वस्तु का उपयोग करना:

var commaSeparatedElements2 = elements.Aggregate(
    seed: new StringBuilder(),
    func: (seed, element) => seed.Append($"{element},"));
    
Console.WriteLine(commaSeparatedElements2.ToString());  //1,2,3,4,5,

परिणाम चयनकर्ता का उपयोग करना:

var commaSeparatedElements3 = elements.Aggregate(
    seed: new StringBuilder(),
    func: (seed, element) => seed.Append($"{element},"),
    resultSelector: (seed) => seed.ToString());
Console.WriteLine(commaSeparatedElements3);  //1,2,3,4,5,

यदि एक बीज छोड़ा जाता है, तो पहला तत्व बीज बन जाता है:

var seedAndElements = elements.Select(n=>n.ToString());
var commaSeparatedElements4 = seedAndElements.Aggregate(
    func: (aggregate, element) => $"{aggregate}{element},");

Console.WriteLine(commaSeparatedElements4);  //12,3,4,5,

देखने के लिए

var persons = new[] {
    new { Name="Fizz", Job="Developer"},
    new { Name="Buzz", Job="Developer"},
    new { Name="Foo", Job="Astronaut"},
    new { Name="Bar", Job="Astronaut"},
};

var groupedByJob = persons.ToLookup(p => p.Job);

foreach(var theGroup in groupedByJob)
{
    Console.WriteLine(
        "{0} are {1}s", 
        string.Join(",", theGroup.Select(g => g.Name).ToArray()),
        theGroup.Key);
}

//Fizz,Buzz are Developers
//Foo,Bar are Astronauts

शामिल हों

class Developer
{
    public int Id { get; set; }
    public string Name { get; set; }
}

class Project
{
    public int DeveloperId { get; set; }
    public string Name { get; set; }
}

var developers = new[] {
    new Developer {
        Id = 1,
        Name = "Foobuzz"
    },
    new Developer {
        Id = 2,
        Name = "Barfizz"
    }
};

var projects = new[] {
    new Project {
        DeveloperId = 1,
        Name = "Hello World 3D"
    },
    new Project {
        DeveloperId = 1,
        Name = "Super Fizzbuzz Maker"
    },
    new Project {
        DeveloperId = 2,
        Name = "Citizen Kane - The action game"
    },
    new Project {
        DeveloperId = 2,
        Name = "Pro Pong 2016"
    }
};

var denormalized = developers.Join(
    inner: projects,
    outerKeySelector: dev => dev.Id,
    innerKeySelector: proj => proj.DeveloperId,
    resultSelector: 
        (dev, proj) => new {
            ProjectName = proj.Name,
            DeveloperName = dev.Name});
    
foreach(var item in denormalized)
{
    Console.WriteLine("{0} by {1}", item.ProjectName, item.DeveloperName);
}

//Hello World 3D by Foobuzz
//Super Fizzbuzz Maker by Foobuzz
//Citizen Kane - The action game by Barfizz
//Pro Pong 2016 by Barfizz

GroupJoin

class Developer
{
    public int Id { get; set; }
    public string Name { get; set; }
}

class Project
{
    public int DeveloperId { get; set; }
    public string Name { get; set; }
}

var developers = new[] {
    new Developer {
        Id = 1,
        Name = "Foobuzz"
    },
    new Developer {
        Id = 2,
        Name = "Barfizz"
    }
};

var projects = new[] {
    new Project {
        DeveloperId = 1,
        Name = "Hello World 3D"
    },
    new Project {
        DeveloperId = 1,
        Name = "Super Fizzbuzz Maker"
    },
    new Project {
        DeveloperId = 2,
        Name = "Citizen Kane - The action game"
    },
    new Project {
        DeveloperId = 2,
        Name = "Pro Pong 2016"
    }
};

var grouped = developers.GroupJoin(
    inner: projects,
    outerKeySelector: dev => dev.Id,
    innerKeySelector: proj => proj.DeveloperId,
    resultSelector: 
        (dev, projs) => new {
            DeveloperName = dev.Name, 
            ProjectNames = projs.Select(p => p.Name).ToArray()});
    
foreach(var item in grouped)
{
    Console.WriteLine(
        "{0}'s projects: {1}", 
        item.DeveloperName,
        string.Join(", ", item.ProjectNames));
}

//Foobuzz's projects: Hello World 3D, Super Fizzbuzz Maker
//Barfizz's projects: Citizen Kane - The action game, Pro Pong 2016

कास्ट

Cast Enumerable के अन्य तरीकों से अलग है कि यह IEnumerable लिए एक विस्तार विधि है, IEnumerable<T> लिए नहीं। इस प्रकार इसका उपयोग पूर्व के उदाहरणों को बाद के उदाहरणों में परिवर्तित करने के लिए किया जा सकता है।

यह संकलन नहीं करता है क्योंकि ArrayList IEnumerable<T> लागू नहीं करता है:

var numbers = new ArrayList() {1,2,3,4,5};
Console.WriteLine(numbers.First());

यह उम्मीद के मुताबिक काम करता है:

var numbers = new ArrayList() {1,2,3,4,5};
Console.WriteLine(numbers.Cast<int>().First()); //1

Cast रूपांतरण Cast नहीं करता है। निम्नलिखित संकलन लेकिन रनटाइम पर InvalidCastException को फेंकता है:

var numbers = new int[] {1,2,3,4,5};
decimal[] numbersAsDecimal = numbers.Cast<decimal>().ToArray();

एक संग्रह के लिए एक परिवर्तित डाली प्रदर्शन करने का उचित तरीका इस प्रकार है:

var numbers= new int[] {1,2,3,4,5};
decimal[] numbersAsDecimal = numbers.Select(n => (decimal)n).ToArray();

खाली

Int का खाली IEnumerable बनाने के लिए:

IEnumerable<int> emptyList = Enumerable.Empty<int>(); 

यह खाली IEnumerable प्रत्येक प्रकार T के लिए कैश किया गया है, ताकि:

Enumerable.Empty<decimal>() == Enumerable.Empty<decimal>(); // This is True
Enumerable.Empty<int>() == Enumerable.Empty<decimal>();     // This is False

तब तक

ThenBy एक के बाद ही किया जा सकता है OrderBy खंड एकाधिक मापदंड का उपयोग करते हुए आदेश करने की इजाजत दी

var persons = new[] 
{
    new {Id = 1, Name = "Foo", Order = 1},
    new {Id = 1, Name = "FooTwo", Order = 2},
    new {Id = 2, Name = "Bar", Order = 2},
    new {Id = 2, Name = "BarTwo", Order = 1},
    new {Id = 3, Name = "Fizz", Order = 2},
    new {Id = 3, Name = "FizzTwo", Order = 1},  
};

var personsSortedByName = persons.OrderBy(p => p.Id).ThenBy(p => p.Order);

Console.WriteLine(string.Join(",", personsSortedByName.Select(p => p.Name)));
//This will display : 
//Foo,FooTwo,BarTwo,Bar,FizzTwo,Fizz

रेंज

Range दो पैरामीटर पहला नंबर और उत्पादन करने के लिए तत्वों की गिनती (अंतिम संख्या नहीं) हैं।

// prints 1,2,3,4,5,6,7,8,9,10
Console.WriteLine(string.Join(",", Enumerable.Range(1, 10)));

// prints 10,11,12,13,14
Console.WriteLine(string.Join(",", Enumerable.Range(10, 5)));

बाईं ओर का बाहरी जोड़

class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

class Pet
{
    public string Name { get; set; }
    public Person Owner { get; set; }
}

public static void Main(string[] args)
{
    var magnus = new Person { FirstName = "Magnus", LastName = "Hedlund" };
    var terry = new Person { FirstName = "Terry", LastName = "Adams" };

    var barley = new Pet { Name = "Barley", Owner = terry };

    var people = new[] { magnus, terry };
    var pets = new[] { barley };

    var query =
        from person in people
        join pet in pets on person equals pet.Owner into gj
        from subpet in gj.DefaultIfEmpty()
        select new
        {
            person.FirstName,
            PetName = subpet?.Name ?? "-" // Use - if he has no pet
        };

    foreach (var p in query)
        Console.WriteLine($"{p.FirstName}: {p.PetName}");
}

दोहराना

Enumerable.Repeat एक दोहराया मूल्य का एक क्रम उत्पन्न करता है। इस उदाहरण में यह 4 बार "हैलो" उत्पन्न करता है।

var repeats = Enumerable.Repeat("Hello", 4);
   
foreach (var item in repeats)
{
    Console.WriteLine(item);
}

/* output:
    Hello
    Hello
    Hello
    Hello
*/