Which is preferred Nullable T HasValue or Nullable T null

Question

I always used Nullable lt  gt  HasValue because I liked the semantics  However  recently I was working on someone else s existing codebase where they used Nullable lt  gt     null exclusively instead   Is there a reason to use one over the other  or is it purely preference    int  a  if  a HasValue                vs    int  b  if  b    null

User · Answer

I prefer  a    null  so that the syntax matches reference types

User · Answer

There second method will be many times more effective  mostly because of compilers inlining and boxing but still numbers are very expressive   public static bool CheckObjectImpl object o        return o    null     public static bool CheckNullableImpl lt T gt  T  o  where T  struct       return o HasValue     Benchmark test  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    Benchmark code  public class BenchmarkNullableCheck       static int  x    new Random    Next         public static bool CheckObjectImpl object o                return o    null             public static bool CheckNullableImpl lt T gt  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 was used So if you have an option  e g  writing custom serializers  to process Nullable in different pipeline than  object - and use their specific properties - do it and use Nullable specific properties  So from consistent thinking point of view HasValue should be preferred  Consistent thinking can help you to write better code do not spending too much time in details  PS  People say that advice  quot prefer HasValue because of consistent thinking quot  is not related and useless  Can you predict the performance of this  public static bool CheckNullableGenericImpl lt T gt  T  t  where T  struct       return t    null     or t HasValue     PPS People continue minus  seems nobody tries to predict  performance of CheckNullableGenericImpl  I will tell you  there compiler will not help you replacing   null with HasValue  HasValue should be used directly if you are interested in performance

User · Answer

In VB Net   Do NOT use  IsNot Nothing  when you can use   HasValue    I just solved an  Operation could destabilize the runtime  Medium trust error by replacing  IsNot Nothing  with   HasValue  In one spot   I don t really understand why  but something is happening differently in the compiler   I would assume that     null  in C  may have the same issue

User · Answer

If you use linq and want to keep your code short  I recommand to always use   null   And this is why   Let imagine we have some class Foo with a nullable double variable SomeDouble  public class Foo       public double  SomeDouble        some other properties        If somewhere in our code we want to get all Foo with a non null SomeDouble values from a collection of Foo  assuming some foos in the collection can be null too   we end up with at least three way to write our function  if we use C  6     public IEnumerable lt Foo gt  GetNonNullFoosWithSomeDoubleValues IEnumerable lt Foo gt  foos         return foos Where foo   gt  foo  SomeDouble    null        return foos Where foo  gt foo  SomeDouble HasValue      compile time error      return foos Where foo  gt foo  SomeDouble HasValue    true         return foos Where foo  gt foo    null  amp  amp  foo SomeDouble HasValue     if we don t use C 6     And in this kind of situation I recommand to always go for the shorter one

User · Answer

I did some research on this by using different methods to assign values to a nullable int  Here is what happened when I did various things  Should clarify what s going on  Keep in mind  Nullable lt something gt  or the shorthand something  is a struct for which the compiler seems to be doing a lot of work to let us use with null as if it were a class  As you ll see below  SomeNullable    null and SomeNullable HasValue will always return an expected true or false  Although not demonstrated below  SomeNullable    3 is valid too  assuming SomeNullable is an int    While SomeNullable Value gets us a runtime error if we assigned null to SomeNullable  This is in fact the only case where nullables could cause us a problem  thanks to a combination of overloaded operators  overloaded object Equals obj  method  and compiler optimization and monkey business   Here is a description of some code I ran  and what output it produced in labels   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      Ok  lets try the next initialization method   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      All the same as before  Keep in mind that initializing with int  val   new int  null    with null passed to the constructor  would have produced a COMPILE time error  since the nullable object s VALUE is NOT nullable  It is only the wrapper object itself that can equal null   Likewise  we would get a compile time error from   int  val   new int     val Value   null    not to mention that val Value is a read-only property anyway  meaning we can t even use something like   val Value   3    but again  polymorphous overloaded implicit conversion operators let us do   val   3    No need to worry about polysomthing whatchamacallits though  so long as it works right

User · Answer

The compiler replaces null comparisons with a call to HasValue  so there is no real difference  Just do whichever is more readable makes more sense to you and your colleagues

[c#] Which is preferred: Nullable<T>.HasValue or Nullable<T> != null?

Examples related to c#

Examples related to .net

Examples related to null

Examples related to nullable