Suprimir violações da análise de código

  • Artigo

Se você colaborar com sua equipe ao criar código, geralmente é útil indicar que um aviso não é aplicável. Suprimir violações de Code Analysis indica para os membros da equipe que o código foi revisado e o aviso pode ser suprimido. As seções a seguir descrevem as diferentes maneiras de suprimir violações de análise de código usando o IDE do Visual Studio.

Suprimir violações usando o arquivo EditorConfig

No arquivo EditorConfig para sua solução ou projeto, adicione uma entrada para cada regra que você deseja configurar e defina sua gravidade como none. Por exemplo, dotnet_diagnostic.CA1822.severity = none. Para obter mais informações, confira Configurar manualmente a gravidade da regra em um arquivo EditorConfig. Para adicionar um arquivo EditorConfig, confira Adicionar um arquivo EditorConfig a um projeto.

Suprimir violações no código-fonte

Você pode suprimir violações em seu código-fonte usando uma diretiva de pré-processador, que suprime violações para uma linha de código específica:

Ou, você pode usar o atributo SuppressMessageAttribute para suprimir um aviso em seu código C# e Visual Basic.

Suprimir violações usando o editor de código

Para suprimir violações usando o editor de código, siga estas etapas:

  1. Coloque o cursor na linha de código com a violação e pressione Ctrl+Ponto (.) ou Alt+Enter para abrir o menu Ações rápidas.

  2. Selecione Suprimir ou configurar problemas>Suprimir <número da regra> e escolha na Origem ou na Origem (atributo).

    • Se você escolher na Origem, verá uma visualização da diretiva de pré-processador adicionada ao seu código.

      Captura de tela que mostra a seleção na Origem no menu Suprimir Ações Rápidas.

    • Se você escolher na Origem (atributo), verá uma visualização do atributo SuppressMessageAttribute adicionado ao seu código.

      Captura de tela que mostra a seleção na Origem (atributo) no menu Suprimir Ações Rápidas.

Suprimir violações usando a Lista de Erros

Para suprimir violações usando a janela Lista de erros, siga estas etapas:

  1. Na janela Lista de Erros, selecione as regras que deseja suprimir.

  2. Clique com o botão direito do mouse e selecione Suprimir>na Origem.

    A caixa de diálogo Visualizar alterações é aberta e mostra uma visualização da diretiva de aviso #pragma do C# ou da diretiva de aviso #Desabilitar do Visual Basic adicionada ao código-fonte.

    Captura de tela que mostra a caixa de diálogo Visualizar alterações para adicionar avisos de #pragma ao arquivo no código.

  3. Selecione Aplicar para salvar as alterações em seu arquivo de código.

Excluir diagnóstico de build da Lista de erros

Se você não vir a opção de menu Suprimir na janela Lista de erros, é provável que a violação seja de um build e não de uma análise dinâmica. A janela Lista de erros exibe diagnósticos ou violações de regras, tanto da Code Analysis dinâmica quanto de builds. Como os diagnósticos de build podem ser obsoletos, por exemplo, se você editou o código para corrigir a violação, mas não recompilou, nem sempre é possível suprimir esses diagnósticos da Lista de erros.

Os diagnósticos da análise dinâmica ou do IntelliSense estão sempre atualizados com as fontes atuais e podem ser sempre suprimidos da Lista de Erros. Para excluir o diagnóstico de build de sua seleção, siga estas etapas:

  1. Na lista suspensa filtro de origem da Lista de Erros, altere a seleção de Build + IntelliSense para Somente IntelliSense.

    Captura de tela que mostra o filtro de origem Lista de erros.

  2. Selecione o diagnóstico que você deseja suprimir e prossiga conforme descrito anteriormente.

Suprimir violações usando um arquivo de supressão global

O arquivo de supressão global usa o atributo SuppressMessageAttribute para suprimir violações de código.

Usar um arquivo de supressão global do editor de código

Para suprimir violações com um arquivo de supressão global usando o editor de código, siga estas etapas:

  1. No editor de código, coloque o cursor em uma linha de código com uma violação e pressione Ctrl+Ponto (.) ou Alt+Enter para abrir o menu Ações rápidas.

  2. Selecione Suprimir <número da regra> e, em seguida, escolha no Arquivo de supressão.

    Visual Studio cria uma guia no editor de código que contém o novo arquivo de supressão global.

Usar um arquivo de supressão global da Lista de Erros

Para suprimir violações com um arquivo de supressão global usando a janela Lista de erros, siga estas etapas:

  1. Na janela Lista de Erros, selecione as regras que deseja suprimir.

  2. Clique com o botão direito do mouse e selecione Suprimir>no Arquivo de supressão.

    A caixa de diálogo Visualizar alterações é aberta e mostra uma visualização do atributo SuppressMessageAttribute adicionado ao arquivo de supressão global.

    Captura de tela que mostra a caixa de diálogo Visualizar alterações com um atributo SuppressMessageAttribute no arquivo de supressão.

  3. Selecione Aplicar para salvar o arquivo de supressão global.

Suprimir todas as violações atuais

A supressão de todas as violações atuais às vezes é chamada de criação de linha de base. Para suprimir todas as violações atuais em uma solução ou projeto, siga estas etapas:

  1. Na barra de menus do Visual Studio, selecione Analisar>Build e Suprimir problemas ativos.

  2. Selecione Para solução para suprimir violações para toda a solução ou selecione Para <nome do projeto> para suprimir violações somente para seu projeto.

Suprimir violações usando configurações de projeto

Para suprimir violações usando as configurações de projeto do Gerenciador de Soluções, siga estas etapas:

  1. No Gerenciador de Soluções, selecione seu projeto.

  2. Clique com o botão direito do mouse e selecione Propriedades (ou pressione Alt + Enter).

  3. Na janela Propriedades, selecione Code Analysis no painel esquerdo e desmarque Suprimir resultados do código gerado.

Suprimir violações usando um conjunto de regras

No editor do conjunto de regras, desmarque a caixa de seleção ao lado do nome ou defina Ação como Nenhuma.

Supressão na origem e o atributo SuppressMessageAttribute

A ISS (supressão na origem) usa o atributo SuppressMessageAttribute para suprimir um aviso. Você pode adicionar o atributo SuppressMessageAttribute ao arquivo de origem próximo ao segmento de código que gerou o aviso.

Você pode inserir o atributo manualmente no editor de código ou adicionar o atributo automaticamente da seguinte maneira:

  1. No editor de código, coloque o cursor em uma linha de código com uma violação e pressione Ctrl+Ponto (.) ou Alt+Enter para abrir o menu Ações rápidas.

  2. Selecione Suprimir ou configurar problemas>Suprimir <número da regra> no menu Ações rápidas.

  3. Execute uma das seguintes etapas:

    • Selecione na Origem (atributo).

      O Visual Studio adiciona um atributo SuppressMessageAttribute ao seu código.

    • Selecione no Arquivo de supressão.

      Visual Studio cria uma guia no editor de código que contém um novo arquivo de supressão global com atributos SuppressMessageAttribute.

O atributo SuppressMessageAttribute é um atributo condicional, que está incluído nos metadados de seu assembly de código gerenciado. Esse atributo é incluído somente se o símbolo de compilação CODE_ANALYSIS for definido no tempo de compilação.

Somente no código C++ e CLI, use as macros CA_SUPPRESS_MESSAGE ou CA_GLOBAL_SUPPRESS_MESSAGE no arquivo de cabeçalho para adicionar o atributo.

Se você migrar um projeto para a última versão do Visual Studio, pode ver um número grande de avisos de Code Analysis. Se você não estiver pronto para corrigir os avisos, poderá suprimir todos eles selecionando Analisar>Compilar e Suprimir Problemas Ativos.

Observação

Não use supressões no código-fonte em builds liberados, para evitar o envio acidental dos metadados de supressão no código-fonte.

Formato de atributo SuppressMessageAttribute

O atributo SuppressMessageAttribute tem o seguinte formato:

[Scope:SuppressMessage("Rule Category", "Rule Id", Justification = "Justification", MessageId = "MessageId", Scope = "Scope", Target = "Target")]

As propriedades do atributo incluem:

  • Category: a categoria da regra. Para obter mais informações sobre as categorias de regras de Code Analysis, confira Regras de qualidade de código.

  • CheckId: o identificador da regra. O suporte inclui um nome curto e longo para o identificador de regra. O nome curto é CAXXXX, o nome longo é CAXXXX:FriendlyTypeName.

  • Justification: o texto usado para documentar o motivo da supressão da mensagem.

  • MessageId: o identificador exclusivo do problema para cada mensagem.

  • Scope: o destino no qual o aviso está sendo suprimido. Se o destino não for especificado, o sistema define o destino do atributo. Os escopos com suporte incluem:

    • module: esse escopo suprime avisos para um assembly. É uma supressão global que se aplica a todo o projeto.

    • resource: (somente FxCop herdado) esse escopo suprime avisos em informações de diagnóstico gravadas em arquivos de recurso que fazem parte do módulo (assembly). Esse escopo não é lido ou respeitado em compiladores C#/VB para diagnóstico do analisador Roslyn, que analisam apenas arquivos de origem.

    • type: esse escopo suprime avisos para um tipo.

    • member: esse escopo suprime avisos para um membro.

    • namespace: Esse escopo suprime avisos para o próprio namespace. Ele não suprime avisos para tipos dentro do namespace.

    • namespaceanddescendants: (requer o compilador versão 3.x ou superior e o Visual Studio 2019 ou mais recente) Esse escopo suprime avisos em um namespace e todos os seus símbolos descendentes. A análise herdada ignora o valor namespaceanddescendants.

  • Target: um identificador que especifica o destino no qual o aviso está sendo suprimido. Ele deve conter um nome de componente totalmente qualificado.

Ao ver avisos no Visual Studio, você pode exibir exemplos de SuppressMessageAttributeadicionando uma supressão ao arquivo de supressão global. O atributo de supressão e suas propriedades necessárias aparecem em uma janela de visualização.

Uso do SuppressMessageAttribute

Os avisos do Code Analysis são suprimidos no nível ao qual o atributo SuppressMessageAttribute é aplicado. Por exemplo, o atributo pode ser aplicado no nível de assembly, módulo, tipo, membro ou parâmetro. A finalidade de aplicar esse atributo é associar firmemente as informações de supressão ao código em que a violação ocorre.

A forma geral de supressão inclui a categoria de regra e um identificador de regra, que contém uma representação opcional legível por humanos do nome da regra. Por exemplo:

[SuppressMessage("Microsoft.Design", "CA1039:ListsAreStrongTyped")]

Se houver motivos de desempenho estritos para minimizar os metadados de supressão no código-fonte, o nome da regra poderá ser omitido. A categoria de regra e sua ID de regra juntas formam um identificador de regra suficientemente exclusivo. Por exemplo:

[SuppressMessage("Microsoft.Design", "CA1039")]

Por motivos de manutenção, não recomendamos omitir o nome da regra.

Suprimir violações seletivas em um corpo do método

Os atributos de supressão podem ser aplicados a um método, mas não podem ser inseridos em um corpo do método. Todas as violações de uma regra específica serão suprimidas se você adicionar o atributo SuppressMessageAttribute ao método.

Em alguns casos, talvez você queira suprimir uma instância específica da violação. Considere o exemplo em que o código futuro não é automaticamente isento da regra de Code Analysis. Determinadas regras de análise de código permitem suprimir uma instância específica da violação usando a propriedade MessageId do atributo SuppressMessageAttribute. Em geral, as regras herdadas para violações em um símbolo específico (uma variável ou parâmetro local) respeitam a propriedade MessageId. CA1500:VariableNamesShouldNotMatchFieldNames é um exemplo dessa regra. No entanto, as regras herdadas para violações no código executável (não símbolo) não respeitam a propriedade MessageId. Além disso, os analisadores da .NET Compiler Platform ("Roslyn") não respeitam a propriedade MessageId.

Para suprimir uma violação de símbolo específica de uma regra, especifique o nome do símbolo para a propriedade MessageId do atributo SuppressMessageAttribute. O exemplo a seguir mostra o código com duas violações de CA1500:VariableNamesShouldNotMatchFieldNames: uma violação para a variável name e outra violação para a variável age. Somente a violação do símbolo age é suprimida.

public class Animal
{
    int age;
    string name;

    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Maintainability", "CA1500:VariableNamesShouldNotMatchFieldNames", MessageId = "age")]
    private void PrintInfo()
    {
        int age = 5;
        string name = "Charlie";

        Console.WriteLine($"Age {age}, Name {name}");
    }
}

Supressões de nível global

A ferramenta de análise de código gerenciado examina os atributos SuppressMessageAttribute que são aplicados no assembly, módulo, tipo, membro ou nível de parâmetro. Ele também envia violações contra recursos e namespaces. Essas violações devem ser aplicadas no nível global e têm escopo e direção. Por exemplo, a seguinte mensagem suprime uma violação de namespace:

[module: SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace", Target = "MyNamespace")]

Para supressões de nível global

  • Quando você suprime um aviso com um escopo namespace, ele suprime o aviso em relação ao próprio namespace. Ele não suprime o aviso em relação aos tipos dentro do namespace.

  • Target sempre contém o nome do item totalmente qualificado.

  • Qualquer supressão pode ser expressa especificando um escopo explícito. Essas supressões devem residir no nível global. Não é possível especificar a supressão no nível do membro modificando um tipo.

  • Supressões de nível global são a única maneira de suprimir mensagens que se referem ao código gerado pelo compilador que não é mapeado para a fonte de usuário fornecida explicitamente. Por exemplo, o código a seguir suprime uma violação contra um construtor emitido pelo compilador:

    [module: SuppressMessage("Microsoft.Design", "CA1055:AbstractTypesDoNotHavePublicConstructors", Scope="member", Target="Microsoft.Tools.FxCop.Type..ctor()")]

Arquivo de supressão global

O arquivo de supressão global mantém supressões que são de nível global ou supressões que não especificam um destino. Por exemplo, as supressões para violações no nível do assembly são armazenadas nesse arquivo. Além disso, algumas supressões ASP.NET são armazenadas nesse arquivo, pois as configurações no nível do projeto não estão disponíveis para código por trás de um formulário. O Visual Studio cria e adiciona um arquivo de supressão global ao seu projeto na primeira vez em que você seleciona a opção no Arquivo de supressão do projeto do comando Suprimir na janela Lista de erros.

Escopo de supressão de módulo

Você pode suprimir as violações da qualidade do código para todo o conjunto usando o escopo module.

Por exemplo, o seguinte atributo no arquivo de projeto GlobalSuppressions suprime a violação ConfigureAwait para um projeto ASP.NET Core:

[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Reliability", "CA2007:Consider calling ConfigureAwait on the awaited task", Justification = "ASP.NET Core doesn't use thread context to store request context.", Scope = "module")]

Código gerado

Compiladores de código gerenciado e algumas ferramentas externas geram código para ajudar no desenvolvimento rápido de código. O código gerado pelo compilador que aparece nos arquivos de origem é marcado com o atributo GeneratedCodeAttribute.

Para análise de código-fonte, você pode suprimir mensagens no código gerado em um arquivo .editorconfig. Para saber mais, confira Excluir código gerado.

Para análise de código herdada, você pode escolher se deseja suprimir avisos e erros de análise de código para o código gerado. Para obter informações sobre como suprimir esses avisos e erros, confira Suprimir avisos de Code Analysis para o código gerado.

Observação

A análise de código ignora GeneratedCodeAttribute quando é aplicada a um assembly inteiro ou a um único parâmetro.

Conteúdo relacionado