स्ट्रक्चर

Question

में बराबर विधि को ओवरराइड करना मैंने structs के लिए दिशानिर्देशों को ओवरराइड करने की तलाश की है, लेकिन मुझे लगता है कि कक्षाओं के लिए मैं सब कुछ ढूंढ सकता हूं।

पहले मैंने सोचा कि मुझे यह देखने की आवश्यकता नहीं है कि पास ऑब्जेक्ट शून्य था, क्योंकि structs मूल्य प्रकार हैं और शून्य नहीं हो सकते हैं। लेकिन अब मैं इसके बारे में सोचने के लिए आते हैं, के रूप में बराबर होती हस्ताक्षर है

public bool Equals(object obj) 

ऐसा लगता है मेरी struct के उपयोगकर्ता को रोकने एक मनमाना संदर्भ प्रकार के साथ तुलना करने की कोशिश कर के लिए कुछ भी नहीं है।

मेरा दूसरा बिंदु मेरी संरचना में मेरे निजी क्षेत्रों की तुलना करने से पहले कास्टिंग I (मुझे लगता है) से संबंधित है। मैं ऑब्जेक्ट को अपने स्ट्रक्चर के प्रकार में कैसे डालना चाहता हूं? सी # as कीवर्ड केवल संदर्भ प्रकारों के लिए उपयुक्त लगता है।

public bool Equals(object obj) 
{ 
    if (obj is MyStruct) 
    { 
    var o = (MyStruct)obj; 
    ... 
    } 
} 

Answer 1

struct MyStruct 
{ 
    public override bool Equals(object obj) 
    { 
     if (!(obj is MyStruct)) 
      return false; 

     MyStruct mys = (MyStruct) obj; 
     // compare elements here 

    } 

} 

Answer 2

is ऑपरेटर का प्रयोग करें।

यदि आप संलग्न करते हैं तो आपके पास अभी भी शून्य मूल्य हो सकते हैं? के रूप में उल्लेख struct नाम के बाद (यह हर मूल्य वस्तु के लिए काम करता है)

int? 

कास्टिंग (MyStructName)variableName

Answer 3

मौजूदा उत्तर देने के लिए जोड़ा जा रहा है:

Answer 4

फोन करके भी किया जाता है मुझे लगता है, अगर एक नेट 4.5 उपयोग कर रहा है, एक डिफ़ॉल्ट कार्यान्वयन का उपयोग कर सकते documentation में:

जब आप अपना खुद का प्रकार परिभाषित करते हैं, तो उस प्रकार के आधार प्रकार के बराबर विधि द्वारा परिभाषित कार्यक्षमता प्राप्त होती है।

ValueType.Equals: मूल्य समानता; या तो प्रतिबिंब का उपयोग कर सीधे बाइट-बाय-बाइट तुलना या क्षेत्र-दर-क्षेत्र तुलना।

Answer 5

मामले में किसी को भी एक Nullable वस्तु में struct मुक्केबाजी के प्रदर्शन हिट के बारे में सोच रहा है (is से डबल प्रकार की जांच और कलाकारों से बचने के लिए), वहाँ एक गैर नगण्य भूमि के ऊपर है।

टीएल; डी: इस परिदृश्य में is & का उपयोग करें।

struct Foo : IEquatable<Foo> 
{ 
    public int a, b; 

    public Foo(int a, int b) 
    { 
     this.a = a; 
     this.b = b; 
    } 

    public override bool Equals(object obj) 
    { 
#if BOXING 
     var obj_ = obj as Foo?; 
     return obj_ != null && Equals(obj_.Value); 
#elif DOUBLECHECK 
     return obj is Foo && Equals((Foo)obj); 
#elif MAGIC 
     ? 
#endif 
    } 

    public bool Equals(Foo other) 
    { 
     return a == other.a && b == other.b; 
    } 
} 

class Program 
{ 
    static void Main(string[] args) 
    { 
     RunBenchmark(new Foo(42, 43), new Foo(42, 43)); 
     RunBenchmark(new Foo(42, 43), new Foo(43, 44)); 
    } 

    static void RunBenchmark(object x, object y) 
    { 
     var sw = Stopwatch.StartNew(); 
     for (var i = 0; i < 100000000; i++) x.Equals(y); 
     sw.Stop(); 
     Console.WriteLine(sw.ElapsedMilliseconds); 
    } 
} 

परिणाम:

BOXING 
EQ 8012 7973 7981 8000 
NEQ 7929 7715 7906 7888 

DOUBLECHECK 
EQ 3654 3650 3638 3605 
NEQ 3310 3301 3319 3297 

चेतावनी: यह परीक्षण, कई मायनों में दोषपूर्ण हो सकता है, हालांकि इस बात की पुष्टि की थी कि बेंचमार्क कोड में ही एक अजीब फैशन में अनुकूलित नहीं किया गया था।

आईएल को देखते हुए, डबल-चेक विधि थोड़ा क्लीनर संकलित करती है।

मुक्केबाजी आईएल:

.method public hidebysig virtual 
    instance bool Equals (
     object obj 
    ) cil managed 
{ 
    // Method begins at RVA 0x2060 
    // Code size 37 (0x25) 
    .maxstack 2 
    .locals init (
     [0] valuetype [mscorlib]System.Nullable`1<valuetype StructIEqualsImpl.Foo> obj_ 
    ) 

    IL_0000: ldarg.1 
    IL_0001: isinst valuetype [mscorlib]System.Nullable`1<valuetype StructIEqualsImpl.Foo> 
    IL_0006: unbox.any valuetype [mscorlib]System.Nullable`1<valuetype StructIEqualsImpl.Foo> 
    IL_000b: stloc.0 
    IL_000c: ldloca.s obj_ 
    IL_000e: call instance bool valuetype [mscorlib]System.Nullable`1<valuetype StructIEqualsImpl.Foo>::get_HasValue() 
    IL_0013: brfalse.s IL_0023 

    IL_0015: ldarg.0 
    IL_0016: ldloca.s obj_ 
    IL_0018: call instance !0 valuetype [mscorlib]System.Nullable`1<valuetype StructIEqualsImpl.Foo>::get_Value() 
    IL_001d: call instance bool StructIEqualsImpl.Foo::Equals(valuetype StructIEqualsImpl.Foo) 
    IL_0022: ret 

    IL_0023: ldc.i4.0 
    IL_0024: ret 
} // end of method Foo::Equals 

दो बार जांचें आईएल:

.method public hidebysig virtual 
    instance bool Equals (
     object obj 
    ) cil managed 
{ 
    // Method begins at RVA 0x2060 
    // Code size 23 (0x17) 
    .maxstack 8 

    IL_0000: ldarg.1 
    IL_0001: isinst StructIEqualsImpl.Foo 
    IL_0006: brfalse.s IL_0015 

    IL_0008: ldarg.0 
    IL_0009: ldarg.1 
    IL_000a: unbox.any StructIEqualsImpl.Foo 
    IL_000f: call instance bool StructIEqualsImpl.Foo::Equals(valuetype StructIEqualsImpl.Foo) 
    IL_0014: ret 

    IL_0015: ldc.i4.0 
    IL_0016: ret 
} // end of method Foo::Equals 

एक गलती है कि वास्तव में मुझे अच्छे लग रहे बनाने नहीं किया गया था खोलना के लिए रोमन रेनर को प्रॉप्स।

struct MyStruct 
{ 
    public override bool Equals(object obj) 
    { 
     if (!(obj is MyStruct mys)) // type pattern here 
      return false; 

     return this.field1 == mys.field1 && this.field2 == mys.field2 // mys is already known here without explicit casting 
    } 
} 

या मेरी पसंदीदा - अभिव्यक्ति शरीर समारोह के रूप में एक ही:

Answer 6

some news in C# 7.0 को

धन्यवाद वहाँ एक आसान तरीका एक ही स्वीकार किए जाते हैं के रूप में जवाब पूरा करने के लिए है

struct MyStruct 
{ 
    public override bool Equals(object obj) => 
     obj is MyStruct mys 
      ? true // the initial "true" doesn't affect the overall boolean operation yet allows nice line aligning below 
       && this.field1 == mys.field1 
       && this.field2 == mys.field2 
      : false; // obj is not MyStruct 
}