C# 8 & No More NullReferenceExceptions – What about legacy code?

2018-06-20T15:00:02+02:00

I really like the lean and backwards compatible implementation.It’s nice you can now be explicit about if a reference type variable can be NULL and this might save a lot of null check bloat.

But while this will help to spot unintentional NULL values in your code at design time, it might even make the issue with exceptions far away from the actual problematic code worse. I can imagine String.Empty will be the new NULL now and instead of getting an exception at least far away from the code that causes the issue, you might now not even get an exception at all, just a wrong result at the end.

So while I think that overall this will be a nice improvement, but the devil might hide in the details.

LikeLiked by 1 person

Reply

2018-06-20T15:14:26+02:00

I don’t think string.Empty will be the new NULL now – you can use all the string methods on an empty string. Of course, this might lead to a result not expected, but this was always the case.

The non-nullable reference types are not only about strings – I expect it a huge improvement overall.

Of course, the devil might hide in the details – but I didn’t see such issues in the applications where I tried the new compiler yet.
I’m just expecting that we want more as it can’t catch all NullableReferenceException issues.

	int i1 = 4; // null is not allowed
	int? i2 = null; // null is allowed

	string s1 = "a string"; // null is not allowed
	string? s2 = null; // a nullable string

	class Book
	{
	public string Title { get; }
	public string Publisher { get; }
	public string? Isbn { get; }
	public Book(string title, string publisher, string? isbn)
	=> (Title, Publisher, Isbn) = (title, publisher, isbn);

	public Book(string title, string publisher)
	: this(title, publisher, null) { }

	public void Deconstruct(out string title, out string publisher, out string? isbn)
	=> (title, publisher, isbn) = (Title, Publisher, Isbn);

	public override string ToString() => Title;
	}

	var book = new Book("Professional C# 8", "Wrox Press");
	// string isbn = book.Isbn; // error: converting null literal or possible null value to non-nullable type
	string? isbn = book.Isbn;

	static string GetIsbn1(Book book)
	{
	string? isbn = book.Isbn;
	if (isbn == null)
	{
	return string.Empty;
	}
	return isbn;
	}

	public string GetIsbn2(Book book)
	=> book.Isbn ?? string.Empty;

	public class NewAndGlory
	{
	public string? GetANullString() => null;

	public string GetAString() => "a string";

	public string PassAString(string s) => s.ToUpper();
	}

	public class Legacy
	{
	public string GetANullString() => null;
	public string PassAString(string s)
	{
	if (s == null) throw new ArgumentNullException(nameof(s));
	return s.ToUpper();
	}
	}

	public interface ILegacyInterface
	{
	string Foo();
	}

	var newglory = new NewAndGlory();
	string? s1 = newglory.GetANullString();
	string s2 = newglory.GetAString();
	// string s3 = newglory.PassAString(null); // error: cannot convert null literal to non-nullable reference or unconstrained type parameter

	var old = new Legacy();
	string s4 = old.GetANullString(); // no error, s1 is null!
	string s5 = old.PassAString(null); // no error

	class SomeClass : ILegacyInterface
	{
	public string? Foo() => null;
	}

	class AnotherClass : ILegacyInterface
	{
	public string Foo() => "a string";
	}

	var glory = new NewAndGlory();
	string s1 = glory.GetANullString();
	string s2 = glory.GetAString();
	string s3 = glory.PassAString(null); // having a NullReferenceException here!

Why avoiding NullReferenceException?

Install C# 8

Reference Types are not Nullable

Assigning Nullable to Non-Nullable

Returning from and passing to methods

C# 8 Application using Libraries built with C# 7 and C# 8

C# 7 Application using Libraries built with C# 8

Summary

Share this:

Published by

Christian Nagel

46 thoughts on “C# 8 & No More NullReferenceExceptions – What about legacy code?”

Leave a comment Cancel reply