Why doesn't C# null check work with structs?

Question

I usually check nullable types with if (foo is not null), and afterwards I can use foo like the non-null type. Why doesn't this work with structs? Even the ! operator does not help. Is this a bug or am I missing something? What's the shortest workaround?

Foo? foo = new Foo { a = "foo" }; 
if (foo is not null) {
    Console.WriteLine(foo.a);  // Works, prints "foo"
}

Bar? bar = new Bar { a = "bar" };
if (bar is not null) {
    Console.WriteLine(bar.a);  // Error: Bar? does not contain a definition for "a"
    Console.WriteLine(bar!.a); // Same error
}

class Foo {
    public string a;
}
struct Bar {
    public string a;
}

Because a nullable struct is of type Nullable<T> which is completely different from a nullable reference type. You have to use .Value to access the value of a nullable struct. — Matthew Watson
– Matthew Watson, Commented Jun 29, 2022 at 8:32
What works in both cases is pattern matching: if (foo is Foo notNullFoo) Console.WriteLine(notNullFoo.a). — Jeroen Mostert
– Jeroen Mostert, Commented Jun 29, 2022 at 8:34
And if repeating the type name seems undesirable, {} can be used instead: if (bar is {} notNullBar) Console.WriteLine(notNullBar.a). Eliminating notNullBar can only be done at the cost of exposing the structural differences between nullable reference types and nullable value types. — Jeroen Mostert
– Jeroen Mostert, Commented Jun 29, 2022 at 8:43

Heinzi · Accepted Answer · 2022-06-29 08:50:42Z

4

Backwards-compatibility.

Nullable value types exist since C# 2.0, and they are implemented differently than nullable reference types (since C# 8.0).

int? is a synonym for Nullable<int>, which is a completely different type than int. There is some compiler magic (lifted operators) to make it behave similarly, but Nullable<int> has members that int doesn't have (HasValue, Value) and vice-versa (ToString(string)).
string? on the other hand, is of type string, with additional compile-time checks enabled.

Making a null-check on int? allow you to access the underlying int without "unwrapping" it with .Value would have broken tons of existing code.

You can, however, use pattern matching to create a new variable with the underlying type:

int? a = 3;      // implicit conversion from int to Nullable<int>

if (a is int b)
{
    // Use b to access the underlying int here.
}
else
{
    // a was null
}

edited Jun 29, 2022 at 8:50

answered Jun 29, 2022 at 8:44

Heinzi

173k61 gold badges386 silver badges554 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

crankedrelic · Accepted Answer · 2022-06-29 08:45:04Z

2

Structs are value types and cannot be assigned to null. By declaring the struct as nullable you wrap them in a Nullable<T> struct. You should check the HasValue and Value property of the Nullable<Bar> struct in you case.

        Bar? bar = new Bar { a = "bar" };
        if (bar.HasValue)
        {
            Console.WriteLine(bar.Value.a);
            Console.WriteLine(bar.Value.a);
        }

edited Jun 29, 2022 at 8:45

answered Jun 29, 2022 at 8:34

crankedrelic

4731 gold badge6 silver badges15 bronze badges

Comments

Sasan · Accepted Answer · 2022-06-29 08:34:06Z

1

A struct is a value type so it's never null. You can check the default value for struct

answered Jun 29, 2022 at 8:34

Sasan

216 bronze badges

Collectives™ on Stack Overflow

Why doesn't C# null check work with structs?

3 Answers 3

Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related