Início / coding / Perguntas / 79488133
Accepted
Bob
Asked: 2025-03-06 10:51:14 +0800 CST

Posso verificar se há nulos em várias variáveis ​​de uma só vez sem disparar avisos de nulidade?

  • 772

Estou tentando validar vários parâmetros de configuração, idealmente relatando todos os problemas em uma única passagem. Isso assume um formato semelhante a:

var isValid = true;
if (arg1 == null)
{
    // logger.LogError...
    isValid = false;
}
if (arg2 == null)
{
    // logger.LogError...
    isValid = false;
}
if (!isValid)
{
    return;
}

arg1.DoSomething(); // possible null warning

Agora, se eu abortar individualmente quando um único argumento for nulo, não há problema: a análise nula detecta com sucesso que isso foi verificado e não precisa avisar. Infelizmente, isso significa que não posso relatar vários erros de uma vez, e o usuário precisará fazer vários ciclos de edição-execução para resolver todos os problemas.

Alternativamente, posso ignorar forçosamente avisos nulos com o operador null-forgiving ( !). Mas isso me deixa vulnerável a realmente esquecer uma verificação nula ou remover uma acidentalmente mais tarde.

Posso ter meu bolo e comê-lo também? Existe um padrão mais organizado para fazer validação de múltiplos argumentos sem sacrificar a análise de nulidade?

Exemplo completo:

using System;

#nullable enable

public class Program
{
    public static void Main()
    {       
        Warning();
        NoWarning();
    }
    
    public static void Warning()
    {
        string? canBeNull = Random.Shared.Next(2) == 1 ? "not-null" : null;
        string? canBeNull2 = Random.Shared.Next(2) == 1 ? "not-null" : null;
        
        var isValid = true;
        
        if (canBeNull == null)
            isValid = false;
        
        if (canBeNull2 == null)
            isValid = false;
        
        if (!isValid)
            return;
        
        Console.WriteLine(canBeNull.Length);
    }
    
    public static void NoWarning()
    {
        string? canBeNull = Random.Shared.Next(2) == 1 ? "not-null" : null;
        string? canBeNull2 = Random.Shared.Next(2) == 1 ? "not-null" : null;
        
        if (canBeNull == null)
            return;
        
        if (canBeNull2 == null)
            return;
        
        Console.WriteLine(canBeNull.Length);
    }
}
c#

2 respostas

  1. Best Answer

    Você pode usar um método validador auxiliar que verifica todas as coisas e consolida as mensagens de erro, com atributos [NotNullWhen] aplicados a cada parâmetro.

    public class UserValidator(ILogger logger)
{
    public void ValidateUser(string? name, string? role)
    {
        if (!IsValid(name, role))
        {
            return;
        }

        Console.WriteLine(name.ToLower()); // no null warning;
                                           // method returned true,
                                           // so all params are not null
    }

    public bool IsValid(
        [NotNullWhen(true)] string? name,
        [NotNullWhen(true)] string? role)
    {
        bool isValid = true;

        if (name is null)
        {
            logger.LogError("Name was null");
            isValid = false;
        }

        if (role is null)
        {
            logger.LogError("Role was null");
            isValid = false;
        }

        return isValid;
    }
}
    • 4

  2. Não está realmente resolvendo o problema "na hora", eu consideraria isso mais como uma "solução alternativa" - apenas como um aviso.

    Se você tiver um método como este:

    bool IsNotNull ( string? candidate, out string notNullCandidate )
{
    notNullCandidate = candidate ?? "";
    return candidate is not null;
}

    então você verifica o candidato anulável e se ele for aprovado, usa a saída não anulável.

    Atenção: isso também funcionará como um método estático, mas, pelo que sei, não como um método de extensão (por causa da palavra-chave out).

    • 1

relate perguntas