nullable reference type covariance

[bbarry]

#nullable enable
public class Bar {
  public void Foo(IDictionary<string, Bar?> lookup) {
   //...
  }
  public void Test(IList<Bar> someList) {
    var lookup = someList.ToDictionary(x => x.Id);
    Foo(lookup); // CS8620
  }
}

This sucks. Clearly Bar is also Bar? and this should just work.

Instead the best solution I've come up with is:

    public static class IgnoreNullableWarning
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static IDictionary<string, T?> FixNullable<T>(this IDictionary<string, T> input)
            where T: class
        {
#nullable disable
            return input;
#nullable enable
        }
    }

Other alternatives:

var lookup = someList.ToDictionary<Bar?, string>(x => x!.Id);

#nullable disable
Foo(lookup);
#nullable enable

Is the ToDictionary<>() extension method deficient in its nullable type annotations somehow? Or maybe the IDictionary<> type? Or is this an unfortunate result of the IDictionary type not being covariant (does covariance mean anything for NRT even if IDictionary was)?

[svick]

I think that's exactly the right behavior. Consider this modification to your code:

public void Foo(IDictionary<string, Bar?> lookup) {
   lookup.Add("foo", null);
}

Now in Test, you have Dictionary<string, Bar> which can give you null Bar, so there should be a warning somewhere and I think where the compiler puts it now is the right place for it.

Also, instead of all those #nullable disable/enable, you can just use !.

[333fred]

Adding onto this, when variance is allowed, we do the thing you'd expect. An IEnumerable<object> is convertible to IEnumerable<object?>, as you'd expect, because the T there is marked out.

[bbarry]

@sick You can't use ! in this case because it isn't changing the second generic argument but instead the type as a whole.

@333fred yeah it seems to be a case of IDictionary<T, V> != IReadOnlyDictionary<in T, out V>

[svick]

@bbarry As I understand it, ! doesn't change the type, it silences warnings. And indeed it works for me.

Also, keep in mind that even IReadOnlyDictionary is not variant. (I believe it's because KeyValuePair can't be variant.)

[bbarry]

I apologize, yesterday I couldn't get that ! to work. Today my code seems fine with it.

[YairHalberstadt]

What might be useful here is target typed Nullable inference

[jnm2]

Other options:

((IEnumerable<Bar?>)someList).ToDictionary(x => x!.Id);
someList.AsEnumerable<Bar?>().ToDictionary(x => x!.Id);
someList.ToDictionary(x => x.Id, x => (Bar?)x);