.NET DBNull vs Nothing across all variable types?

Question

I am a little confused about null values and variables in .NET. (VB preferred)

Is there any way to check the "nullness" of ANY given variable regardless of whether it was an object or a value type? Or does my null check have to always anticipate whether it's checking a value type (e.g. System.Integer) or an object?

I guess what I'm looking for is a function that checks all possible kind of null-ness. That is, any type of variables that

a) were never assigned a value since declared

b) were assigned a null value from a data object (that came from a database)

c) were set equals to another variable value which was null

d) were set to an ASP.NET session/application variable that was never set or expired.

Is there a general best-practice when it comes to handling null scenarios in .NET?

UPDATE: When I talk about a value type being "null", what I really mean is a value type that was either never set or was at some point set equal to or cast from a null object.

Solution 1

Normal value types (booleans, ints, longs, float, double, enum and structs) are not nullable.

The default value for all value types is 0.

The CLR won't let you access variables unless they have been set. You may think this isn't always the case, but sometimes the CLR steps in and initializes them for you. At a method level you must explicitly initialize all variables before they are used.

Further, as others point out, since .net 2.0 there is a new generic type called Nullable<T>. There are some compiler shorthands in C# like int? means Nullable<int>, double? means Nullable<double> etc.

You can only wrap Nullable<T> over non-nullable value types, which is fine since references already have the ability to be null.

int? x = null;

For an int?, while you can test against null, it's sometimes nicer to call x.HasValue().

In C# there's also the nullable coalescing operator ?? when you want to assign a nullable to a non-nullable value type. But if you don't have the operator, you can call GetValueOrDefault().

int y = x ?? 2; // y becomes 2 if x is null.
int z = x.GetValueOrDefault(2); // same as y

Solution 2

Value Types can't be null. It violates what it means to be a Value Type. You can wrap Value Types as Nullable(Of T) which gives you a great set of methods, and checks for Nothing do work. But you do have a lot of overhead with that wrapper. Perhaps you can clarify what you're trying to do?

For completeness the VB syntax for Nullable wrappers is:

Dim i as Nullable(Of Integer) = Nothing '.NET 2.0/3.0'
Dim j as Integer? = Nothing '.NET 3.5'

EDIT: Value Type are always preinitialized to a default value, 0 for numerics, false for Booleans, etc.

Solution 3

Is this what you're after?

if IsNothing(foo) OrElse IsDbNull(foo) Then
    ' Do Something Because foo Is Either Nothing or DBNull.Value
End If

In truth I'm not certain why you'd wish for this structure. The Only time I'd check for DBNULL.Value is when I'm using values that came from a database, and before I assign said value from a DATA Namespace class to some other class [i.e. dim b as string = dataReader(0)].

Typically, if you're concerned about an object having not been instantiated, or needing it to be re-instantiated, then just an IsNothing check will suffice.

Solution 4

In .Net that are only two types of null that I am aware of, null (nothing in VB) and DbNull. If you are using a System.Nullable, you can use the same null checking syntax as you would with an object. If if your nullable object is boxed the .Net 2.0 CLR is smart enough to figure out the right way to handle this.

The only case I have run into both types is in the data tier of an application where I might be accessing database data directly. For example, I have run into DbNull in a DataTable. To check for both of these null types in this situration, you could write an extension method like (sorry, in C#):

static public bool IsNull(this object obj)
{
    return obj != null && obj != DbNull.Value;
}

...

if(dataTable[0]["MyColumn"].IsNull())
{
  //do something
}

View more solutions

Comments

[Ashwin]

the rule is that for all value types, the default is 0. (int, long, float, double, enums, structs, etc.)