[c#] Linq। कोई वीएस .xists - क्या अंतर है?



2 Answers

अंतर यह है कि कोई भी System.Linq.Enumerable पर परिभाषित किसी भी IEnumerable<T> लिए एक एक्सटेंशन विधि है। इसका उपयोग किसी भी IEnumerable<T> इंस्टेंस पर किया जा सकता है।

मौजूदियां एक विस्तार विधि प्रतीत नहीं होती हैं। मेरा अनुमान है कि कॉल प्रकार की List<T> । यदि ऐसा है तो एक उदाहरण विधि है जो किसी के समान काम करती है।

संक्षेप में , विधियां अनिवार्य रूप से वही हैं। एक दूसरे की तुलना में अधिक सामान्य है।

  • किसी के पास एक ओवरलोड भी होता है जो कोई पैरामीटर नहीं लेता है और केवल गणना में किसी भी आइटम की तलाश करता है।
  • मौजूदियों में ऐसा कोई अधिभार नहीं है।
Question

संग्रह पर लिंक का उपयोग, कोड की निम्नलिखित पंक्तियों के बीच क्या अंतर है?

if(!coll.Any(i => i.Value))

तथा

if(!coll.Exists(i => i.Value))

अद्यतन 1

जब मैं अलग करता .Exists ऐसा लगता है कि कोई कोड नहीं है।

अद्यतन 2

किसी को पता है कि इस के लिए कोड क्यों नहीं है?




इसके अतिरिक्त, यह केवल तभी काम करेगा जब मूल्य प्रकार के बूल है। आम तौर पर यह भविष्यवाणी के साथ प्रयोग किया जाता है। किसी भी भविष्यवाणी का प्रयोग आम तौर पर किया जाता है कि क्या कोई तत्व किसी दिए गए शर्त को संतुष्ट करता है या नहीं। यहां आप बस अपने तत्व से एक बूल संपत्ति के लिए एक नक्शा कर रहे हैं। यह एक "i" की खोज करेगा जिसका मूल्य संपत्ति सत्य है। एक बार पूरा हो जाने पर, विधि सही हो जाएगी।




बेंचमार्किंग पर मटास के उत्तर पर निरंतरता के रूप में।

टीएल / डीआर : मौजूद () और कोई भी () समान रूप से तेज़ हैं।

सबसे पहले: स्टॉपवॉच का उपयोग करके बेंचमार्किंग सटीक नहीं है ( श्रृंखला 0 के उत्तर को एक अलग, लेकिन समान, विषय पर देखें ), लेकिन यह डेटटाइम से कहीं अधिक सटीक है।

वास्तव में सटीक रीडिंग प्राप्त करने का तरीका प्रदर्शन प्रोफाइलिंग का उपयोग करना है। लेकिन एक तरीका यह समझने का एक तरीका है कि कैसे दो तरीकों का प्रदर्शन एक-दूसरे के लिए मापता है, दोनों तरीकों को लोड करने और फिर प्रत्येक के सबसे तेज़ निष्पादन समय की तुलना करके। इस तरह, यह वास्तव में कोई फर्क नहीं पड़ता कि जेआईटीआईंग और अन्य शोर हमें बुरी रीडिंग देता है (और यह करता है ), क्योंकि दोनों निष्पादन एक अर्थ में " समान रूप से गुमराह " होते हैं।

static void Main(string[] args)
    {
        Console.WriteLine("Generating list...");
        List<string> list = GenerateTestList(1000000);
        var s = string.Empty;

        Stopwatch sw;
        Stopwatch sw2;
        List<long> existsTimes = new List<long>();
        List<long> anyTimes = new List<long>();

        Console.WriteLine("Executing...");
        for (int j = 0; j < 1000; j++)
        {
            sw = Stopwatch.StartNew();
            if (!list.Exists(o => o == "0123456789012"))
            {
                sw.Stop();
                existsTimes.Add(sw.ElapsedTicks);
            }
        }

        for (int j = 0; j < 1000; j++)
        {
            sw2 = Stopwatch.StartNew();
            if (!list.Exists(o => o == "0123456789012"))
            {
                sw2.Stop();
                anyTimes.Add(sw2.ElapsedTicks);
            }
        }

        long existsFastest = existsTimes.Min();
        long anyFastest = anyTimes.Min();

        Console.WriteLine(string.Format("Fastest Exists() execution: {0} ticks\nFastest Any() execution: {1} ticks", existsFastest.ToString(), anyFastest.ToString()));
        Console.WriteLine("Benchmark finished. Press any key.");
        Console.ReadKey();
    }

    public static List<string> GenerateTestList(int count)
    {
        var list = new List<string>();
        for (int i = 0; i < count; i++)
        {
            Random r = new Random();
            int it = r.Next(0, 100);
            list.Add(new string('s', it));
        }
        return list;
    }

उपरोक्त कोड को 4 बार निष्पादित करने के बाद (जो बदले में 1 000 000 तत्वों Exists() 1 Exists() और Any() को 1 000 000 तत्वों के साथ सूची में), यह देखना मुश्किल नहीं है कि विधियां काफी समान हैं।

Fastest Exists() execution: 57881 ticks
Fastest Any() execution: 58272 ticks

Fastest Exists() execution: 58133 ticks
Fastest Any() execution: 58063 ticks

Fastest Exists() execution: 58482 ticks
Fastest Any() execution: 58982 ticks

Fastest Exists() execution: 57121 ticks
Fastest Any() execution: 57317 ticks

थोड़ा सा अंतर है, लेकिन यह पृष्ठभूमि शोर द्वारा समझाया जाने वाला अंतर नहीं है। मेरा अनुमान यह होगा कि अगर कोई 10 000 या 100 000 Exists() और Any() इसके बजाय, थोड़ा सा अंतर कम या कम गायब हो जाएगा।






Related