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

Se você colaborar com sua equipe enquanto cria código, geralmente é útil indicar que um aviso não é aplicável. A supressão de 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 severidade como none. Por exemplo, dotnet_diagnostic.CA1822.severity = none. Para obter mais informações, consulte Configurar manualmente a severidade 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 em seu código-fonte usando uma diretiva de pré-processador, que suprime violações para uma linha específica de código:

C#: #pragma aviso
Visual Basic: Desativar 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, execute estas etapas:

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 .
Selecione Suprimir ou configurar problemasSuprimir número da regra e depois escolha em Origem ou em Origem (atributo).
- Se você escolher em Source, verá uma visualização da diretiva de pré-processador adicionada ao seu código.
- Se você escolher em Source (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 ficheiro de supressão global utilizando o editor de códigos, siga estes passos:

No editor de códigos, coloque o cursor sobre uma linha de código com uma violação e pressione Ctrl+Period (.) ou Alt+Enter para abrir o menu Ações rápidas .
Selecione Suprimir <número> da regra e, em seguida, escolha em Arquivo de supressã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 é por vezes referida como linha de base. Para suprimir todas as violações atuais em uma solução ou projeto, siga estas etapas:

Na barra de menus do Visual Studio, selecione Analisar>Compilar e Suprimir Problemas Ativos.
Selecione Para solução para suprimir violações para toda a solução ou selecione Para <nome> do projeto para suprimir violações apenas para o seu projeto.

Suprimir violações usando as configurações do projeto

Para suprimir violações usando as configurações do projeto Solution Explorer, execute estas etapas:

No Gerenciador de Soluções, selecione seu projeto.
Clique com o botão direito do rato e, em seguida, selecione Propriedades (ou prima Alt + Enter).
Na janela Propriedades , selecione Análise de código no painel esquerdo e desmarque Suprimir resultados do código gerado.

Supressão na fonte e o atributo SuppressMessageAttribute

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

Você pode inserir o atributo manualmente no editor de código ou adicioná-lo automaticamente da seguinte maneira:

No editor de códigos, coloque o cursor sobre uma linha de código com uma violação e pressione Ctrl+Period (.) ou Alt+Enter para abrir o menu Ações rápidas .
Selecione Suprimir ou configurar problemas>Suprimir <número> da regra no menu Ações rápidas.
Efetue um dos seguintes passos:
- Selecione em Origem (atributo).
  
  O Visual Studio adiciona um SuppressMessageAttribute atributo ao seu código.
- Selecione em Arquivo de supressão.
  
  Visual Studio cria um separador no editor de código contendo um novo ficheiro de supressão global com atributos SuppressMessageAttribute.

O atributo SuppressMessageAttribute é um atributo condicional, que está incluído nos metadados do assembly de código gerido. Este atributo é incluído somente se o CODE_ANALYSIS símbolo de 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, você pode ver um grande número de avisos de análise de código. Se não estiver pronto para corrigir os avisos, pode suprimir todos eles selecionando Analisar>Compilação e Suprimir problemas ativos.

Observação

Não use supressões no código fonte em compilaçõ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:

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

<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 da 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 alvo 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 suportados incluem:
- module: Este escopo suprime avisos relativos a assembly. É uma supressão global que se aplica a todo o projeto.
- resource: (somente análise herdada ) Este escopo suprime avisos em informações de diagnóstico gravadas em arquivos de recursos que fazem parte do módulo (assembly). Esse escopo não é lido ou respeitado em compiladores C#/VB para diagnósticos do analisador Roslyn, que analisam apenas arquivos de origem.
- type: Este escopo suprime avisos contra um determinado tipo.
- member: Este escopo suprime advertências relativamente a um membro.
- namespace: Este escopo suprime avisos contra o namespace em si. Ele não suprime avisos contra tipos dentro do namespace.
- namespaceanddescendants: (Requer compilador versão 3.x ou superior e Visual Studio 2019 ou posterior) Este 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.

Quando você vê 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 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. O objetivo da aplicação desse atributo é acoplar firmemente as informações de supressão ao código onde ocorre a violação.

A forma geral de supressão inclui a categoria da 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 rigorosos para minimizar os metadados de supressão na origem, o nome da regra poderá ser omitido. A categoria da regra e seu ID de regra juntos formam um identificador de regra suficientemente exclusivo. Por exemplo:

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

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

Suprimir violações seletivas dentro de um corpo de método (somente análise de legado)

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

Em alguns casos, poderá querer suprimir um caso específico da violação. Considere o exemplo em que o código futuro não é automaticamente isento da regra de análise de código. Certas 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 MessageId propriedade. 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 MessageId propriedade. Além disso, os analisadores da plataforma de compilador .NET ("Roslyn") não respeitam a MessageId propriedade.

Para suprimir uma violação de símbolo específico 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. Apenas a violação para o 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}");
    }
}

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 a nível global

A ferramenta de análise de código gerido examina os atributos SuppressMessageAttribute que são aplicados ao nível de ensamble, módulo, tipo, membro ou parâmetro. Também submete violações relativamente a recursos e namespaces. Estas violações devem ser aplicadas a nível global e são definidas e direcionadas. Por exemplo, a seguinte mensagem suprime uma violação de namespace:

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

Para supressões a 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 contra tipos dentro do namespace.
Target sempre contém o nome do item totalmente qualificado.
Qualquer supressão pode ser expressa especificando um âmbito explícito. Estas supressões devem existir a nível global. Não é possível especificar a supressão ao nível de membro ao modificar um tipo.
As 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 do 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 por violações no nível de assembly são armazenadas neste arquivo. Além disso, algumas supressões de ASP.NET são armazenadas neste arquivo porque as configurações no nível do projeto não estão disponíveis para o 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 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 violações de qualidade de código de todo o assembly 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 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 herdado, 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 código gerado.