C# - Tratando alertas como erros

Você já pensou em tratar os alertas ou warnings do seu código como erros ?

Vamos estabelecer um ponto de partida definindo (sem entrar muito a fundo) o que são alertas e o que são erros.

Erros de Compilação

O que são erros ?  Bem existem diversos tipos de erros como erros de sintaxe, erros de lógica, erros de runtime, etc.  Então vamos considerar, no contexto deste artigo, erros como sendo erros de compilação.

Observe o exemplo de código a seguir:

Colocando o mouse sobre o texto 'numero' vemos que o Visual Studio emite a mensagem “Não é possível converter implicitamente o tipo 'string' para 'int'”, que é exatamente a mesma mensagem de erro que é exibida na janela de erros.

Isso acontece, porque estou tentando atribuir uma string literal a uma variável do tipo int, o que não é permitido, pois esses tipos são completamente diferentes um do outro e não há conversão implícita declarada.

Então, é exatamente assim que um erro de compilador se resume. O compilador está me informando que o código que escrevi não faz sentido. Ele tenta fazer algo totalmente em desacordo com a sintaxe e/ou semântica da linguagem C#.

Alertas de Compilação

Vamos considerar agora o código a seguir:

    class Program
    {
        static void ExibirMes(int mes)
        {
            if (mes != null)
                Console.WriteLine(new CultureInfo("pt-br").DateTimeFormat.GetMonthName(mes));
                Console.WriteLine(new CultureInfo("ent-us").DateTimeFormat.GetMonthName(mes));
        }

        static void Main(string[] args)
        {
            ExibirMes(1);
            Console.ReadLine();
        }
    }

Aqui estamos exibindo o nome do mês em português e em inglês passando um inteiro referente ao mês do ano.

Se você executar esse código ele vai funcionar.

Mas vamos olhar este código no Visual Studio 2019:

Observe que temos um alerta do compilador que nos diz o seguinte:

The result of the expression is always ‘true’ since a value of type ‘int’ is never equal to ‘null’ of type ‘int?’

Existe algo errado mas ao mesmo tempo parece que o problema não é tão sério pois o Visual Studio vai compilar o projeto e exibir o resultado:

A mensagem de aviso está me dizendo que a instrução “if” é desnecessária, pois um valor do tipo int nunca pode ser nulo. Em outras palavras, o código acima não faz sentido, mas de uma maneira mais benigna do que antes.

Assim o compilador usado pelo Visual Studio pode produzir erros quando o código não pode ser criado e avisos quando a compilação é concluída com êxito, mas existe algo que não foi feito de forma correta mas não vai afetar a execução do código.

Existem cenários onde os avisos podem indicar problemas que poderão ocorrer em outras partes do código.

Para evitar que avisos sejam perdidos ou ignorados, existe uma opção para tratá-los como erros.

Mas porque tratar avisos como erros ?

Como já vimos o compilador pode produzir avisos que não causam falha na compilação, mas que podem apontar para problemas que exigem resolução para evitar que seus programas se comportem inesperadamente.

Veja este exemplo:

            while (valorBoolean = true)
            {
                Console.WriteLine("teste");
                valorBoolean = false;
            }
            Console.ReadLine();

À primeira vista, esse código parece fornecer um loop while que é executado enquanto a variável valorBoolean está definida como true.

À medida que o valor da variável se torna false na primeira iteração, você pode esperar que o loop seja executado no máximo uma vez.

No entanto, temos aqui um loop infinito porque o programador acidentalmente usou o operador de atribuição (=) em vez do operador de igualdade (==).

Na primeira linha, o valor valorBoolean é definido como true, não comparado com ele. Como tal, a condição será avaliada como verdadeira e o loop continuará para sempre.

Esse é um tipo de situação mais comum do que podemos imaginar.

E o compilador faz o seu papel detectando o problema em potencial e mostrando o aviso "A atribuição na expressão condicional é sempre constante; você quis usar == em vez de =?".

Infelizmente, pode ser fácil perder esse aviso e liberar o programa com um bug.

Uma opção para garantir que esse tipo de erro não possa ser cometido é tratar todos os avisos em um projeto como erros. Com esta opção ativa, qualquer aviso é atualizado para um erro e causa falha na compilação.

Tratando avisos como erros

O compilador não verdade não faz parte do Visual Studio. Ele é um programa separado que pode ser usado na linha de comando e pode ser instruído a tratar avisos como erros usando uma opção de linha de comando.

No entanto, quando você está usando o Visual Studio ou uma das versões gratuitas, como a edição do C# , o ambiente de desenvolvimento integrado (IDE) inclui uma interface gráfica para habilitar a opção.

Com o seu projeto aberto no VS 2019 abra a janela de propriedades do projeto e clique na guia Build:



Vamos destacar duas áreas nesta opção destacadas na figura acima:

  1. Errors and warnings
  2. Treat warnings as errors

Na primeira temos o nível de aviso que você deseja exibir para a compilação: Números mais baixos mostram apenas avisos de severidade alta; números mais altos mostram mais avisos. Os valores válidos são de 0 a 4:

Nível do Aviso Significado
0 Desativa a emissão de todas as mensagens de avisos
1 Exibe mensagens de aviso severas
2 Exibe avisos de nível 1, além de certos avisos menos severos, como avisos sobre a ocultação de membros;
3 Exibe avisos de nível 2, além de certos avisos menos graves, como avisos sobre expressões que sempre são avaliadas como verdadeiras ou falsas.
4 Exibe todos os avisos de nível 3, além de avisos informativos. (valor padrão)

Na linha de comando você usamos a opção -warn o código :  

csc -warn:1 teste.cs
csc -nowarn:28 teste.cs

Note que na opção Supress warnings podemos definir uma lista de aviso que desejamos suprimir.

Na segunda janela temos marcar a opção All para tratar todos os avisos como erros:

Nota:  Para obter o mesmo efeito via linha de comando usamos a opção warnaserror : csc -warnaserror teste.cs

Se você abrir o seu arquivo de projeto vai verificar a opção ativada:

Para testar você pode criar um método em qualquer classe em seu código e adicionar o atributo [Obsolete] e a seguir chamar este método de qualquer lugar do seu código.

Além das opções "None" e "All", você pode optar por tratar apenas avisos específicos como erros.

Isso é útil quando você deseja permitir a maioria dos avisos, mas não quando os avisos selecionados não são aceitáveis.

Para usar esta opção, selecione o botão de opção "Especific warnings:" e forneça uma lista separada por vírgula de números de aviso na caixa de texto.



Temos assim uma maneira de configurar como desejamos tratar avisos no ambiente de compilação da linguagem C#.

E estamos conversados...

"E a paz de Deus, que excede todo o entendimento, guardará os vossos corações e os vossos pensamentos em Cristo Jesus."
Filipenses 4:7

Referências:

José Carlos Macoratti