Is there a better way to deal with nullable return that depends on another value?

Question

I have a method that returns a tuple (MyEnum, MyObject?). There is one and only one enum value that means MyObject is not null - all the others mean MyObject will be null (and the string will have a message).

Something along the lines of

(MyEnum response, Package? package) MyMethod()
{
    if (Today == NiceDay)
    {
        return (MyEnum.Happy, new Package("I'm happy!"));
    }
    if (Today == RainyDay)
    {
        return (MyEnum.Pensive, null);
    }
    if (Today == SnowyDay)
    {
        return (MyEnum.Cold, null);
    }
}

Obviously, if I try and use MyMethod().package.message, the compiler will warn me about the possibility of a null reference. I'm aware of the null-forgiving operator, but that kind of feels like a quick-fix.

Is there a way to "tell" the compiler to expect a value when MyMethod().response is MyEnum.Happy, and null when it is any other value, or is the null-forgiving operator the correct and expected way to deal with this situation?

I'm confused. You talk about a tuple: `(string, MyEnum, MyObject?)`, but none of your code has the `string` part of the tuple (the first member). In the one case where you have a non-null last member of the tuple, it's a `Package` instance, not a `MyObject` instance — Flydog57, Dec 21 '22 at 21:30
It's not the compiler warning you, it's the intellisense of whatever IDE you're using that is telling you that. The intended way to suppress these warnings *is* the null-forgiving operator. However, there are other ways. [Here's an answer going over one of them](https://stackoverflow.com/a/61425855/10601203). — Jesse, Dec 21 '22 at 21:31
@Jesse _"It's not the compiler warning you"_ - it actually is compiler, `dotnet build` will result in the same warnings though no IDE is involved. — Guru Stron, Dec 21 '22 at 21:43
Depending on context, one option might be to replace the tuple or enum and package with a polymorphic record type: https://spencerfarley.com/2021/03/26/unions-in-csharp/, and then use pattern matching. — user1937198, Dec 21 '22 at 22:17
The "string" member of the tuple was just a remainder of the actual code, and had no effect on the understanding of the questions root issue. As for @Jesse's solution, it works, but Guru's answer below fits better the situation. Thanks for all your help! — Artur S., Dec 22 '22 at 12:49

Guru Stron · Accepted Answer · 2022-12-22T13:08:38.857

Currently attributes for null-state static analysis interpreted by the C# compiler do not support neither specifying nullability of selected properties of returned value nor scenario when specific constant/enum value can be tied to nullability of parameters (except bool constants). The closest thing which can be done - return boolean value and tie out parameter to the return:

bool MyMethod(out MyEnum response, [NotNullWhen(true)] out Package? package)
{
    string Today = "";
    response = MyEnum.Happy;
    package = new Package("");
    return true;
}

Usage:

if(MyMethod(out _, out var packageValue))
{
    Console.WriteLine(packageValue.ToString()); // no warning
}

score 2 · Answer 2 · answered Dec 21 '22 at 22:09

So there are many ways to handle null/null warnings.

First If you are 100% sure that the value cannot be null here you can use ! operator something like this package!.Message

Second If You are not sure and there is only one condition in which the value can not be null its better to use the ternary operator like this var result = MyMethod().response == MyEnum.Happy ? MyMethod().package.message : string.Empty;

Third you can use ?? operator like this var message = MyMethod().package?.message ?? "No message found"; or empty string according to your use case.

score 0 · Answer 3 · answered Dec 21 '22 at 22:34

As a suggestion to resolve the issue, instead of the null have a static property in the Package class that defines an empty package:

class Package {
    public static Package None => new Package { Message = "No package." };
}

In your code make the return for Package non-nullable and use

   return (MyEnum.Pensive, Package.None);

Is there a better way to deal with nullable return that depends on another value?

3 Answers3