NotNullAttribute and event in Nullable Reference Type context?

[datvm]

Consider a class that implement INotifyPropertyChanged:

public event PropertyChangedEventHandler? PropertyChanged = delegate { };

Without ? the compiler generates a warning ("Nullability of reference types in type of 'event ... PropertyChanged' doesn't match implicitly implemented member 'event PropertyChangedEventHandler? INotifyPropertyChanged.PropertyChanged'"). However now we have to decorate all event invoker with null-forgiving operator ! because we know it is never null. Normally [NotNull] is the solution but it doesn't applicable for events:

[NotNull] // Does not compile
public event PropertyChangedEventHandler? PropertyChanged = delegate { };

Did I miss something here? Should NotNullAttribute add Event as a valid target?

[Joe4evr]

However now we have to decorate all event invoker with null-forgiving operator ! because we know it is never null.

But do you really know? In the 99% case, you won't be certain that a consumer will subscribe to your event, and then it remains null. That's what NRTs are tuned to, so the diagnostics are correct.

Anyway, one alternative for you would be to wrap your event with

#nullable disable warnings
public event ....
#nullable restore

then you won't need the ! operator at your invocations.

[datvm]

That's why I have the = delegate { }. I never had a NullReferenceException from it even when no one subscribe to the event.

[FaustVX]

@datvm
= delegate { } is not recommended because if no-one subscribe to your event, you still invoke it.
The recommended way is to call it with null-conditionnal PropertyChanged?.Invoke(…)

[svick]

This is less about nullable reference types themselves and more about their interaction with inheritance. INotifyPropertyChanged.PropertyChanged is marked as nullable, so it makes sense to me that any implementation has to be marked as nullable as well.

And if you want to implement the nullable INotifyPropertyChanged.PropertyChanged, while having your non-nullable event, you can, like this:

private event PropertyChangedEventHandler propertChangedImpl = delegate {};

public event PropertyChangedEventHandler? PropertyChanged
{
    add => propertChangedImpl += value;
    remove => propertChangedImpl -= value;
}

Wait, what? If value can be null, how come using it to subscribe to a non-nullable event is allowed? It's not clear to me whether this is intentional behavior, or a bug in the compiler.

If it's intentional, maybe INotifyPropertyChanged.PropertyChanged should be changed to be non-nullable, so that implementation like yours become allowed?