मूल्य प्रकारों को शून्य करने के लिए C # ठीक है

Question 1

मैं आज इस में भाग गया और पता नहीं क्यों C # संकलक एक त्रुटि नहीं फेंक रहा है।

Int32 x = 1;
if (x == null)
{
    Console.WriteLine("What the?");
}

मैं उलझन में हूँ कि कैसे x कभी संभवत: अशक्त हो सकता है। खासकर जब से यह काम निश्चित रूप से एक संकलक त्रुटि फेंकता है:

Int32 x = null;

क्या यह संभव है कि x शून्य हो सकता है, क्या Microsoft ने इस चेक को कंपाइलर में नहीं डालने का निर्णय लिया था, या यह पूरी तरह से याद नहीं था?

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

public class Test
{
    public DateTime ADate = DateTime.Now;

    public Test ()
    {
        Test test = new Test();
        if (test.ADate == null)
        {
            Console.WriteLine("What the?");
        }
    }
}

Question 2

यह कानूनी है क्योंकि ऑपरेटर ओवरलोड रिज़ॉल्यूशन को चुनने के लिए एक अद्वितीय सर्वश्रेष्ठ ऑपरेटर है। एक == ऑपरेटर है जो दो अशक्त ints लेता है। इंट स्थानीय एक अशक्त इंट के लिए परिवर्तनीय है। अशक्त शाब्दिक एक अशक्त इंट के लिए परिवर्तनीय है। इसलिए यह == ऑपरेटर का कानूनी उपयोग है, और हमेशा गलत परिणाम देगा।

इसी तरह, हम आपको "अगर (x == 12.6)" भी कहने की अनुमति देते हैं, जो हमेशा झूठ होगा। अंतर स्थानीय एक डबल में परिवर्तनीय है, शाब्दिक एक डबल में परिवर्तनीय है, और जाहिर है कि वे कभी भी समान नहीं होंगे।

Question 3

यह एक त्रुटि नहीं है, क्योंकि एक ( int?) रूपांतरण है; यह दिए गए उदाहरण में एक चेतावनी उत्पन्न करता है:

अभिव्यक्ति का परिणाम हमेशा 'गलत' होता है क्योंकि 'int' का मान कभी भी 'int' के 'null' के बराबर नहीं होता है?

यदि आप IL की जाँच करते हैं, तो आप देखेंगे कि यह पूरी तरह से पहुंच योग्य शाखा को हटा देता है - यह रिलीज़ बिल्ड में मौजूद नहीं है।

ध्यान दें कि यह समानता ऑपरेटरों के साथ कस्टम संरचनाओं के लिए यह चेतावनी उत्पन्न नहीं करता है। यह 2.0 में इस्तेमाल हुआ, लेकिन 3.0 संकलक में नहीं। कोड अभी भी हटा दिया गया है (इसलिए यह जानता है कि कोड उपलब्ध नहीं है), लेकिन कोई चेतावनी उत्पन्न नहीं होती है:

using System;

struct MyValue
{
    private readonly int value;
    public MyValue(int value) { this.value = value; }
    public static bool operator ==(MyValue x, MyValue y) {
        return x.value == y.value;
    }
    public static bool operator !=(MyValue x, MyValue y) {
        return x.value != y.value;
    }
}
class Program
{
    static void Main()
    {
        int i = 1;
        MyValue v = new MyValue(1);
        if (i == null) { Console.WriteLine("a"); } // warning
        if (v == null) { Console.WriteLine("a"); } // no warning
    }
}

आईएल के साथ (के लिए Main) - (जो दुष्प्रभाव हो सकता है) को छोड़कर सब कुछ नोट करें MyValue(1):

.method private hidebysig static void Main() cil managed
{
    .entrypoint
    .maxstack 2
    .locals init (
        [0] int32 i,
        [1] valuetype MyValue v)
    L_0000: ldc.i4.1 
    L_0001: stloc.0 
    L_0002: ldloca.s v
    L_0004: ldc.i4.1 
    L_0005: call instance void MyValue::.ctor(int32)
    L_000a: ret 
}

यह मूल रूप से है:

private static void Main()
{
    MyValue v = new MyValue(1);
}

Question 4

तथ्य यह है कि एक तुलना कभी सच नहीं हो सकती इसका मतलब यह नहीं है कि यह अवैध है। फिर भी, नहीं, मूल्य प्रकार कभी भी हो सकता है null।

Question 5

नहीं, Int32 xकभी नहीं बनेगा null।

यदि आप किसी इंट की तुलना नल से कर रहे हैं तो तुलना करने वाला ऑपरेटर दो इंट ले लेता है।

"नल के साथ एक मूल्य प्रकार की तुलना एक चेतावनी क्यों है?" लेख आपकी मदद करेगा।

Question 6

एक मान प्रकार नहीं हो सकता है null, हालांकि यह null(विचार Nullable<>) के बराबर हो सकता है । आपके मामले में intपरिवर्तनशील और nullअंतर्निहित रूप से Nullable<Int32>तुलना की जाती है।

Question 7

मुझे संदेह है कि आपका विशेष परीक्षण केवल कंपाइलर द्वारा अनुकूलित किया जा रहा है जब यह आईएल उत्पन्न करता है क्योंकि परीक्षण कभी भी गलत नहीं होगा।

साइड नोट: Int32 में एक अशक्त Int32 का उपयोग करना संभव है? इसके बजाय एक्स।

Question 8

मुझे लगता है कि यह है क्योंकि "==" एक वाक्यविन्यास चीनी है जो वास्तव में कॉल को System.Object.Equalsविधि का प्रतिनिधित्व करता है जो System.Objectपैरामीटर को स्वीकार करता है। ईसीएमए विनिर्देश द्वारा नल एक विशेष प्रकार है जो निश्चित रूप से प्राप्त होता है System.Object।

इसलिए केवल एक चेतावनी है।

Question 9

[संपादित करें: त्रुटियों में चेतावनी दी, और ऑपरेटरों को स्ट्रिंग हैक के बजाय अशक्त के बारे में स्पष्ट किया।]

उपरोक्त टिप्पणी में @ सुपरकैट के चतुर सुझाव के अनुसार, निम्न ऑपरेटर ओवरलोड आपको अपने कस्टम मूल्य प्रकार की तुलना शून्य करने की त्रुटि उत्पन्न करने की अनुमति देते हैं।

उन ऑपरेटरों को लागू करने से जो आपके प्रकार के अशक्त संस्करणों की तुलना करते हैं, तुलना में अशक्त का उपयोग ऑपरेटर के अशक्त संस्करण से मेल खाता है, जो आपको अप्रचलित विशेषता के माध्यम से त्रुटि उत्पन्न करने देता है।

जब तक Microsoft हमें अपना कंपाइलर चेतावनी वापस नहीं देता, तब तक मैं इस समाधान के साथ जा रहा हूँ, धन्यवाद @supercat!

public struct Foo
{
    private readonly int x;
    public Foo(int x)
    {
        this.x = x;
    }

    public override string ToString()
    {
        return string.Format("Foo {{x={0}}}", x);
    }

    public override int GetHashCode()
    {
        return x.GetHashCode();
    }

    public override bool Equals(Object obj)
    {
        return x.Equals(obj);
    }

    public static bool operator ==(Foo a, Foo b)
    {
        return a.x == b.x;
    }

    public static bool operator !=(Foo a, Foo b)
    {
        return a.x != b.x;
    }

    [Obsolete("The result of the expression is always 'false' since a value of type 'Foo' is never equal to 'null'", true)]
    public static bool operator ==(Foo a, Foo? b)
    {
        return false;
    }
    [Obsolete("The result of the expression is always 'true' since a value of type 'Foo' is never equal to 'null'", true)]
    public static bool operator !=(Foo a, Foo? b)
    {
        return true;
    }
    [Obsolete("The result of the expression is always 'false' since a value of type 'Foo' is never equal to 'null'", true)]
    public static bool operator ==(Foo? a, Foo b)
    {
        return false;
    }
    [Obsolete("The result of the expression is always 'true' since a value of type 'Foo' is never equal to 'null'", true)]
    public static bool operator !=(Foo? a, Foo b)
    {
        return true;
    }
}

Question 10

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

public class NullTester<T>
{
    public bool IsNull(T value)
    {
        return (value == null);
    }
}

यदि कंपाइलर nullमान प्रकारों के खिलाफ तुलनाओं को स्वीकार नहीं करता है , तो यह अनिवार्य रूप से इस वर्ग को तोड़ देगा, इसके प्रकार पैरामीटर से जुड़ा एक अंतर्निहित बाधा (यानी यह केवल गैर-मूल्य-आधारित प्रकारों के साथ काम करेगा)।

Question 11

संकलक आपको ==अशक्त को लागू करने वाले किसी भी संरचना की तुलना करने की अनुमति देगा । यहां तक कि यह आपको एक नल की तुलना करने की अनुमति देता है (आपको हालांकि एक चेतावनी मिलेगी)।

लेकिन यदि आप कोड को अलग करते हैं तो आप देखेंगे कि कोड संकलित होने पर तुलना हल हो रही है। इसलिए, उदाहरण के लिए, यह कोड (जहां Fooएक संरचना कार्यान्वयन है ==):

public static void Main()
{
    Console.WriteLine(new Foo() == new Foo());
    Console.WriteLine(new Foo() == null);
    Console.WriteLine(5 == null);
    Console.WriteLine(new Foo() != null);
}

यह IL उत्पन्न करता है:

.method public hidebysig static void  Main() cil managed
{
  .entrypoint
  // Code size       45 (0x2d)
  .maxstack  2
  .locals init ([0] valuetype test3.Program/Foo V_0)
  IL_0000:  nop
  IL_0001:  ldloca.s   V_0
  IL_0003:  initobj    test3.Program/Foo
  IL_0009:  ldloc.0
  IL_000a:  ldloca.s   V_0
  IL_000c:  initobj    test3.Program/Foo
  IL_0012:  ldloc.0
  IL_0013:  call       bool test3.Program/Foo::op_Equality(valuetype test3.Program/Foo,
                                                           valuetype test3.Program/Foo)
  IL_0018:  call       void [mscorlib]System.Console::WriteLine(bool)
  IL_001d:  nop
  IL_001e:  ldc.i4.0
  IL_001f:  call       void [mscorlib]System.Console::WriteLine(bool)
  IL_0024:  nop
  IL_0025:  ldc.i4.1
  IL_0026:  call       void [mscorlib]System.Console::WriteLine(bool)
  IL_002b:  nop
  IL_002c:  ret
} // end of method Program::Main

जैसा कि आप देख सकते हैं:

Console.WriteLine(new Foo() == new Foo());

इसका अनुवाद है:

IL_0013:  call       bool test3.Program/Foo::op_Equality(valuetype test3.Program/Foo,
                                                               valuetype test3.Program/Foo)

जहाँ तक:

Console.WriteLine(new Foo() == null);

असत्य में अनुवादित है:

IL_001e:  ldc.i4.0