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

Se você colaborar com sua equipe ao criar código, geralmente é útil indicar que um aviso não é aplicável. Suprimir violações de análise de código indica aos 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, consulte Configurar manualmente a gravidade da regra em um arquivo EditorConfig. Para adicionar um arquivo EditorConfig, consulte Adicionar um arquivo EditorConfig a um projeto.

Suprimir violações no código-fonte

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

• C#: #pragma aviso
• Visual Basic: Desabilitar aviso

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+Period (.) ou Alt+Enter para abrir o menu Ações Rápidas .

2. Selecione Suprimir ou configurar problemas>Suprimir número<da regra> e depois 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.

     

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

     

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+Period (.) ou Alt+Enter para abrir o menu Ações Rápidas .

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

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

Suprimir todas as violações atuais

A supressão de todas as violações atuais às vezes é conhecida como baselining. 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>Compilar e Suprimir Problemas Ativos.

2. Selecione Para solução para suprimir violações de toda a solução ou selecione Para <nome do projeto> para suprimir violações apenas no 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 Análise de Código no painel esquerdo e desmarque Suprimir resultados do código gerado.

Supressão no código-fonte e o atributo SuppressMessageAttribute

O ISS (supressão no código-fonte) usa o atributo SuppressMessageAttribute para suprimir um aviso. Você pode adicionar o SuppressMessageAttribute atributo 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+Period (.) ou Alt+Enter para abrir o menu Ações Rápidas .

2. Selecione Suprimir ou configurar problemas><> no menu Ações Rápidas.

3. Siga uma das etapas a seguir:

   • Selecione 'em Origem (atributo)'.

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

   • Selecione no Arquivo de Supressão.

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

O SuppressMessageAttribute atributo é um atributo condicional, que está incluído nos metadados do assembly de código gerenciado. Esse atributo será incluído somente se o símbolo de CODE_ANALYSIS compilação for definido em 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 versão mais recente do Visual Studio, poderá ver um grande número de avisos de análise de código. Se você não estiver pronto para corrigir os avisos, poderá suprimir todos selecionando Analisar>Compilar e Suprimir Problemas Ativos.

Observação

Não use supressões no código-fonte em versões de lançamento, para evitar o envio acidental dos metadados de supressão no código-fonte.

Formato do atributo SuppressMessageAttribute

O SuppressMessageAttribute atributo tem o seguinte formato:

C#

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

VB

<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 categorias de regras de análise de código, consulte 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 para suprimir a 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 o definirá como o destino do atributo. Os escopos com suporte incluem:

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

  • resource: (somente análise herdada ) 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 os arquivos de origem.

  • type: esse escopo suprime avisos em relação a um tipo.

  • member: Este escopo suprime alertas em relação a um membro.

  • namespace: esse escopo suprime avisos em relação ao namespace em si. Ele não suprime os avisos em relação aos tipos dentro do namespace.

  • namespaceanddescendants: (Requer o compilador versão 3.x ou superior e o Visual Studio 2019 ou posterior) 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 os avisos no Visual Studio, você pode exibir exemplos ao adicionar SuppressMessageAttributeuma 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 de SuppressMessageAttribute

Os avisos de análise de código são suprimidos no nível ao qual o SuppressMessageAttribute atributo é 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 metadados de supressão no código-fonte, o nome da regra poderá ser omitido. A categoria de regra e sua ID de regra em conjunto formam um identificador de regra suficientemente exclusivo. Por exemplo:

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

Por motivos de manutenção, não é recomendável omitir o nome da regra.

Suprimir ou filtrar violações seletivas dentro do corpo de um método (apenas para análise herdada)

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 SuppressMessageAttribute atributo ao método.

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

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

C#

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}");
    }
}

VB

Public Class Animal
    Dim age As Integer
    Dim name As String

    <CodeAnalysis.SuppressMessage("Microsoft.Maintainability", "CA1500:VariableNamesShouldNotMatchFieldNames", MessageId:="age")>
    Sub PrintInfo()
        Dim age As Integer = 5
        Dim name As String = "Charlie"

        Console.WriteLine("Age {0}, Name {1}", age, name)
    End Sub

End Class

Supressões de nível global

A ferramenta de análise de código gerenciado examina os atributos SuppressMessageAttribute que são aplicados em nível de assembly, módulo, tipo, membro ou parâmetro. Também relata violações contra recursos e namespaces. Essas violações devem ser aplicadas no nível global e têm como escopo e destino. 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 namespace escopo, ele suprime o aviso em relação ao namespace em si. 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 estar no nível global. Não é possível especificar a supressão ao nível de membro ao modificar 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 supressões 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 neste arquivo. Além disso, algumas supressões de ASP.NET são armazenadas nesse arquivo porque 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 que você seleciona a opção Arquivo de Supressão de Projeto do comando Suprimir na janela Lista de Erros .

Escopo de supressão de módulo

Você pode suprimir violações de qualidade de código para todo o assembly usando o escopo module.

Por exemplo, o seguinte atributo em seu arquivo de projeto GlobalSuppressions suprime a violação ConfigureAwait para um projeto do 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 GeneratedCodeAttribute atributo.

Para análise de código-fonte, você pode suprimir mensagens no código gerado em um arquivo .editorconfig . Para obter mais informações, consulte 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, consulte Suprimir avisos de análise de código 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

• Scope
• System.Diagnostics.CodeAnalysis
• Personalizar regras do analisador Roslyn