There is
no-doubt that the C#2 nullable-types
is a cool feature. However I regret that C# don't support the other
half of the paradigm: the non-nullable types.
The same
way as nullable-types allow null values for value-types, non-nullable types forbid
null references for reference types. In
the following example the method AcceptNonNullString(string!) takes a non-nullable
string as parameter.
static void AcceptNullString(string
s) {
AcceptNonNullString(null);
// <- Here the compiler emit an error.
AcceptNonNullString(s); // <- Here the
compiler emit an error
// because 's' might
be null.
}
static void AcceptNonNullString(string!
s) {
// Here we have
the garantee that the reference 's' is not null.
int length =
s.Length;
}
The !
syntax comes from the an extension of C# named Spec# .
I think it is an elegant and
concise syntax that allows to get rid of a problem
programmers face every day: NullReferenceException. This power comes at a
cost. There exist some cases where the compiler should be tweaked in order to
ensure the non-nullable condition, for example:
- ·
There
is problem to check non-nullable instance fields:
public class Foo {
string! m_String;
public Foo(string! s) {
// Here the
compiler must understand that m_String
// hasn't
been assigned yet and is null.
int
length = m_String.Length;
m_String = s;
}
}
- ·
There is problem to check
non-nullable static fields:
public class Foo {
static string! s_String;
static
Foo() {
// Here the
compiler must understand that s_String
// hasn't
been assigned yet and is null.
int
length = s_String.Length;
s_String = "hello";
}
}
- ·
There
is problem to check arrays of non-nullable elements:
void Method() {
string![]
array = new string![2];
// Here array[0]
and array[1] are null references.
array[0] = "hello";
array[1] = "hello";
}
More information
on these problems can be found here on these excellent blog posts [1] [2] [3] [4] by Cyrus Najmabadi, a software design
engineer on the C# team.
I had the
chance during the last MVP summit in March 2007 to talk about non-nullable
types with the C# team. It seems that the biggest hindrance to the adoption of non-nullable
types is that it is so powerful that it would disturb programmers’ habits
and code base. Indeed, we agreed that something like 70% of references of C# programs are likely to end-up as non-nullable ones. This underlines the fact
that null references are the exception and not the rule.Indeed, null
references is a trick inherited from the good old days with C++. Nowadays, programmers
are used to rely on null references to avoid writing too much
code for simple check such as field not initialized or optional parameters. The NullReferenceException problem is a high price to pay for this facility.
In this
context, adding the ! syntax to C# is a bit awkward since the vast majority
of references would use this extra syntax. Personally, I could live with
that. We now don’t have the choice. We spend our time inserting numerous
non-null checks and asserts in our methods and we pray that it is
enough to avoid the pesky NullReferenceException experience to our users. It is
never too late to do things well and non-nullable types should be added to C#4
(it is clearly too late to add such a feature to C#3).