В чем разница между Nullable ‹T› .HasValue и Nullable ‹T›! = Null?

Компилятор заменяет нулевые сравнения вызовом HasValue, поэтому реальной разницы нет. Просто сделайте то, что более читабельно / имеет больше смысла для вас и ваших коллег.

Я предпочитаю (a != null), чтобы синтаксис соответствовал ссылочным типам.

Я провел некоторое исследование по этому поводу, используя разные методы для присвоения значений обнуляемому int. Вот что произошло, когда я делал разные вещи. Следует прояснить, что происходит. Имейте в виду: Nullable<something> или сокращенное обозначение something? - это структура, для которой компилятор, похоже, проделывает большую работу, чтобы позволить нам использовать значение null, как если бы это был класс.
Как вы увидите ниже, SomeNullable == null и SomeNullable.HasValue всегда будет возвращать ожидаемое значение true или false. Хотя это не показано ниже, SomeNullable == 3 также действителен (при условии, что SomeNullable - это int?).
Хотя SomeNullable.Value выдает нам ошибку времени выполнения, если мы присвоили null SomeNullable. Фактически, это единственный случай, когда значения NULL могут вызвать у нас проблему из-за комбинации перегруженных операторов, перегруженного метода object.Equals(obj), оптимизации компилятора и обезьяньего бизнеса.

Вот описание некоторого кода, который я запускал, и то, что он выводил в метках:

int? val = null;
lbl_Val.Text = val.ToString(); //Produced an empty string.
lbl_ValVal.Text = val.Value.ToString(); //Produced a runtime error. ("Nullable object must have a value.")
lbl_ValEqNull.Text = (val == null).ToString(); //Produced "True" (without the quotes)
lbl_ValNEqNull.Text = (val != null).ToString(); //Produced "False"
lbl_ValHasVal.Text = val.HasValue.ToString(); //Produced "False"
lbl_NValHasVal.Text = (!(val.HasValue)).ToString(); //Produced "True"
lbl_ValValEqNull.Text = (val.Value == null).ToString(); //Produced a runtime error. ("Nullable object must have a value.")
lbl_ValValNEqNull.Text = (val.Value != null).ToString(); //Produced a runtime error. ("Nullable object must have a value.")

Хорошо, попробуем следующий метод инициализации:

int? val = new int?();
lbl_Val.Text = val.ToString(); //Produced an empty string.
lbl_ValVal.Text = val.Value.ToString(); //Produced a runtime error. ("Nullable object must have a value.")
lbl_ValEqNull.Text = (val == null).ToString(); //Produced "True" (without the quotes)
lbl_ValNEqNull.Text = (val != null).ToString(); //Produced "False"
lbl_ValHasVal.Text = val.HasValue.ToString(); //Produced "False"
lbl_NValHasVal.Text = (!(val.HasValue)).ToString(); //Produced "True"
lbl_ValValEqNull.Text = (val.Value == null).ToString(); //Produced a runtime error. ("Nullable object must have a value.")
lbl_ValValNEqNull.Text = (val.Value != null).ToString(); //Produced a runtime error. ("Nullable object must have a value.")

Все так же, как и раньше. Имейте в виду, что инициализация с помощью int? val = new int?(null); с передачей null конструктору привела бы к ошибке времени COMPILE, поскольку значение VALUE объекта, допускающего значение NULL, НЕ допускает значения NULL. Только сам объект-оболочка может иметь значение null.

Точно так же мы получим ошибку времени компиляции из:

int? val = new int?();
val.Value = null;

не говоря уже о том, что val.Value в любом случае является свойством только для чтения, что означает, что мы даже не можем использовать что-то вроде:

val.Value = 3;

но опять же, полиморфные перегруженные операторы неявного преобразования позволяют нам:

val = 3;

Не нужно беспокоиться о полисом, что такое, если оно работает правильно? :)

В VB.Net. НЕ используйте «IsNot Nothing», если вы можете использовать «.HasValue». Я только что решил, что «операция может дестабилизировать время выполнения», ошибка среднего доверия, заменив «IsNot Nothing» на «.HasValue» в одном месте. Не совсем понимаю почему, но что-то в компиляторе происходит иначе. Я предполагаю, что "! = Null" в C # может иметь ту же проблему.

Если вы используете linq и хотите, чтобы ваш код был коротким, я рекомендую всегда использовать !=null

И вот почему:

Представьте, что у нас есть класс Foo с переменной SomeDouble, допускающей обнуляемое значение double

public class Foo
{
    public double? SomeDouble;
    //some other properties
}   

Если где-то в нашем коде мы хотим получить все Foo с ненулевыми значениями SomeDouble из коллекции Foo (предполагая, что некоторые foo в коллекции тоже могут быть нулевыми), мы получаем как минимум три способа написать нашу функцию (если мы используйте C # 6):

public IEnumerable<Foo> GetNonNullFoosWithSomeDoubleValues(IEnumerable<Foo> foos)
{
     return foos.Where(foo => foo?.SomeDouble != null);
     return foos.Where(foo=>foo?.SomeDouble.HasValue); // compile time error
     return foos.Where(foo=>foo?.SomeDouble.HasValue == true); 
     return foos.Where(foo=>foo != null && foo.SomeDouble.HasValue); //if we don't use C#6
}

И в такой ситуации я рекомендую всегда выбирать более короткий

Второй метод будет во много раз эффективнее (в основном из-за встраивания и бокса компиляторов, но все же числа очень выразительны):

public static bool CheckObjectImpl(object o)
{
    return o != null;
}

public static bool CheckNullableImpl<T>(T? o) where T: struct
{
    return o.HasValue;
}

Контрольный тест:

BenchmarkDotNet=v0.10.5, OS=Windows 10.0.14393
Processor=Intel Core i5-2500K CPU 3.30GHz (Sandy Bridge), ProcessorCount=4
Frequency=3233539 Hz, Resolution=309.2587 ns, Timer=TSC
  [Host] : Clr 4.0.30319.42000, 64bit RyuJIT-v4.6.1648.0
  Clr    : Clr 4.0.30319.42000, 64bit RyuJIT-v4.6.1648.0
  Core   : .NET Core 4.6.25009.03, 64bit RyuJIT


        Method |  Job | Runtime |       Mean |     Error |    StdDev |        Min |        Max |     Median | Rank |  Gen 0 | Allocated |
-------------- |----- |-------- |-----------:|----------:|----------:|-----------:|-----------:|-----------:|-----:|-------:|----------:|
   CheckObject |  Clr |     Clr | 80.6416 ns | 1.1983 ns | 1.0622 ns | 79.5528 ns | 83.0417 ns | 80.1797 ns |    3 | 0.0060 |      24 B |
 CheckNullable |  Clr |     Clr |  0.0029 ns | 0.0088 ns | 0.0082 ns |  0.0000 ns |  0.0315 ns |  0.0000 ns |    1 |      - |       0 B |
   CheckObject | Core |    Core | 77.2614 ns | 0.5703 ns | 0.4763 ns | 76.4205 ns | 77.9400 ns | 77.3586 ns |    2 | 0.0060 |      24 B |
 CheckNullable | Core |    Core |  0.0007 ns | 0.0021 ns | 0.0016 ns |  0.0000 ns |  0.0054 ns |  0.0000 ns |    1 |      - |       0 B |

Код теста:

public class BenchmarkNullableCheck
{
    static int? x = (new Random()).Next();

    public static bool CheckObjectImpl(object o)
    {
        return o != null;
    }

    public static bool CheckNullableImpl<T>(T? o) where T: struct
    {
        return o.HasValue;
    }

    [Benchmark]
    public bool CheckObject()
    {
        return CheckObjectImpl(x);
    }

    [Benchmark]
    public bool CheckNullable()
    {
        return CheckNullableImpl(x);
    }
}

Использовался https://github.com/dotnet/BenchmarkDotNet

Поэтому, если у вас есть возможность (например, написать собственные сериализаторы) для обработки Nullable в другом конвейере, чем object - и использовать их конкретные свойства - сделайте это и используйте определенные свойства Nullable. Так что с точки зрения последовательного мышления предпочтение следует отдавать HasValue. Последовательное мышление может помочь вам написать лучший код, не тратя слишком много времени на детали.

PS. Люди говорят, что советы предпочитают HasValue, потому что последовательное мышление не имеет отношения к делу и бесполезно. Можете ли вы предсказать эффективность этого?

public static bool CheckNullableGenericImpl<T>(T? t) where T: struct
{
    return t != null; // or t.HasValue?
}

PPS Люди продолжают минус, производительность CheckNullableGenericImpl вроде никто не пытается предсказать. Я вам скажу: там компилятор вам не поможет, заменив !=null на HasValue. HasValue следует использовать напрямую, если вы заинтересованы в производительности.