C # ổn với việc so sánh các loại giá trị với null

Tôi gặp phải vấn đề này ngày hôm nay và không biết tại sao trình biên dịch C # không gặp lỗi.

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

Tôi bối rối không biết làm thế nào mà x có thể là null. Đặc biệt là vì bài tập này chắc chắn gây ra lỗi trình biên dịch:

Int32 x = null;

Có khả năng x có thể trở thành null, Microsoft chỉ quyết định không đưa kiểm tra này vào trình biên dịch, hay nó đã bị bỏ lỡ hoàn toàn?

Cập nhật: Sau khi lộn xộn với mã để viết bài viết này, đột nhiên trình biên dịch đưa ra cảnh báo rằng biểu thức sẽ không bao giờ đúng. Bây giờ tôi thực sự lạc lối. Tôi đặt đối tượng vào một lớp và bây giờ cảnh báo đã biến mất nhưng vẫn để lại câu hỏi, liệu một kiểu giá trị có thể kết thúc bằng null không.

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

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

Điều này là hợp pháp vì giải quyết quá tải của nhà điều hành có một nhà điều hành tốt nhất duy nhất để lựa chọn. Có một toán tử == nhận hai giá trị int null. Int local có thể chuyển đổi thành int nullable. Chữ null có thể chuyển đổi thành int nullable. Do đó, đây là cách sử dụng hợp pháp của toán tử == và sẽ luôn dẫn đến sai.

Tương tự, chúng tôi cũng cho phép bạn nói "if (x == 12,6)", điều này cũng sẽ luôn là false. Int local có thể chuyển đổi thành double, nghĩa đen là chuyển đổi thành double, và rõ ràng là chúng sẽ không bao giờ bằng nhau.

Nó không phải là một lỗi, vì có một int?chuyển đổi ( ); nó tạo ra một cảnh báo trong ví dụ đã cho:

Kết quả của biểu thức luôn là 'false' vì giá trị của kiểu 'int' không bao giờ bằng 'null' của kiểu 'int?'

Nếu bạn kiểm tra IL, bạn sẽ thấy rằng nó loại bỏ hoàn toàn nhánh không thể truy cập - nó không tồn tại trong bản phát hành.

Tuy nhiên, lưu ý rằng nó không tạo cảnh báo này cho các cấu trúc tùy chỉnh có toán tử bình đẳng. Nó từng có trong 2.0, nhưng không có trong trình biên dịch 3.0. Mã vẫn bị xóa (vì vậy nó biết rằng mã không thể truy cập được), nhưng không có cảnh báo nào được tạo:

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
    }
}

Với IL (cho Main) - lưu ý mọi thứ ngoại trừ MyValue(1)(có thể có tác dụng phụ) đã bị loại bỏ:

.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 
}

về cơ bản đây là:

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

Thực tế là so sánh không bao giờ có thể đúng không có nghĩa là nó bất hợp pháp. Tuy nhiên, không, một loại giá trị có thể là null.

Không, Int32 xsẽ không bao giờ trở thành null.

Nếu bạn đang so sánh một int với null thì có thể áp dụng toán tử so sánh nhận hai int.

"Tại sao so sánh kiểu giá trị với null lại là một cảnh báo?" bài viết sẽ giúp bạn.

Một kiểu giá trị không thể là null, mặc dù nó có thể bằng null(xem xét Nullable<>). Trong trường hợp của bạn, intbiến và nullđược truyền ngầm đến Nullable<Int32>và so sánh.

Tôi nghi ngờ rằng thử nghiệm cụ thể của bạn chỉ đang được trình biên dịch tối ưu hóa khi nó tạo IL vì thử nghiệm sẽ không bao giờ sai.

Lưu ý bên: Có thể có Int32 có thể sử dụng Int32 không? thay vào đó x.

Tôi đoán điều này là do "==" là một đường cú pháp thực sự đại diện cho lời gọi System.Object.Equalsphương thức chấp nhận System.Objecttham số. Đặc tả Null by ECMA là một kiểu đặc biệt, tất nhiên có nguồn gốc từ System.Object.

Đó là lý do tại sao chỉ có một cảnh báo.

[ĐÃ CHỈNH SỬA: đưa ra các cảnh báo về lỗi và đưa ra các toán tử rõ ràng về khả năng vô hiệu thay vì tấn công chuỗi.]

Theo gợi ý thông minh của @ supercat trong một nhận xét ở trên, các toán tử quá tải sau đây cho phép bạn tạo ra lỗi khi so sánh loại giá trị tùy chỉnh của bạn thành null.

Bằng cách triển khai các toán tử so sánh với các phiên bản nullable của kiểu của bạn, việc sử dụng null trong phép so sánh sẽ khớp với phiên bản nullable của toán tử, điều này cho phép bạn tạo ra lỗi thông qua thuộc tính Obsolete.

Cho đến khi Microsoft trả lại cho chúng tôi cảnh báo trình biên dịch của chúng tôi, tôi sẽ xử lý giải pháp này, cảm ơn @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;
    }
}

Tôi nghĩ câu trả lời tốt nhất cho việc tại sao trình biên dịch chấp nhận điều này là dành cho các lớp chung chung. Hãy xem xét lớp sau ...

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

Nếu trình biên dịch không chấp nhận các so sánh đối với nullcác kiểu giá trị, thì về cơ bản nó sẽ phá vỡ lớp này, có một ràng buộc ngầm gắn với tham số kiểu của nó (nghĩa là nó sẽ chỉ hoạt động với các kiểu không dựa trên giá trị).

Trình biên dịch sẽ cho phép bạn so sánh bất kỳ cấu trúc nào triển khai == thành null. Nó thậm chí còn cho phép bạn so sánh một int với null (mặc dù vậy bạn sẽ nhận được một cảnh báo).

Nhưng nếu bạn tháo rời mã, bạn sẽ thấy rằng sự so sánh đang được giải quyết khi mã được biên dịch. Vì vậy, ví dụ, mã này (nơi Footriển khai cấu trúc ==):

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

Tạo IL này:

.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

Bạn có thể thấy:

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

Được dịch thành:

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

Trong khi:

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

Được dịch thành sai:

IL_001e:  ldc.i4.0