शब्दार्थ के बावजूद, प्रदर्शन एक महत्वपूर्ण विचार हो सकता है क्योंकि आप दोनों विकल्पों पर विचार करते हैं। जैसा कि पहले उल्लेख किया गया KeyValuePair
है, एक मूल्य प्रकार (संरचना) है, जबकि Tuple<>
एक संदर्भ प्रकार (वर्ग) है। इसलिए, KeyValuePair
स्टैक Tuple<>
पर आवंटित किया जाता है और ढेर पर आवंटित किया जाता है, और इष्टतम विकल्प आमतौर पर स्टैक बनाम हीप मेमोरी आवंटन के क्लासिक तर्कों द्वारा निर्धारित किया जाता है । संक्षेप में, स्टैक स्पेस सीमित है, लेकिन आम तौर पर बहुत तेज़ पहुंच है। ढेर स्मृति बहुत बड़ी है, लेकिन कुछ धीमी है।
KeyValuePair<T1, T2>
अगर दोनों कुंजी और मान प्रकार पुरातन (मूल्य प्रकार चाहते हैं बेहतर विकल्प हो सकता है int
, bool
, double
, आदि) या छोटे आकार की structs। स्टैक पर आदिम प्रकारों के साथ, आवंटन और निपटारा तेजी से बिजली कर रहा है। यह वास्तव में प्रदर्शन को प्रभावित कर सकता है, विशेष रूप से पुनरावर्ती विधि कॉल के तर्क के रूप में।
दूसरी ओर, Tuple<T1, T2>
संभावना है, तो या तो बेहतर विकल्प है T1
या T2
संदर्भ प्रकार (वर्ग) की तरह कर रहे हैं। ए KeyValuePair
में पॉइंटर्स टू रेफरेंस टाइप्स (जैसे की या वैल्यू टाइप्स) होते हैं, उद्देश्य को हरा देता है क्योंकि ऑब्जेक्ट्स को वैसे भी ढेर पर देखना होगा।
यहाँ एक बेंचमार्क है जो मुझे ऑनलाइन मिला: टपल बनाम कीवैल्यूएयर । इस बेंचमार्क के साथ एकमात्र समस्या यह है कि उन्होंने KeyValuePair<string, string>
बनाम परीक्षण किया Tuple<string, string>
, और string
प्रकार .NET में एक असामान्य और विशेष प्रकार है। यह निष्पादन के संदर्भ के आधार पर मूल्य प्रकार और / या संदर्भ प्रकार दोनों का व्यवहार कर सकता है। मेरा मानना है कि के KeyValuePair<int, int>
खिलाफ एक स्पष्ट विजेता रहा होगा Tuple<int, int>
। हालांकि, कमियों के साथ भी, परिणाम बताते हैं कि प्रदर्शन अंतर महत्वपूर्ण हो सकते हैं:
8.23 ns - आवंटन Tuple
0.32 ns - KeyValuePair आवंटित करें (25x तेज़ी से!)
1.93 ns - तर्क के रूप में टुपल पास करें
2.57 ns - तर्क के रूप में KeyValuePair पास करें
1.91 ns - रिटर्न टपल
6.09 ns - KeyValuePair रिटर्न
2.79 ns - सूची से लोड टपल को
4.18 ns - सूची से KeyValuePair लोड करें
KeyValuePair
एक कुंजी और एक मान है, एक समान मूल्योंTuple<T1,T2>
की एक जोड़ी है । आप यह भी पूछ सकते हैं: "मुझे क्यों उपयोग करना चाहिए अगर मैं उपयोग कर सकता हूं "।List<Class>
Dictionary<A,B>