private IEnumerable<string> Tables
{
get
{
yield return "Foo";
yield return "Bar";
}
}
मान लीजिए कि मैं उन पर पुनरावृति चाहता हूं और # एम के # प्रसंस्करण की तरह कुछ लिखता हूं।
क्या कोई ऐसा तरीका है जिससे मैं अपने मुख्य पुनरावृत्ति से पहले पुनरावृत्ति के बिना मी का मूल्य ज्ञात कर सकता हूँ?
मुझे उम्मीद है कि मैंने खुद को स्पष्ट कर दिया है।
जवाबों:
IEnumerableयह समर्थन नहीं करता है। यह डिजाइन द्वारा है। IEnumerableआलसी मूल्यांकन का उपयोग उन तत्वों को प्राप्त करने के लिए करते हैं जिन्हें आप अपनी आवश्यकता से ठीक पहले मांगते हैं।
यदि आप उन वस्तुओं की संख्या जानना चाहते हैं, जिन्हें आप उपयोग नहीं कर सकते हैं ICollection<T>, तो इसके पास एक Countसंपत्ति है।
System.Linq.Enumerable.Countविस्तार पद्धति पर IEnumerable<T>निम्नलिखित कार्यान्वयन है:
ICollection<T> c = source as ICollection<TSource>;
if (c != null)
return c.Count;
int result = 0;
using (IEnumerator<T> enumerator = source.GetEnumerator())
{
while (enumerator.MoveNext())
result++;
}
return result;
तो यह कास्ट करने की कोशिश करता है ICollection<T>, जिसके पास एक Countसंपत्ति है, और यदि संभव हो तो इसका उपयोग करता है। अन्यथा यह पुनरावृति करता है।
तो आपकी सबसे अच्छी शर्त यह है कि आप Count()अपने IEnumerable<T>ऑब्जेक्ट पर एक्सटेंशन विधि का उपयोग करें , क्योंकि आपको उस तरह से सबसे अच्छा प्रदर्शन संभव होगा।
ICollection<T>पहली बार कास्ट करने की कोशिश करता है ।
Tपर IEnumerator<T> enumerator = source.GetEnumerator(), बस आप यह कर सकते हैं: IEnumerator enumerator = source.GetEnumerator()और काम करना चाहिए!
IEnumerable<T>इनहेरिट करता है IDisposableजो usingस्टेटमेंट को स्वचालित रूप से डिस्पोज करने की अनुमति देता है । IEnumerableनहीं करता। इसलिए यदि आप GetEnumeratorकिसी भी तरह से कॉल करते हैं, तो आपको खत्म करना चाहिएvar d = e as IDisposable; if (d != null) d.Dispose();
बस अतिरिक्त कुछ जानकारी जोड़ना:
Count()विस्तार हमेशा पुनरावृति नहीं है। Linq को Sql पर विचार करें, जहां गिनती डेटाबेस में जाती है, लेकिन सभी पंक्तियों को वापस लाने के बजाय, यह Sql Count()कमांड जारी करता है और इसके बजाय उस परिणाम को लौटाता है।
इसके अतिरिक्त, कंपाइलर (या रनटाइम) पर्याप्त स्मार्ट है कि यह ऑब्जेक्ट Count()विधि को कॉल करेगा यदि इसमें एक है। तो यह अन्य उत्तरदाताओं के रूप में नहीं है , तत्वों की गणना करने के लिए पूरी तरह से अनभिज्ञ और हमेशा पुनरावृत्त होना।
कई मामलों में जहां प्रोग्रामर एक्सटेंशन विधि if( enumerable.Count != 0 )का उपयोग करके जांच कर रहा है Any(), जैसा कि if( enumerable.Any() ) लाइनक के आलसी मूल्यांकन के साथ कहीं अधिक कुशल है क्योंकि यह शॉर्ट-सर्किट हो सकता है एक बार यह निर्धारित कर सकता है कि कोई तत्व हैं। यह अधिक पठनीय भी है
.Countहैं तो संपत्ति का उपयोग करें क्योंकि यह हमेशा जानता है कि यह आकार है। जब collection.Countकोई अतिरिक्त गणना नहीं की जाती है, तो यह पहले से ज्ञात संख्या को वापस कर देता है। Array.lengthजहाँ तक मुझे पता है, उसी के लिए । हालांकि, .Any()स्रोत के प्रगणक का उपयोग करके प्राप्त करता है using (IEnumerator<TSource> enumerator = source.GetEnumerator())और अगर यह कर सकता है तो सही रिटर्न देता है enumerator.MoveNext()। संग्रह के लिए:, if(collection.Count > 0)सरणियाँ: if(array.length > 0)और enumerables पर if(collection.Any())।
IQueryably<T>को कास्ट करते हैं तो IEnumerable<T>यह एक वर्ग गणना जारी नहीं करेगा। जब मैंने यह लिखा था, लिन्क टू सकेल नया था; मुझे लगता है कि मैं केवल उपयोग करने के लिए जोर दे रहा था Any()क्योंकि enumerables, संग्रह और sql के लिए यह बहुत अधिक कुशल और पठनीय (सामान्य रूप से) था। उत्तर में सुधार के लिए धन्यवाद।
मेरे एक मित्र के पास ब्लॉग पोस्टों की एक श्रृंखला है जो इस बात का दृष्टांत प्रदान करती है कि आप ऐसा क्यों नहीं कर सकते। वह फ़ंक्शन बनाता है जो एक IEnumerable लौटाता है जहां प्रत्येक पुनरावृत्ति अगले अभाज्य संख्या, सभी तरह से देता है ulong.MaxValue, और अगले आइटम की गणना तब तक नहीं की जाती है जब तक आप इसके लिए नहीं पूछते हैं। त्वरित, पॉप प्रश्न: कितने आइटम वापस किए जाते हैं?
यहाँ पोस्ट हैं, लेकिन वे लंबे समय की तरह हैं:
EnumerableFeaturesवस्तु है) के लिए कुछ भी करने के लिए प्रगणकों की आवश्यकता नहीं होगी, लेकिन इस तरह के प्रश्न (जैसे कुछ अन्य लोगों के साथ पूछ सकते हैं) में सक्षम हो सकते हैं? हमेशा आइटम का एक ही क्रम वापस करें "," क्या आप सुरक्षित रूप से कोड के संपर्क में आ सकते हैं जो आपके अंतर्निहित संग्रह को नहीं बदलना चाहिए ", आदि) बहुत उपयोगी होगा।
set yield optionsइसका समर्थन करने के लिए एक बयान या कुछ समान मिलेगा । अगर ठीक से डिज़ाइन किया गया है, IEnhancedEnumeratorतो बहुत सारे "रक्षात्मक" ToArrayया ToListकॉल को खत्म करके LINQ जैसी चीजों को अधिक उपयोग करने योग्य बना सकता है , विशेष रूप से ...
Enumerable.Concatबड़े संग्रह को संयोजित करने के लिए चीजों का उपयोग किया जाता है, जो एक छोटे से अपने बारे में बहुत कुछ जानता है जो ऐसा नहीं करता है।
IEnumerable पुनरावृत्ति के बिना गिनती नहीं कर सकते।
"सामान्य" परिस्थितियों में, IEnumerable या IEnumerable <T> को लागू करने वाली कक्षाओं के लिए संभव होगा, जैसे कि सूची <T>, सूची <T>। संपत्ति वापस करके गणना पद्धति को लागू करने के लिए। हालाँकि, गणना विधि वास्तव में IEnumerable <T> या IEnumerable इंटरफ़ेस पर परिभाषित विधि नहीं है। (केवल वही है, जो वास्तव में, GetEnumerator है।) और इसका मतलब है कि इसके लिए एक वर्ग-विशिष्ट कार्यान्वयन प्रदान नहीं किया जा सकता है।
इसके बजाय, गणना करें कि यह एक विस्तार विधि है, जिसे स्थिर वर्ग पर परिभाषित किया गया है। इसका मतलब यह है कि इसे किसी भी वर्ग के कार्यान्वयन की परवाह किए बिना IEnumerable <T> व्युत्पन्न वर्ग के किसी भी उदाहरण पर बुलाया जा सकता है। लेकिन इसका मतलब यह भी है कि यह एक ही स्थान पर लागू किया जाता है, उन वर्गों में से किसी के लिए बाहरी। निश्चित रूप से इसका मतलब यह है कि इसे इस तरह से लागू किया जाना चाहिए, जो इन वर्ग के इनरल्स से पूरी तरह से स्वतंत्र हो। मतगणना करने का एकमात्र तरीका पुनरावृत्ति है।
वैकल्पिक रूप से आप निम्न कार्य कर सकते हैं:
Tables.ToList<string>().Count;नहीं, सामान्य तौर पर नहीं। गणना करने वालों का उपयोग करने में एक बिंदु यह है कि गणना में वस्तुओं का वास्तविक सेट ज्ञात नहीं है (अग्रिम में, या बिल्कुल भी)।
आप System.Linq का उपयोग कर सकते हैं।
using System;
using System.Collections.Generic;
using System.Linq;
public class Test
{
private IEnumerable<string> Tables
{
get {
yield return "Foo";
yield return "Bar";
}
}
static void Main()
{
var x = new Test();
Console.WriteLine(x.Tables.Count());
}
}आपको परिणाम '2' मिलेगा।
अपने तात्कालिक प्रश्न से परे जाकर (जो कि नकारात्मक रूप से पूरी तरह से उत्तर दिया गया है), यदि आप प्रगति की सूचना देते हुए प्रगति की रिपोर्ट करना चाहते हैं, तो आप मेरे ब्लॉग पोस्ट रिपोर्टिंग प्रोग्रेस इन लीनिक क्वेरीज़ के दौरान देखना चाह सकते हैं ।
यह आपको ऐसा करने देता है:
BackgroundWorker worker = new BackgroundWorker();
worker.WorkerReportsProgress = true;
worker.DoWork += (sender, e) =>
{
// pretend we have a collection of
// items to process
var items = 1.To(1000);
items
.WithProgressReporting(progress => worker.ReportProgress(progress))
.ForEach(item => Thread.Sleep(10)); // simulate some real work
};मैंने IEnumberableसामग्री में उत्तीर्ण की जाँच करने के लिए एक विधि के अंदर इस तरह का उपयोग किया
if( iEnum.Cast<Object>().Count() > 0)
{
}इस तरह एक विधि के अंदर:
GetDataTable(IEnumberable iEnum)
{
if (iEnum != null && iEnum.Cast<Object>().Count() > 0) //--- proceed further
}bool hasContents = false; if (iEnum != null) foreach (object ob in iEnum) { hasContents = true; ... your code per ob ... }।
यह .Net के संस्करण पर निर्भर करता है और आपके IEnumerable ऑब्जेक्ट का कार्यान्वयन करता है। Microsoft ने कार्यान्वयन के लिए जाँच करने के लिए IEnumerable.Count विधि निर्धारित की है, और ICollection.Count या ICollection <TSource> का उपयोग करता है। विवरण देखें, यहाँ देखें https://connect.microsoft.com/VisualStudio/feedback/details/454130
और नीचे System.Core के लिए Ildasm से MSIL है, जिसमें System.Linq रहता है।
.method public hidebysig static int32 Count<TSource>(class
[mscorlib]System.Collections.Generic.IEnumerable`1<!!TSource> source) cil managed
{
.custom instance void System.Runtime.CompilerServices.ExtensionAttribute::.ctor() = ( 01 00 00 00 )
// Code size 85 (0x55)
.maxstack 2
.locals init (class [mscorlib]System.Collections.Generic.ICollection`1<!!TSource> V_0,
class [mscorlib]System.Collections.ICollection V_1,
int32 V_2,
class [mscorlib]System.Collections.Generic.IEnumerator`1<!!TSource> V_3)
IL_0000: ldarg.0
IL_0001: brtrue.s IL_000e
IL_0003: ldstr "source"
IL_0008: call class [mscorlib]System.Exception System.Linq.Error::ArgumentNull(string)
IL_000d: throw
IL_000e: ldarg.0
IL_000f: isinst class [mscorlib]System.Collections.Generic.ICollection`1<!!TSource>
IL_0014: stloc.0
IL_0015: ldloc.0
IL_0016: brfalse.s IL_001f
IL_0018: ldloc.0
IL_0019: callvirt instance int32 class [mscorlib]System.Collections.Generic.ICollection`1<!!TSource>::get_Count()
IL_001e: ret
IL_001f: ldarg.0
IL_0020: isinst [mscorlib]System.Collections.ICollection
IL_0025: stloc.1
IL_0026: ldloc.1
IL_0027: brfalse.s IL_0030
IL_0029: ldloc.1
IL_002a: callvirt instance int32 [mscorlib]System.Collections.ICollection::get_Count()
IL_002f: ret
IL_0030: ldc.i4.0
IL_0031: stloc.2
IL_0032: ldarg.0
IL_0033: callvirt instance class [mscorlib]System.Collections.Generic.IEnumerator`1<!0> class [mscorlib]System.Collections.Generic.IEnumerable`1<!!TSource>::GetEnumerator()
IL_0038: stloc.3
.try
{
IL_0039: br.s IL_003f
IL_003b: ldloc.2
IL_003c: ldc.i4.1
IL_003d: add.ovf
IL_003e: stloc.2
IL_003f: ldloc.3
IL_0040: callvirt instance bool [mscorlib]System.Collections.IEnumerator::MoveNext()
IL_0045: brtrue.s IL_003b
IL_0047: leave.s IL_0053
} // end .try
finally
{
IL_0049: ldloc.3
IL_004a: brfalse.s IL_0052
IL_004c: ldloc.3
IL_004d: callvirt instance void [mscorlib]System.IDisposable::Dispose()
IL_0052: endfinally
} // end handler
IL_0053: ldloc.2
IL_0054: ret
} // end of method Enumerable::Countयहाँ आलसी मूल्यांकन और आस्थगित निष्पादन के बारे में एक महान चर्चा है । मूल रूप से आपको उस मूल्य को प्राप्त करने के लिए सूची को भौतिक बनाना होगा।
IEnumerable.Count () फ़ंक्शन का परिणाम गलत हो सकता है। यह परीक्षण करने के लिए एक बहुत ही सरल नमूना है:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Collections;
namespace Test
{
class Program
{
static void Main(string[] args)
{
var test = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17 };
var result = test.Split(7);
int cnt = 0;
foreach (IEnumerable<int> chunk in result)
{
cnt = chunk.Count();
Console.WriteLine(cnt);
}
cnt = result.Count();
Console.WriteLine(cnt);
Console.ReadLine();
}
}
static class LinqExt
{
public static IEnumerable<IEnumerable<T>> Split<T>(this IEnumerable<T> source, int chunkLength)
{
if (chunkLength <= 0)
throw new ArgumentOutOfRangeException("chunkLength", "chunkLength must be greater than 0");
IEnumerable<T> result = null;
using (IEnumerator<T> enumerator = source.GetEnumerator())
{
while (enumerator.MoveNext())
{
result = GetChunk(enumerator, chunkLength);
yield return result;
}
}
}
static IEnumerable<T> GetChunk<T>(IEnumerator<T> source, int chunkLength)
{
int x = chunkLength;
do
yield return source.Current;
while (--x > 0 && source.MoveNext());
}
}
}परिणाम (7,7,3,3) होना चाहिए, लेकिन वास्तविक परिणाम (7,7,3,17)
मैं सुझाव दूंगा कि ToList को बुलाओ। हां, आप एन्यूमरेशन जल्दी कर रहे हैं, लेकिन आपके पास अभी भी आइटम की अपनी सूची है।
यह सबसे अच्छा प्रदर्शन नहीं दे सकता है, लेकिन आप IEQ में एक तत्वों को गिनने के लिए LINQ का उपयोग कर सकते हैं:
public int GetEnumerableCount(IEnumerable Enumerable)
{
return (from object Item in Enumerable
select Item).Count();
}मुझे लगता है कि ऐसा करने का सबसे आसान तरीका है
Enumerable.Count<TSource>(IEnumerable<TSource> source)संदर्भ: system.linq.enumerable
मैं उपयोग IEnum<string>.ToArray<string>().Lengthकरता हूं और यह ठीक काम करता है।
IEnum<string>.Count();?
मैं ऐसे कोड का उपयोग करता हूं, अगर मेरे पास स्ट्रिंग्स की सूची है:
((IList<string>)Table).Count