C # โอเคกับการเปรียบเทียบประเภทค่าเป็นโมฆะ

ฉันพบสิ่งนี้ในวันนี้และไม่รู้ว่าทำไมคอมไพเลอร์ 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?");
        }
    }
}

สิ่งนี้ถูกกฎหมายเนื่องจากความละเอียดเกินพิกัดของตัวดำเนินการมีตัวดำเนินการที่ดีที่สุดให้เลือก มีโอเปอเรเตอร์ == ที่รับสอง int ที่เป็นโมฆะ int local สามารถแปลงเป็น int ว่างได้ ลิเทอรัลว่างสามารถแปลงเป็น int ที่เป็นโมฆะได้ ดังนั้นนี่คือการใช้ตัวดำเนินการ == อย่างถูกกฎหมายและจะส่งผลให้เป็นเท็จเสมอ

ในทำนองเดียวกันเรายังอนุญาตให้คุณพูดว่า "if (x == 12.6)" ซึ่งจะเป็นเท็จเสมอ int local สามารถแปลงเป็นสองเท่าลิเทอรัลสามารถแปลงเป็นสองเท่าได้และเห็นได้ชัดว่าพวกมันจะไม่เท่ากัน

ไม่ใช่ข้อผิดพลาดเนื่องจากมีการint?แปลง( ) มันสร้างคำเตือนในตัวอย่างที่กำหนด:

ผลลัพธ์ของนิพจน์จะเป็น 'เท็จ' เสมอเนื่องจากค่าของประเภท 'int' จะไม่เท่ากับ 'null' ของประเภท 'int?'

หากคุณตรวจสอบ 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
    }
}

ด้วย IL (สำหรับ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);
}

การที่การเปรียบเทียบไม่สามารถเป็นจริงได้ไม่ได้หมายความว่ามันผิดกฎหมาย อย่างไรก็ตามไม่มีประเภทค่าสามารถเป็นnullได้

ไม่มีจะไม่เคยเป็น Int32 xnull

หากคุณกำลังเปรียบเทียบ int กับ null ตัวดำเนินการเปรียบเทียบที่ใช้สอง int? s จะใช้ได้

"เหตุใดการเปรียบเทียบประเภทค่ากับ null จึงเป็นคำเตือน" บทความจะช่วยคุณ

ประเภทค่าไม่สามารถเป็นได้nullแม้ว่าจะเท่ากับnull(พิจารณาNullable<>) ในกรณีของคุณintตัวแปรและnullถูกโยนโดยปริยายNullable<Int32>และเปรียบเทียบ

ฉันสงสัยว่าการทดสอบเฉพาะของคุณเพิ่งได้รับการปรับให้เหมาะสมโดยคอมไพเลอร์เมื่อสร้าง IL เนื่องจากการทดสอบจะไม่เป็นเท็จ

หมายเหตุด้านข้าง: เป็นไปได้ที่จะมี Int32 ที่เป็นโมฆะใช้ Int32? x แทน

ฉันเดาว่านี่เป็นเพราะ "==" เป็นไวยากรณ์น้ำตาลซึ่งแสดงถึงSystem.Object.Equalsวิธีการเรียกใช้ที่ยอมรับSystem.Objectพารามิเตอร์ Null by ECMA specification เป็นชนิดพิเศษซึ่งแน่นอนมาจากSystem.Objectเป็นชนิดพิเศษซึ่งเป็นหลักสูตรที่ได้มาจาก

นั่นเป็นเหตุผลว่าทำไมจึงมีเพียงคำเตือน

[แก้ไข: ทำให้คำเตือนเป็นข้อผิดพลาดและทำให้ตัวดำเนินการมีความชัดเจนเกี่ยวกับ nullable แทนที่จะเป็นสตริงแฮ็ค]

ตามข้อเสนอแนะที่ชาญฉลาดของ @ supercat ในความคิดเห็นด้านบนตัวดำเนินการต่อไปนี้โอเวอร์โหลดช่วยให้คุณสร้างข้อผิดพลาดเกี่ยวกับการเปรียบเทียบประเภทค่าที่กำหนดเองของคุณเป็นค่าว่าง

ด้วยการใช้ตัวดำเนินการที่เปรียบเทียบกับเวอร์ชันที่เป็นโมฆะของประเภทของคุณการใช้ null ในการเปรียบเทียบจะตรงกับตัวดำเนินการเวอร์ชันที่เป็นโมฆะซึ่งช่วยให้คุณสร้างข้อผิดพลาดผ่านทางแอตทริบิวต์ล้าสมัย

จนกว่า 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;
    }
}

ฉันคิดว่าคำตอบที่ดีที่สุดว่าทำไมคอมไพเลอร์ยอมรับสิ่งนี้สำหรับคลาสทั่วไป พิจารณาชั้นเรียนต่อไปนี้ ...

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

หากคอมไพลเลอร์ไม่ยอมรับการเปรียบเทียบกับnullชนิดของค่ามันจะทำลายคลาสนี้โดยมีข้อ จำกัด โดยนัยที่แนบมากับพารามิเตอร์ type (กล่าวคือจะใช้ได้เฉพาะกับชนิดที่ไม่อิงตามค่า)

คอมไพเลอร์จะช่วยให้คุณสามารถเปรียบเทียบโครงสร้างใด ๆ ที่ใช้ ==กับ null มันยังช่วยให้คุณสามารถเปรียบเทียบ int กับ null ได้ (คุณจะได้รับคำเตือน)

แต่ถ้าคุณแยกชิ้นส่วนโค้ดออกคุณจะเห็นว่าการเปรียบเทียบกำลังได้รับการแก้ไขเมื่อคอมไพล์โค้ด ตัวอย่างเช่นรหัสนี้ ( 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