Why You Should Care About C#\u2019s \u2018Nullable Reference Types\u2019<\/p>\n
If you have ever worked with C#, you are likely aware on some level of the dreaded NullReferenceException<\/strong>. The NullReferenceException <\/strong>is one of the most feared runtime errors of any application, and its undesired effect of crashing programs while simultaneously wasting developers\u2019 time during debugging sessions is notorious. The exception is thrown at runtime when an attempt is made to use a member (e.g., property, method, etc.) or access a member variable on an object if the object that the member uses is\u00a0null.<\/p>\n Fortunately, with the introduction of C# 8.0, you can avoid these dreaded null-related issues by taking advantage of the new feature, Nullable Reference Types<\/strong>, to enforce stricter null-safety rules in your code. Nullable Reference Types help ensure that you investigate your null references at compile-time, giving you an early warning system against potential null reference bugs instead of affecting them at runtime. In this article, we will look at what nullable reference types are, how they enhance safety in your code, and how you can leverage them to write better and more reliable C#\u00a0code.<\/p>\n For reference types in C#, such as string, class, and object, assigning a null value is the default behavior. As a developer, you may appreciate your flexibility, but the concern is being affected by null-related errors if you did not perform a check for a reference type prior to utilizing it.<\/p>\n Before C# 8.0, C# had no way to distinguish between reference types that may or may not be initialized as null. As such, initializing objects and checking them for null before using them was left purely to the developer. C# 8.0 introduced Nullable Reference Types<\/strong>, which is a new way to state if a reference type is null. This is done using the? symbol to specifically designate a type to be\u00a0null.<\/p>\n Non-nullable Reference types: <\/strong>All reference types are non-nullable by default. This means you may not assign null, unless you explicitly declared it as a nullable reference type.Nullable Reference types<\/strong>: You may declare a reference type as nullable just by stating a\u00a0? after the type declaration, meaning that it may contain\u00a0null.<\/p>\n Let\u2019s consider an\u00a0example:<\/p>\n #nullable enable \/\/ Enable nullable reference typespublic class Person Name is a non-nullable reference type<\/strong> (it cannot be null), while Nickname is a nullable reference type (string<\/strong>?), meaning it can be set to\u00a0null<\/strong>.<\/p>\n The biggest advantage of nullable reference types is that they add compile-time safety checks to avoid NullReferenceException <\/strong>errors. If you turn on nullable reference types, the compiler will warn you if you try to assign null to a non-nullable reference type or if you try to dereference a nullable reference type without checking if it is\u00a0null.<\/p>\n When you have nullable reference types on, the compiler checks to make sure you handle potential nulls correctly. As an example, if you try to assign null to a non-nullable reference type, you will get an\u00a0error:<\/p>\n #nullable enablepublic class Person This lets you catch a potential bug before you even run your code, which should let you make your programs less surprising and more\u00a0stable.<\/p>\n Another benefit is avoiding accidentally dereferencing <\/strong>null. When you try to reference a nullable reference type without checking to see if it is null, the compiler will warn\u00a0you:<\/p>\n #nullable enablepublic class Person Name is nullable (string?) here, and getting its Length property without any null check would throw a runtime exception. The compiler warns you of this possibility before you even run the\u00a0code.<\/p>\n Using nullable reference types makes your code more expressive and easier to read. You can instantly see for which properties or variables it is possible that they hold a null value for which makes it easier to think about the code and not include unnecessary null\u00a0checks.<\/p>\n public class Person In the above case, it is easy to see that Name will never be null, but Nickname can be null. As a result, you can have an easier time avoiding some bugs when working with those properties.<\/p>\n Migrating an existing project to nullable reference types is a simple process; however, it could require some refactoring to handle existing non-nullable code<\/strong> with respect to the new nullability rules.<\/p>\n Steps to\u00a0take:<\/p>\n First, you will want to allow nullable reference types. You can allow them globally in your (.csproj) project file or on a per-file basis with the#nullable enable directive.<\/p>\n Global Allowance<\/strong>: If you want to allow nullable reference types as a project, then add this to the\u00a0.csproj\u00a0file:<Nullable>enable<\/Nullable>Per-File Allowance<\/strong>: If you want to globally allow nullable reference types, but only for certain files, then add the following directive at the top of your C#\u00a0Files#nullable enable<\/p>\n Once nullable reference types have been enabled, you will probably have warnings in places where you are not handling nullability as intended. For example, assigning null to a non-nullable reference type or dereferencing a nullable type without a null check will both show warnings.<\/p>\n You can handle these warnings in a few different ways:<\/p>\n Mark types as nullable<\/strong>: Use the\u00a0? to mark types that can be\u00a0null.Check for <\/strong>null<\/strong>: Use a null check or a null-conditional operator to be sure that the nullable reference types are only accessed if they are not\u00a0null.public string? GetName(Person person) You don\u2019t have to change everything all at once. You can begin by enabling nullable reference types in areas where nulls might cause serious issues, and then incrementally refactor the rest of your codebase. This allows you to deploy a feature that is iterative while also safeguarding your application.<\/p>\n If you have some cases where you know a nullable reference type will never be null, you can use the! operator, the null-forgiving operator, to suppress the warnings.<\/p>\n string name = person.Name!; \/\/ Suppress warning assuming Name will never be null.<\/p>\n But use this carefully because it can lead to run-time errors when the assumption is\u00a0wrong.<\/p>\n Now let\u2019s look at some example code and see how nullable reference types work practically.<\/p>\n #nullable enablepublic class Person In this\u00a0example:<\/p>\n Name is nullable (string?), so it is valid to assign null to\u00a0it.We check to see whether Nameis null before we access the Length property, so that we do not throw an exception at run-time.<\/p>\n #nullable enablepublic class Person Here, It Name is a non-nullable reference type, so you cannot assign null to it, and the compiler will provide an error at compile time, preventing a possible\u00a0null.<\/p>\n While nullable reference types greatly mitigate null issues, there are a few best practices to adhere to to avoid null\u00a0issues:<\/p>\n Mark Nullable Types Explicitly<\/strong>: Avoid overuse of nullable reference types. Only mark a reference type as nullable when it has real significance in your model (i.e., an optional property or parameter).Use Null-Conditional Operators<\/strong>: Utilize the null-conditional operator (?.) to safely access nullable reference types; this way, you won\u2019t have to worry about triggering a NullReferenceException.string? name = person?.Name; \/\/ Returns null if person is null<\/p>\n 3. Check for null Before Usage<\/strong>: When using nullable reference types, always check for null before using them. This will help prevent you from accidentally dereferencing a null reference.<\/p>\n 4. Use IDisposableto Manage Unmanaged Resources.<\/strong> While nullable reference types are\u00a0helpful,<\/p>\n 5. Use the Null-Forgiving Operator (<\/strong>!Only When Necessary<\/strong> string name = person.Name!;<\/p>\n 6. However, this circumvents the compiler\u2019s safety functionality<\/strong> and should only be used when necessary. It is like saying to the compiler, \u201cTrust me, I know what I am doing.\u201d You still risk throwing a runtime exception if you are\u00a0wrong.<\/p>\n 7. Prefer Constructor Initialization for Required Properties<\/strong> public class Person { public Person(string name) { 8. This method enforces immutability <\/strong>and guarantees the required values to always available.<\/p>\n 9. Use Annotations and Contracts for Better Clarity<\/strong> Nullable reference types in C# represent more than a language feature\u200a\u2014\u200athey are a change in philosophy towards safer, more defensive, and more intentional programming<\/strong>. If you enable this feature, you\u00a0will:<\/p>\n Catch issues related to null before <\/strong>they can crash your\u00a0app.Be better understood by other developers (and your future\u00a0self).Create code that is easier to maintain and reason\u00a0about.Reduce runtime exceptions and improve app stability.<\/p>\n Simply put, nullable reference types are a way to get the compiler<\/strong> to do more of the heavy lifting for you, to allow you to write applications that, before this point, are robust and resilient<\/p>\n If you are building new applications or maintaining high-value production applications, enabling nullable reference types is one of the easiest and most powerful mechanisms for quick-better-code-now!<\/p>\n To recap:<\/p>\n Enable it in your\u00a0.csproj\u00a0file:<Nullable>enable<\/Nullable>Start annotating your code with \u2018?\u2019 where null is an acceptable option.Fix all the compiler warnings, and be aware of the null-checking best practice.Expect fewer bugs and more confidence that your code is\u00a0right.<\/p>\n In today\u2019s\u00a0.NET world\u200a\u2014\u200awith C#<\/strong> powering everything from web applications to cloud computing and cross-platform mobile apps\u200a\u2014\u200anull-safe code is more than a best practice: it\u2019s required.<\/p>\n Nullable reference types add compile-time safety to one of the most dangerous areas of programming<\/strong>. It might feel like a small step forward, but the impact this can have on the quality of your code cannot be understated. So next time you have a\u00a0? in your type declaration, consider it not a pain in the butt, but rather as a guardian-keeping your code safe from the sneaky bugs that go undetected\u2026 until your app goes down on production time.<\/p>\n Why You Should Care About C#\u2019s \u2018Nullable Reference Types\u2019<\/a> was originally published in Coinmonks<\/a> on Medium, where people are continuing the conversation by highlighting and responding to this story.<\/p>","protected":false},"excerpt":{"rendered":" and How They Help Prevent Null-Related Errors Why You Should Care About C#\u2019s \u2018Nullable Reference Types\u2019 If you have ever worked with C#, you are likely aware on some level of the dreaded NullReferenceException. The NullReferenceException is one of the most feared runtime errors of any application, and its undesired effect of crashing programs while […]<\/p>\n","protected":false},"author":0,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[2],"tags":[],"class_list":["post-93768","post","type-post","status-publish","format-standard","hentry","category-interesting"],"_links":{"self":[{"href":"https:\/\/mycryptomania.com\/index.php?rest_route=\/wp\/v2\/posts\/93768"}],"collection":[{"href":"https:\/\/mycryptomania.com\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/mycryptomania.com\/index.php?rest_route=\/wp\/v2\/types\/post"}],"replies":[{"embeddable":true,"href":"https:\/\/mycryptomania.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=93768"}],"version-history":[{"count":0,"href":"https:\/\/mycryptomania.com\/index.php?rest_route=\/wp\/v2\/posts\/93768\/revisions"}],"wp:attachment":[{"href":"https:\/\/mycryptomania.com\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=93768"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/mycryptomania.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=93768"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/mycryptomania.com\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=93768"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}What Are Nullable Reference Types?<\/h3>\n
{
public string Name { get; set; } \/\/ Non-nullable
public string? Nickname { get; set; } \/\/ Nullable
}var person = new Person();
person.Name = “John”;
person.Nickname = null; \/\/ This is valid because Nickname is nullable.<\/p>\nHow Nullable Reference Types Offer Better\u00a0Safety<\/h3>\n
1. Compile-Time Null\u00a0Safety<\/h4>\n
{
public string Name { get; set; } \/\/ Non-nullable
}var person = new Person();
person.Name = null; \/\/ Error: Cannot assign null to non-nullable reference type.<\/p>\n2. Preventing Unintentional Null Dereferencing<\/h4>\n
{
public string? Name { get; set; }
}var person = new Person();
Console.WriteLine(person.Name.Length); \/\/ Warning: Dereferencing a nullable value.<\/p>\n3. Better Code Readability and Clarity of\u00a0Intent<\/h4>\n
{
public string Name { get; set; } \/\/ Non-nullable reference type
public string? Nickname { get; set; } \/\/ Nullable reference type
}<\/p>\nMigrating an Existing Project to Nullable Reference Types<\/h3>\n
1. Allow Nullable Reference Types<\/h4>\n
2. Resolving Warnings and\u00a0Errors<\/h4>\n
{
return person?.Name; \/\/ Safe access with null-conditional operator
}<\/p>\n3. Staged Migration<\/h4>\n
4. Suppressing Warnings<\/h4>\n
Code Examples: Demonstrating Nullable Types in\u00a0Practice<\/h3>\n
Example 1: Nullable Reference Types in\u00a0Practice<\/h4>\n
{
public string? Name { get; set; }
}var person = new Person();
person.Name = null;if (person.Name != null)
{
Console.WriteLine(person.Name.Length); \/\/ Safe to access Name, as null is checked first.
}
else
{
Console.WriteLine(“Name is null”);
}<\/p>\nExample 2: Non-nullable reference types<\/h4>\n
{
public string Name { get; set; } \/\/ Non-nullable
}var person = new Person();
person.Name = null; \/\/ Error: Cannot assign null to a non-nullable reference type.<\/p>\nBest Practices to Avoid Null Issues in\u00a0C#<\/h3>\n
If you are completely certain that the nullable reference will not be nullYou can suppress the compiler warning with the null-forgiving operator\u00a0(<\/strong>!)<\/strong><\/p>\n
When working with non-nullable properties, initialize them through constructors to ensure they\u2019re always set when an object is\u00a0created:<\/p>\n
public string Name {
get;
}<\/p>\n
Name = name;
}
}<\/p>\n
When authoring APIs or libraries, adding attributes such as [NotNull], [MaybeNull], or XML documentation can make your intent clearer and enhance tool\u00a0support.<\/p>\nSummary: Why Nullable Reference Types Are Worth the\u00a0Effort<\/h3>\n
Are You Ready to Enable\u00a0It?<\/h3>\n
Final Thought<\/h3>\n