Allow opt in to usage of ?. and ?? for default structs

[YairHalberstadt]

I'm currently converting some code from using Arrays to ImmutableArrays, and one thing that is really bothering me is the poor story around default ImmutableArrays.

A default ImmutableArray is for all intents and purposes null - any attempt to access a member will throw a NullReferenceException. However, it's not technically null, and so all the language tools built around nullability, such as the ?? and ?. operators don't work. Instead you have to check IsDefault.

This can often lead to a serious uglification of code. For example, consider how this code originally looked using arrays:

public class C
{
    public string[] Strings {get; set;}
}
...
C c = GetC();
var str = c?.Strings?.FirstOrDefault();

And how it looks once Strings is converted to an ImmutableArray:

public class C
{
    public ImmutableArray<string> Strings {get; set;}
}
...
C c = GetC();
var strs = c?.Strings ?? default;
var str = strs.IsDefault ? null : strs.FirstOrDefault();

Significantly noisier.

Multiply that by a hundred different locations, and a hundred unnecessary temporary variables added, and I'm seriously starting to wonder whether the benefit of using immutable types is worth the loss in clarity that ensues.

Proposed Solution

Allow indicating that default for a struct should be treated as a pseudo-null case.

This could be done by an attribute, a new keyword, or a pattern such as an IsDefault property.

When this is done, ?? and ?. should be valid on such a struct. ?? becomes the default coalescing operator, and ?. remains the safe navigation operator, but checks for default not just null.

This could be done either by using .Equals, or by generating a method that checks if the struct is in a default state.

Then ImmutableArray could be marked as such a struct, and we can continue using ?. and ?? as before.

[CyrusNajmabadi]

A default ImmutableArray is for all intents and purposes null - any attempt to access a member will throw a NullReferenceException.

This is definitely not true. Even ignoring members like IsDefault (something very 'null'-oriented) there are members like Clear or OfType that will not throw. Then there are the overriden Object members (like GetHashCode or Equals) that don't throw either.

[CyrusNajmabadi]

or a pattern such as an IsDefault property.

I like this idea.

[benaadams]

Its the same isn't it?

class C
{
    public ImmutableArray<string> Strings { get; set; }

    static void Main(string[] args)
    {
        C c = null;

        var str = c?.Strings.FirstOrDefault();

        Console.WriteLine(str == null); // outputs true
    }
}

[benaadams]

Oh less one ? e.g.

var str = c?.Strings?.FirstOrDefault(); // string[]

To

var str = c?.Strings.FirstOrDefault(); // ImmutableArray<string>

[YairHalberstadt]

This is definitely not true. Even ignoring members like IsDefault (something very 'null'-oriented) there are members like Clear or OfType that will not throw. Then there are the overriden Object members (like GetHashCode or Equals) that don't throw either.

That's true. But == null will be true, so it lives in a sort of quasi null state.

[benaadams]

Ah, gotcha

static void Main(string[] args)
{
    C c = null;

    var str = c?.Strings.FirstOrDefault();

    Console.WriteLine(str == null); // true

    c = new C();

    str = c?.Strings.FirstOrDefault(); // null ref

    Console.WriteLine(str == null);
}

Surely a bug in FirstOrDefault?

[YairHalberstadt]

Nope. It's by design. A default ImmutableArray throws when you try and enumerate it.

[benaadams]

That's just throwing half the advantage of it being a struct away (don't worry about null)

[CyrusNajmabadi]

ImmutableArray isn't a struct so that it can be non-null. It's a struct so that it can enforce, with nearly no overhead (either memory or CPU), that the array is actually immutable. It's meant to represent what an array can represent. And arrays can be null, and so ImmutableArray needs to be able to represent htat as well (without costing anything).

[MkazemAkhgary]

I had this problem as well. the only reliable solution is to use IsDefault.

It's weird decision because they made a dedicated set of Linq methods for ImmutableArray in ImmutableArrayExtensions and that throws exception :/

One solution would be

public static class ImmutableExtensions<T>
{
    private static readonly ImmutableArray<T> EmptyArray = new T[0].ToImmutableArray();
    
    public static ImmutableArray<T> NotDefault(this ImmutableArray<T> x) => x.IsDefault ? EmptyArray : x;
}

[ufcpp]

#147 ?

[YairHalberstadt]

@ufcpp
I think this is a slightly simplified version of that proposal. For example, under this proposal the only null value is default, and the ?. operator will always just propogate default.

[scalablecory]

There are a handful of places that default could reasonably read as null, so I like this idea.

I would not enforce memberwise comparisons, though -- this will be wasteful because largely you will only be inspecting a single member rather than all members. For this reason I'd support the idea of patterns, allowing the "nullness" check to be optimized according to the type.

[GalaxiaGuy]

#2020 Proposal: Allow null conditional (?.) and null coalescing ()?? operators to be overloaded

Although it seems all roads lead to #147.

[YairHalberstadt]

@GalaxiaGuy
That's very different. That's operator overloading, which IMO is really horrible in cases like this. It makes it impossible to reason about what is happening when you see ?., Whereas here it's trivial. It means if the value is default, evaluate to null, whether the value is a struct or a class.

#147 is most similar, but a bit over engineered IMO.

[ufcpp]

#146 ?

[YairHalberstadt]

I suggested something similar to that as well: #2019

The issue is the boat has already sailed on this one. Its too late to make ImmutableArray non-defaultable.

Also this should be significantly cheaper to implement.

[ufcpp]

Roles could solve this issue?
Maybe thin wrappers including ImmutableArray should be supported by the .NET type system instead of C# syntax suger or structs.

[YairHalberstadt]

@ufcpp
Could you give more details as to how please?

[ufcpp]

ImmutableArray<int> a = (int[])null;
object obj = a;

obj is a boxed instance if ImmutableArray is a struct wrapper, but would be null if it were a role.

[YairHalberstadt]

A role would not be truly immutable as you could change the underlying array.