Usando C# 8+ con contexto anulable habilitado, tengo un método que devuelve

1. Una enumeración que representa varios códigos de error o éxito;
2. Un objeto (si es exitoso) o nulo (si es un error)

como ValueTuple. Además del operador que perdona nulos , ¿hay alguna manera de decirle al compilador que el objeto no es nulo si el valor de enumeración indica éxito?

 private (EnumResult, SomeClass?) DoThing(...) { if (...) return (EnumResult.Error1, null); if (...) return (EnumResult.Error2, null); return (EnumResult.Success, new SomeClass(...)); }

 (EnumResult result, SomeClass? someClass) = DoThing(...); if (result == EnumResult.Success) { // `someClass` should not be null here, but the compiler doesn't know that. }

Soy consciente de que hay atributos de análisis estáticos anulables que se pueden aplicar cuando se usa un retorno bool y un parámetro out :

 private bool TryDoThing(..., [NotNullWhen(true)] out SomeClass? someClass) { if (...) { someClass = null; return false; } someClass = new SomeClass(...); return true; }

 if (TryDoThing(..., out SomeClass someClass)) { // The compiler knows that `someClass` is not null here. }

Pero no pude determinar cómo aplicar algo similar al devolver un ValueTuple.

Estoy usando una enumeración en lugar de un bool o lanzando excepciones porque el código de resultado se comunica a través de una canalización con nombre , donde el proceso en el otro lado lo analiza nuevamente en una enumeración y luego reacciona de acuerdo con el error específico. Estoy usando un ValueTuple en lugar de un parámetro de out por preferencia personal.