सी # - वैल्यू टाइप बराबर विधि - संकलक प्रतिबिंब का उपयोग क्यों करता है?

Question

मैं बस मेरे लिए कुछ अजीब कुछ आया: जब आप एक मान प्रकार पर समान() विधि का उपयोग करते हैं (और यदि यह विधि निश्चित रूप से अतिरंजित नहीं हुई है) तो आपको कुछ बहुत मिलता है धीमी - फ़ील्ड की तुलना की जाती है प्रतिबिंब का उपयोग कर एक से एक! जैसा कि:

public struct MyStruct{ 
    int i; 
} 

    (...) 

    MyStruct s, t; 
    s.i = 0; 
    t.i = 1; 
    if (s.Equals(t)) /* s.i will be compared to t.i via reflection here. */ 
     (...) 

मेरा प्रश्न: सी # कंपाइलर मूल्य प्रकारों की तुलना करने के लिए एक सरल विधि क्यों नहीं उत्पन्न करता है? की तरह कुछ (MyStruct की परिभाषा में):

public override bool Equals(Object o){ 
     if (this.i == o.i) 
     return true; 
     else 
     return false; 
    } 

संकलक जानता संकलन समय पर MyStruct के क्षेत्र क्या कर रहे हैं, कारण है कि यह क्रम तक इंतजार करता MyStruct क्षेत्रों की गणना करने में?

मेरे लिए बहुत अजीब।

धन्यवाद :)

जोड़ा: क्षमा करें, मैं बस एहसास है कि, ज़ाहिर है, Equals एक भाषा कीवर्ड लेकिन एक क्रम तरीका नहीं है ... संकलक इस विधि से पूरी तरह अनजान है। तो यह प्रतिबिंब का उपयोग करने के लिए यहाँ संवेदना बनाते हैं।

Answer 1

निम्नलिखित mscorlib से decompiled ValueType.Equals विधि है:

public override bool Equals(object obj) 
{ 
    if (obj == null) 
    { 
     return false; 
    } 
    RuntimeType type = (RuntimeType) base.GetType(); 
    RuntimeType type2 = (RuntimeType) obj.GetType(); 
    if (type2 != type) 
    { 
     return false; 
    } 
    object a = this; 
    if (CanCompareBits(this)) 
    { 
     return FastEqualsCheck(a, obj); 
    } 
    FieldInfo[] fields = type.GetFields(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance); 
    for (int i = 0; i < fields.Length; i++) 
    { 
     object obj3 = ((RtFieldInfo) fields[i]).InternalGetValue(a, false); 
     object obj4 = ((RtFieldInfo) fields[i]).InternalGetValue(obj, false); 
     if (obj3 == null) 
     { 
      if (obj4 != null) 
      { 
       return false; 
      } 
     } 
     else if (!obj3.Equals(obj4)) 
     { 
      return false; 
     } 
    } 
    return true; 
} 

जब संभव हो, एक बिट-वार तुलना की जाएगी (CanCompareBits और FastEqualsCheck को नोट करें, जिनमें से दोनों को InternalCall के रूप में परिभाषित किया गया है। जेआईटी संभावित रूप से उपयुक्त कोड इंजेक्ट करेगा। डब्ल्यू के रूप में हाय यह बहुत धीमी है, मैं आपको नहीं बता सका।

Answer 2

यह प्रतिबिंब का उपयोग नहीं करता है जब इसे की आवश्यकता नहीं होती है। यह struct के मामले में बस थोड़ा सा मूल्यों की तुलना करें यदि ऐसा हो सकता है। हालांकि, अगर struct सदस्यों में से कोई भी सदस्य (या सदस्यों के सदस्य, किसी भी वंशज) object.Equals ओवरराइड करते हैं और अपना स्वयं का कार्यान्वयन प्रदान करते हैं, जाहिर है, यह वापसी मूल्य की गणना करने के लिए बिट-बाय-बिट तुलना पर भरोसा नहीं कर सकता है।

कारण यह धीमा है कि Equals का पैरामीटर object प्रकार है और मूल्य प्रकारों को object के रूप में माना जाना चाहिए। बॉक्सिंग में ढेर पर स्मृति आवंटित करना और उस स्थान पर मूल्य प्रकार की प्रतिलिपि बनाना शामिल है।

आप मैन्युअल Equals विधि है कि लेता है के लिए एक अधिभार प्रदान कर सकता है अपनी खुद की struct को रोकने के लिए पैरामीटर के रूप में मुक्केबाजी:

public bool Equals(MyStruct obj) { 
    return obj.i == i; 
} 

Answer 3

एक कंपाइलर जेनरेट फ़ंक्शन का विचार उचित है।

प्रभावों के बारे में सोचते हुए मुझे लगता है कि भाषा डिजाइन टीम ने यह सही किया है। सी ++ से ज्ञात संकलित तरीकों को शुरुआती लोगों के लिए समझना मुश्किल है। देखते हैं क्या स्वत: जनरेट की struct.Equals साथ सी # में क्या होगा:

यह अब के रूप में, .Equals की अवधारणा() सरल है:

• हर struct inherits ValueType से बराबर होती है।
• अगर ओवर्रिडन, कस्टम बराबर विधि लागू होती है।

संकलक हमेशा बराबर विधि बनाने हैं, तो हम हो सकता है:

• हर struct inherits वस्तु से बराबर होती है। (ValueType अब अपना संस्करण लागू करेगा)
• Object.Equals अब हमेशा होता है (!) ओवरराइड, या तो उत्पन्न संकलक द्वारा विधि के बराबर है या उन कार्यान्वयन द्वारा

अब हमारे struct एक स्वत: जनरेट की ओवरराइड विधि है कि कोड रीडर नहीं देखता है! तो आप कैसे जानते हैं कि बेस विधि ऑब्जेक्ट। एक्वाल्स आपकी संरचना पर लागू नहीं होता है? स्वचालित रूप से संकलक उत्पन्न विधियों के सभी मामलों को सीखकर। और यह सी ++ सीखने वाले बोझों में से एक है।

उपयोगकर्ता को समान रूप से कुशल संरचना छोड़ने और अवधारणाओं को सरल रखने के लिए अच्छा निर्णय मानेंगे, मानक मानक बराबर विधि की आवश्यकता होती है।

उस ने कहा, प्रदर्शन महत्वपूर्ण structs बराबर ओवरराइड करना चाहिए। नीचे दिए गए कोड,

बनाम 53 मिलीसेकंड कारण आभासी बराबर से परहेज है, लेकिन वैसे भी करने के लिए नेट 4.5.1

इस प्रदर्शन लाभ निश्चित रूप से है पर मापा से पता चलता है, इसलिए यदि आभासी Object.Equals होगा कहा जाता है कि लाभ बहुत कम होगा। निष्पादन महत्वपूर्ण मामलों ऑब्जेक्ट को कॉल नहीं करेंगे। हालांकि, इसलिए यहां लाभ लागू होगा।

using System; 
using System.Diagnostics; 

struct A 
{ 
    public int X; 
    public int Y; 
} 

struct B : IEquatable<B> 
{ 
    public bool Equals(B other) 
    { 
     return this.X == other.X && this.Y == other.Y; 
    } 

    public override bool Equals(object obj) 
    { 
     return obj is B && Equals((B)obj); 
    } 

    public int X; 
    public int Y; 
} 


class Program 
{ 
    static void Main(string[] args) 
    { 
     var N = 100000000; 

     A a = new A(); 
     a.X = 73; 
     a.Y = 42; 
     A aa = new A(); 
     a.X = 173; 
     a.Y = 142; 

     var sw = Stopwatch.StartNew(); 
     for (int i = 0; i < N; i++) 
     { 
      if (a.Equals(aa)) 
      { 
       Console.WriteLine("never ever"); 
      } 
     } 
     sw.Stop(); 
     Console.WriteLine(sw.ElapsedMilliseconds); 

     B b = new B(); 
     b.X = 73; 
     b.Y = 42; 
     B bb = new B(); 
     b.X = 173; 
     b.Y = 142; 

     sw = Stopwatch.StartNew(); 
     for (int i = 0; i < N; i++) 
     { 
      if (b.Equals(bb)) 
      { 
       Console.WriteLine("never ever"); 
      } 
     } 
     sw.Stop(); 
     Console.WriteLine(sw.ElapsedMilliseconds); 
    } 
} 

भी http://blog.martindoms.com/2011/01/03/c-tip-override-equals-on-value-types-for-better-performance/