{"id":2190,"date":"2024-10-18T10:26:18","date_gmt":"2024-10-18T10:26:18","guid":{"rendered":"https:\/\/www.w3computing.com\/articles\/?p=2190"},"modified":"2024-10-18T10:26:22","modified_gmt":"2024-10-18T10:26:22","slug":"how-to-work-with-nullable-reference-types-in-c-8-0","status":"publish","type":"post","link":"https:\/\/www.w3computing.com\/articles\/how-to-work-with-nullable-reference-types-in-c-8-0\/","title":{"rendered":"How to Work with Nullable Reference Types in C# 8.0+"},"content":{"rendered":"\n

Nullable reference types are one of the significant new features introduced in C# 8.0. The goal is to help developers avoid the most common and frustrating issues in C# development: null reference exceptions, often referred to as the “billion-dollar mistake.”<\/p>\n\n\n\n

Before C# 8.0, all reference types were implicitly nullable, meaning that any reference type variable could hold either a reference to an object or a null<\/code> value. However, this lack of clarity often led to runtime errors when null<\/code> was assigned to variables or passed around, resulting in null reference exceptions. C# 8.0 introduced nullable reference types to provide a way to explicitly mark variables as nullable or non-nullable, thereby providing better compile-time checks and reducing the likelihood of runtime issues.<\/p>\n\n\n\n

This tutorial will guide you through everything you need to know about nullable reference types in C# 8.0 and beyond, explaining how they work, how to enable them, and how to manage them effectively in your codebase.<\/p>\n\n\n\n

What Are Nullable Reference Types?<\/h2>\n\n\n\n

In C# 8.0 and later, nullable reference types allow developers to express whether a reference type can be null<\/code> or not. The compiler enforces this with warnings and errors where appropriate, helping developers write safer, more robust code.<\/p>\n\n\n\n

Nullable reference types are split into two categories:<\/p>\n\n\n\n

    \n
  1. Non-nullable reference types<\/strong>: These are the default reference types, which cannot be assigned a null<\/code> value.<\/li>\n\n\n\n
  2. Nullable reference types<\/strong>: These reference types can hold a null<\/code> value.<\/li>\n<\/ol>\n\n\n\n

    The idea is simple: if you declare a reference type variable as nullable, the compiler knows that it can potentially hold a null<\/code> value and will issue warnings if you’re not handling the null<\/code> case appropriately. If the variable is non-nullable, the compiler will ensure that you’re not assigning null<\/code> to it or accessing it without initializing it.<\/p>\n\n\n\n

    How to Enable Nullable Reference Types<\/h2>\n\n\n\n

    Nullable reference types are not enabled by default in C# 8.0+ because they would break backward compatibility with existing codebases. To enable them, you need to do so explicitly at either the project level or within specific files or scopes.<\/p>\n\n\n\n

    Enabling Nullable Reference Types in the Project File<\/h3>\n\n\n\n

    You can enable nullable reference types for the entire project by modifying the .csproj<\/code> file. Add the following line within the <PropertyGroup><\/code> section:<\/p>\n\n\n

    <PropertyGroup<\/span>><\/span>\n  <Nullable<\/span>><\/span>enable<\/Nullable<\/span>><\/span>\n<\/PropertyGroup<\/span>><\/span><\/code><\/span>Code language:<\/span> HTML, XML<\/span> (<\/span>xml<\/span>)<\/span><\/small><\/pre>\n\n\n
    This setting applies globally to all files in the project.<\/p>\n\n\n\n
    Enabling Nullable Reference Types in Code<\/h3>\n\n\n\n
    If you want to enable nullable reference types for a specific file or section of code rather than the entire project, you can use the #nullable<\/code> directive at the top of your C# file:<\/p>\n\n\n
    #nullable enable<\/span><\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
    You can also disable nullable reference types using:<\/p>\n\n\n
    #nullable disable<\/span><\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
    If you want to enforce nullable reference types within a particular block of code, you can use #nullable<\/code> for finer control:<\/p>\n\n\n
    #nullable enable<\/span>\n\nvoid<\/span> MyMethod<\/span>(<\/span>)<\/span>\n{\n    string<\/span>? nullableString = null<\/span>; \/\/ Allowed<\/span>\n    string<\/span> nonNullableString = null<\/span>; \/\/ Warning: CS8600<\/span>\n}\n\n#nullable disable<\/span><\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
    This flexibility allows you to gradually adopt nullable reference types in a large codebase, starting from new code or specific parts of the application.<\/p>\n\n\n\n
    Nullable vs. Non-Nullable Reference Types<\/h2>\n\n\n\n
    Once nullable reference types are enabled, the C# compiler starts treating reference types in a new way. Let’s break down the differences between nullable and non-nullable reference types.<\/p>\n\n\n\n
    Non-Nullable Reference Types<\/h3>\n\n\n\n
    By default, reference types like string<\/code>, object<\/code>, List<T><\/code>, etc., are non-nullable when nullable reference types are enabled.<\/p>\n\n\n
    #nullable enable<\/span>\n\nstring<\/span> nonNullableString = null<\/span>; \/\/ Warning: CS8600, null cannot be assigned to a non-nullable reference type<\/span><\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
    In this example, the compiler warns you that you are trying to assign null<\/code> to a non-nullable string<\/code>. Non-nullable reference types cannot hold a null<\/code> value. This restriction makes your code safer because you can be confident that whenever you access a non-nullable reference type, it will never be null<\/code>.<\/p>\n\n\n\n
    Nullable Reference Types<\/h3>\n\n\n\n
    Nullable reference types are indicated by appending a ?<\/code> to the reference type. These types can hold a null<\/code> value.<\/p>\n\n\n
    #nullable enable<\/span>\n\nstring<\/span>? nullableString = null<\/span>; \/\/ No warning<\/span><\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
    Here, the compiler understands that nullableString<\/code> can be null<\/code>, so it won’t issue a warning. However, this comes with a trade-off: you need to handle null<\/code> values appropriately when using nullable reference types.<\/p>\n\n\n\n
    For example:<\/p>\n\n\n
    #nullable enable<\/span>\n\nvoid<\/span> Greet<\/span>(string<\/span>? name<\/span>)<\/span>\n{\n    if<\/span> (name != null<\/span>)\n    {\n        Console.WriteLine($\"Hello, {name}<\/span>\"<\/span>);\n    }\n    else<\/span>\n    {\n        Console.WriteLine(\"Hello, stranger!\"<\/span>);\n    }\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
    In this case, we check whether name<\/code> is null<\/code> before using it, ensuring that we don’t run into null reference exceptions at runtime.<\/p>\n\n\n\n
    Compiler Warnings and Nullability Annotations<\/h2>\n\n\n\n
    When nullable reference types are enabled, the compiler will analyze your code and provide warnings if you’re not handling potential null<\/code> values correctly. Let’s explore the different kinds of warnings you might encounter.<\/p>\n\n\n\n
    CS8600: Null Assigned to Non-Nullable Type<\/h3>\n\n\n\n
    This warning occurs when you’re trying to assign a null<\/code> value to a non-nullable reference type.<\/p>\n\n\n
    #nullable enable<\/span>\n\nstring<\/span> nonNullableString = null<\/span>; \/\/ Warning: CS8600<\/span><\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
    CS8602: Dereference of a Possibly Null Reference<\/h3>\n\n\n\n
    This warning occurs when you’re trying to dereference a nullable reference type without first ensuring it’s not null<\/code>.<\/p>\n\n\n
    #nullable enable<\/span>\n\nstring<\/span>? nullableString = null<\/span>;\nConsole.WriteLine(nullableString.Length); \/\/ Warning: CS8602<\/span><\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
    To fix this, you need to check whether nullableString<\/code> is null<\/code> before accessing it:<\/p>\n\n\n
    #nullable enable<\/span>\n\nstring<\/span>? nullableString = null<\/span>;\n\nif<\/span> (nullableString != null<\/span>)\n{\n    Console.WriteLine(nullableString.Length); \/\/ No warning<\/span>\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
    Alternatively, you can use the null-conditional operator (?.<\/code>) to safely access nullable types:<\/p>\n\n\n
    #nullable enable<\/span>\n\nstring<\/span>? nullableString = null<\/span>;\n\nConsole.WriteLine(nullableString?.Length); \/\/ No warning<\/span><\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
    In this case, if nullableString<\/code> is null<\/code>, the expression will evaluate to null<\/code>, and nothing will be printed.<\/p>\n\n\n\n
    CS8603: Null Returned from a Non-Nullable Type<\/h3>\n\n\n\n
    This warning occurs when you’re returning null<\/code> from a method that has a non-nullable return type.<\/p>\n\n\n
    #nullable enable<\/span>\n\nstring<\/span> GetNonNullableString<\/span>(<\/span>)<\/span>\n{\n    return<\/span> null<\/span>; \/\/ Warning: CS8603<\/span>\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
    To fix this, you can either change the return type to be nullable or ensure you’re returning a non-null value.<\/p>\n\n\n
    #nullable enable<\/span>\n\nstring<\/span>? GetNullableString()\n{\n    return<\/span> null<\/span>; \/\/ No warning<\/span>\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
    Null Forgiving Operator (!<\/code>)<\/h2>\n\n\n\n
    Sometimes, you may know that a variable is not null<\/code> but the compiler can’t determine that. In such cases, you can use the null-forgiving operator (!<\/code>) to suppress the compiler warning.<\/p>\n\n\n
    #nullable enable<\/span>\n\nstring<\/span>? nullableString = GetString();\n\nConsole.WriteLine(nullableString!.Length); \/\/ No warning<\/span><\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
    In this example, nullableString!<\/code> tells the compiler, “I know this value isn’t null<\/code>, so don’t warn me about it.” Be careful when using the null-forgiving operator, as it’s easy to introduce runtime errors if you mistakenly assume that a value will never be null<\/code>.<\/p>\n\n\n\n
    Adopting Nullable Reference Types in Existing Codebases<\/h2>\n\n\n\n
    Nullable reference types can be a fantastic tool for writing safer code, but adopting them in a large existing codebase can be a bit tricky. Fortunately, C# gives you the tools to adopt nullable reference types incrementally and with care.<\/p>\n\n\n\n
    Gradual Adoption<\/h3>\n\n\n\n
    You don’t have to enable nullable reference types for your entire project at once. You can enable them in specific files or even in particular sections of code using the #nullable enable<\/code> directive, as shown earlier.<\/p>\n\n\n\n
    This approach allows you to gradually refactor your codebase, starting with new code or the most critical areas. Over time, you can enable nullable reference types in more areas as you improve your code’s nullability safety.<\/p>\n\n\n\n
    Null Annotations and Legacy Code<\/h3>\n\n\n\n
    When working with legacy code that doesn’t have nullability annotations, you’ll need to balance the strictness of nullable reference types with the flexibility of existing code. One option is to disable nullable reference types in legacy files using #nullable disable<\/code> to prevent compiler warnings from flooding your project.<\/p>\n\n\n\n
    However, it’s worth considering adding nullability annotations to your existing codebase over time. This process involves updating method signatures, return types, and variable declarations to explicitly mark them as nullable or non-nullable.<\/p>\n\n\n\n
    Using Annotations for External Libraries<\/h3>\n\n\n\n
    If you’re working with external libraries that haven’t yet adopted nullable reference types, the compiler may not have enough information to provide accurate nullability warnings. In such cases, you can use annotations from the System.Diagnostics.CodeAnalysis<\/code> namespace to indicate nullability behavior explicitly.<\/p>\n\n\n\n
    For example, you can use the [NotNull]<\/code>, [MaybeNull]<\/code>, and [AllowNull]<\/code> attributes to provide hints to the compiler about the nullability of parameters, return types, or properties.<\/p>\n\n\n
    #nullable enable<\/span>\nusing<\/span> System.Diagnostics.CodeAnalysis;\n\npublic<\/span> class<\/span> Example<\/span>\n{\n    public<\/span> void<\/span> Process<\/span>([NotNull] string<\/span>? input<\/span>)<\/span>\n    {\n        \/\/ The compiler assumes 'input' is not null in the method body<\/span>\n        Console.WriteLine(input.Length); \/\/ No warning<\/span>\n    }\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
    These annotations help improve nullability checks when working with external code that doesn’t have full nullability annotations.<\/p>\n\n\n\n
    Nullable Contexts and Annotations in APIs<\/h2>\n\n\n\n
    In addition to enabling nullable reference types in your own code, you can also use nullability annotations to design APIs that clearly communicate nullability expectations. This improves the safety and clarity of your public APIs, making it easier for other developers to use them correctly.<\/p>\n\n\n\n
    Designing APIs with Nullability Annotations<\/h3>\n\n\n\n
    When designing an API, you can use nullable reference types to make your intentions clear regarding which parameters or return types can be null<\/code> and which cannot.<\/p>\n\n\n\n
    For example, consider a simple API for handling user information:<\/p>\n\n\n
    #nullable enable<\/span>\n\npublic<\/span> class<\/span> User<\/span>\n{\n    public<\/span> string<\/span> Name { get<\/span>; set<\/span>; }\n    public<\/span> string<\/span>? Nickname { get<\/span>; set<\/span>; }\n\n    public<\/span> User<\/span>(string<\/span> name, string<\/span>? nickname<\/span>)<\/span>\n    {\n        Name = name ?? throw<\/span> new<\/span> ArgumentNullException(nameof<\/span>(name));\n        Nickname = nickname;\n    }\n\n    public<\/span> string<\/span>? GetNicknameOrDefault()\n    {\n        return<\/span> Nickname ?? \"No nickname\"<\/span>;\n    }\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
    In this API, Name<\/code> is a non-nullable property, indicating that every User<\/code> must have a name. However, Nickname<\/code> is nullable, reflecting the fact that a user might not have a nickname.<\/p>\n\n\n\n
    This approach makes the API safer and easier to use, as developers can see immediately whether they need to handle potential null<\/code> values.<\/p>\n\n\n\n
    Best Practices for Nullable Reference Types<\/h2>\n\n\n\n
    Nullable reference types are a powerful tool, but they can also introduce complexity if not used carefully. Here are some best practices to follow when working with nullable reference types in your codebase:<\/p>\n\n\n\n
    1. Enable Nullable Reference Types Gradually<\/h4>\n\n\n\n
    If you’re working with an existing codebase, enable nullable reference types gradually rather than all at once. This allows you to avoid overwhelming your project with warnings and errors and gives you time to refactor your code to handle null<\/code> values correctly.<\/p>\n\n\n\n
    2. Use Nullable Reference Types to Express Intent<\/h4>\n\n\n\n
    When designing new APIs or methods, use nullable reference types to clearly express your intent. If a parameter or return value can be null<\/code>, mark it as nullable. If not, make it non-nullable. This clarity helps other developers (and yourself!) avoid potential null reference exceptions.<\/p>\n\n\n\n
    3. Always Handle Nullable Values<\/h4>\n\n\n\n
    Whenever you’re working with a nullable reference type, be sure to handle the null<\/code> case appropriately. Use null checks, the null-conditional operator (?.<\/code>), or pattern matching to handle nullable values safely.<\/p>\n\n\n
    #nullable enable<\/span>\n\nstring<\/span>? nullableString = GetString();\n\nif<\/span> (nullableString is<\/span> not null<\/span>)\n{\n    Console.WriteLine(nullableString.Length); \/\/ Safe access<\/span>\n}\nelse<\/span>\n{\n    Console.WriteLine(\"String is null\"<\/span>);\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
    4. Avoid Overusing the Null Forgiving Operator<\/h4>\n\n\n\n
    The null-forgiving operator (!<\/code>) can be useful in certain situations, but it should be used sparingly. Overusing !<\/code> defeats the purpose of nullable reference types, as it disables the safety mechanisms designed to protect your code from null reference exceptions.<\/p>\n\n\n\n
    5. Refactor Existing Code to Add Nullability Annotations<\/h4>\n\n\n\n
    Over time, consider refactoring your existing codebase to add nullability annotations. This process can be time-consuming, but it helps make your code more robust and easier to maintain in the long run.<\/p>\n\n\n\n
    Conclusion<\/h2>\n\n\n\n
    Nullable reference types in C# 8.0 and beyond are a powerful feature that helps developers write safer, more robust code by reducing the risk of null reference exceptions. By enabling nullable reference types, you can make your codebase clearer and more explicit about nullability, leading to fewer runtime errors and improved code quality.<\/p>\n\n\n\n
    In this tutorial, we\u2019ve covered the key concepts of nullable reference types, including how to enable them, the difference between nullable and non-nullable types, how to handle nullable values safely, and best practices for using this feature effectively.<\/p>\n\n\n\n
    By following these guidelines and using nullable reference types thoughtfully, you can improve your code’s null safety and create more reliable and maintainable applications in C#. <\/p>\n","protected":false},"excerpt":{"rendered":"
    Nullable reference types are one of the significant new features introduced in C# 8.0. The goal is to help developers avoid the most common and frustrating issues in C# development: null reference exceptions, often referred to as the “billion-dollar mistake.” Before C# 8.0, all reference types were implicitly nullable, meaning that any reference type variable […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_genesis_hide_title":false,"_genesis_hide_breadcrumbs":false,"_genesis_hide_singular_image":false,"_genesis_hide_footer_widgets":false,"_genesis_custom_body_class":"","_genesis_custom_post_class":"","_genesis_layout":"","_jetpack_memberships_contains_paid_content":false,"footnotes":""},"categories":[8,4],"tags":[],"class_list":["post-2190","post","type-post","status-publish","format-standard","category-csharp","category-programming-languages","entry"],"yoast_head":"\nHow to Work with Nullable Reference Types in C# 8.0+<\/title>\n<meta name=\"description\" content=\"Nullable reference types are one of the significant new features introduced in C# 8.0. The goal is to help developers avoid the most common\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.w3computing.com\/articles\/how-to-work-with-nullable-reference-types-in-c-8-0\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"How to Work with Nullable Reference Types in C# 8.0+\" \/>\n<meta property=\"og:description\" content=\"Nullable reference types are one of the significant new features introduced in C# 8.0. The goal is to help developers avoid the most common\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.w3computing.com\/articles\/how-to-work-with-nullable-reference-types-in-c-8-0\/\" \/>\n<meta property=\"article:published_time\" content=\"2024-10-18T10:26:18+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2024-10-18T10:26:22+00:00\" \/>\n<meta name=\"author\" content=\"w3compadmin\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"w3compadmin\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"8 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"TechArticle\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/how-to-work-with-nullable-reference-types-in-c-8-0\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/how-to-work-with-nullable-reference-types-in-c-8-0\\\/\"},\"author\":{\"name\":\"w3compadmin\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\"},\"headline\":\"How to Work with Nullable Reference Types in C# 8.0+\",\"datePublished\":\"2024-10-18T10:26:18+00:00\",\"dateModified\":\"2024-10-18T10:26:22+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/how-to-work-with-nullable-reference-types-in-c-8-0\\\/\"},\"wordCount\":1697,\"articleSection\":[\"C#\",\"Programming Languages\"],\"inLanguage\":\"en-US\"},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/how-to-work-with-nullable-reference-types-in-c-8-0\\\/\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/how-to-work-with-nullable-reference-types-in-c-8-0\\\/\",\"name\":\"How to Work with Nullable Reference Types in C# 8.0+\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#website\"},\"datePublished\":\"2024-10-18T10:26:18+00:00\",\"dateModified\":\"2024-10-18T10:26:22+00:00\",\"author\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\"},\"description\":\"Nullable reference types are one of the significant new features introduced in C# 8.0. The goal is to help developers avoid the most common\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/how-to-work-with-nullable-reference-types-in-c-8-0\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/how-to-work-with-nullable-reference-types-in-c-8-0\\\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/how-to-work-with-nullable-reference-types-in-c-8-0\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Articles Home\",\"item\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Programming Languages\",\"item\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/programming-languages\\\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"How to Work with Nullable Reference Types in C# 8.0+\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#website\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/\",\"name\":\"Developer Articles Hub\",\"description\":\"\",\"alternateName\":\"Developer Articles\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\",\"name\":\"w3compadmin\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780747165\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780747165\",\"contentUrl\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780747165\",\"caption\":\"w3compadmin\"},\"sameAs\":[\"http:\\\/\\\/w3computing.com\\\/articles\"]}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"How to Work with Nullable Reference Types in C# 8.0+","description":"Nullable reference types are one of the significant new features introduced in C# 8.0. The goal is to help developers avoid the most common","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.w3computing.com\/articles\/how-to-work-with-nullable-reference-types-in-c-8-0\/","og_locale":"en_US","og_type":"article","og_title":"How to Work with Nullable Reference Types in C# 8.0+","og_description":"Nullable reference types are one of the significant new features introduced in C# 8.0. The goal is to help developers avoid the most common","og_url":"https:\/\/www.w3computing.com\/articles\/how-to-work-with-nullable-reference-types-in-c-8-0\/","article_published_time":"2024-10-18T10:26:18+00:00","article_modified_time":"2024-10-18T10:26:22+00:00","author":"w3compadmin","twitter_card":"summary_large_image","twitter_misc":{"Written by":"w3compadmin","Est. reading time":"8 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"TechArticle","@id":"https:\/\/www.w3computing.com\/articles\/how-to-work-with-nullable-reference-types-in-c-8-0\/#article","isPartOf":{"@id":"https:\/\/www.w3computing.com\/articles\/how-to-work-with-nullable-reference-types-in-c-8-0\/"},"author":{"name":"w3compadmin","@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561"},"headline":"How to Work with Nullable Reference Types in C# 8.0+","datePublished":"2024-10-18T10:26:18+00:00","dateModified":"2024-10-18T10:26:22+00:00","mainEntityOfPage":{"@id":"https:\/\/www.w3computing.com\/articles\/how-to-work-with-nullable-reference-types-in-c-8-0\/"},"wordCount":1697,"articleSection":["C#","Programming Languages"],"inLanguage":"en-US"},{"@type":"WebPage","@id":"https:\/\/www.w3computing.com\/articles\/how-to-work-with-nullable-reference-types-in-c-8-0\/","url":"https:\/\/www.w3computing.com\/articles\/how-to-work-with-nullable-reference-types-in-c-8-0\/","name":"How to Work with Nullable Reference Types in C# 8.0+","isPartOf":{"@id":"https:\/\/www.w3computing.com\/articles\/#website"},"datePublished":"2024-10-18T10:26:18+00:00","dateModified":"2024-10-18T10:26:22+00:00","author":{"@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561"},"description":"Nullable reference types are one of the significant new features introduced in C# 8.0. The goal is to help developers avoid the most common","breadcrumb":{"@id":"https:\/\/www.w3computing.com\/articles\/how-to-work-with-nullable-reference-types-in-c-8-0\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.w3computing.com\/articles\/how-to-work-with-nullable-reference-types-in-c-8-0\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/www.w3computing.com\/articles\/how-to-work-with-nullable-reference-types-in-c-8-0\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Articles Home","item":"https:\/\/www.w3computing.com\/articles\/"},{"@type":"ListItem","position":2,"name":"Programming Languages","item":"https:\/\/www.w3computing.com\/articles\/programming-languages\/"},{"@type":"ListItem","position":3,"name":"How to Work with Nullable Reference Types in C# 8.0+"}]},{"@type":"WebSite","@id":"https:\/\/www.w3computing.com\/articles\/#website","url":"https:\/\/www.w3computing.com\/articles\/","name":"Developer Articles Hub","description":"","alternateName":"Developer Articles","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.w3computing.com\/articles\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Person","@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561","name":"w3compadmin","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780747165","url":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780747165","contentUrl":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780747165","caption":"w3compadmin"},"sameAs":["http:\/\/w3computing.com\/articles"]}]}},"featured_image_src":null,"featured_image_src_square":null,"author_info":{"display_name":"w3compadmin","author_link":"https:\/\/www.w3computing.com\/articles\/author\/w3compadmin\/"},"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"_links":{"self":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/2190","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/comments?post=2190"}],"version-history":[{"count":2,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/2190\/revisions"}],"predecessor-version":[{"id":2192,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/2190\/revisions\/2192"}],"wp:attachment":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/media?parent=2190"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/categories?post=2190"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/tags?post=2190"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}