Visão geralOverview

Cada regra ou diagnóstico do Roslyn Analyzer tem um estado de gravidade e supressão padrão que pode ser substituído e personalizado para seu projeto.Each Roslyn analyzer diagnostic or rule has a default severity and suppression state that can be overwritten and customized for your project. Este artigo aborda a definição de severidades do analisador e a supressão de violações do analisador.This article covers setting analyzer severities and suppressing analyzer violations.

Configurar níveis de severidadeConfigure severity levels

A partir do Visual Studio 2019 versão 16,3, você pode configurar a severidade de regras do analisador, ou diagnósticos, em um arquivo EditorConfig, no menu de lâmpadae na lista de erros.Starting in Visual Studio 2019 version 16.3, you can configure the severity of analyzer rules, or diagnostics, in an EditorConfig file, from the light bulb menu, and from the error list.

Você pode configurar a severidade de regras do analisador ou diagnóstico, se instalar os analisadores como um pacote NuGet.You can configure the severity of analyzer rules, or diagnostics, if you install the analyzers as a NuGet package. Você pode alterar a severidade de uma regra de Gerenciador de soluções ou em um arquivo de conjunto de regras.You can change the severity of a rule from Solution Explorer or in a rule set file.

A tabela a seguir mostra as diferentes opções de gravidade:The following table shows the different severity options:

Gravidade (Gerenciador de Soluções)Severity (Solution Explorer) Severidade (arquivo EditorConfig)Severity (EditorConfig file) Comportamento de tempo de compilaçãoBuild-time behavior Comportamento do editorEditor behavior
ErroError error As violações aparecem como erros na lista de erros e na saída da compilação da linha de comando e causam a falha das compilações.Violations appear as Errors in the Error List and in command-line build output, and cause builds to fail. O código incorreto é sublinhado com um ondulado vermelho e marcado por uma pequena caixa vermelha na barra de rolagem.Offending code is underlined with a red squiggle and marked by a small red box in the scroll bar.
AvisoWarning warning As violações aparecem como avisos no lista de erros e na saída da compilação da linha de comando, mas não causam a falha das compilações.Violations appear as Warnings in the Error List and in command-line build output, but do not cause builds to fail. O código incorreto é sublinhado com um ondulado verde e marcado por uma pequena caixa verde na barra de rolagem.Offending code is underlined with a green squiggle and marked by a small green box in the scroll bar.
InformaçõesInfo suggestion As violações aparecem como mensagens no lista de erros, e não em uma saída de compilação de linha de comando.Violations appear as Messages in the Error List, and not at all in command-line build output. O código incorreto é sublinhado com um rabisco cinza e marcado por uma pequena caixa cinza na barra de rolagem.Offending code is underlined with a gray squiggle and marked by a small gray box in the scroll bar.
HiddenHidden silent Não visível para o usuário.Non-visible to user. Não visível para o usuário.Non-visible to user. No entanto, o diagnóstico é reportado para o mecanismo de diagnóstico do IDE.The diagnostic is reported to the IDE diagnostic engine, however.
NenhumNone none Suprimido completamente.Suppressed completely. Suprimido completamente.Suppressed completely.
PadrãoDefault default Corresponde à severidade padrão da regra.Corresponds to the default severity of the rule. Para determinar qual é o valor padrão de uma regra, procure na janela Propriedades.To determine what the default value for a rule is, look in the Properties window. Corresponde à severidade padrão da regra.Corresponds to the default severity of the rule.

Se violações de regra forem encontradas por um analisador, elas serão relatadas no editor de códigos (como um rabisco no código incorreto) e na janela de lista de erros.If rule violations are found by an analyzer, they're reported in the code editor (as a squiggle under the offending code) and in the Error List window.

As violações do analisador relatadas na lista de erros correspondem à configuração de nível de severidade da regra.The analyzer violations reported in the error list match the severity level setting of the rule. As violações do analisador também aparecem no editor de códigos como ondulado no código incorreto.Analyzer violations also show up in the code editor as squiggles under the offending code. A imagem a seguir mostra três violações — um erro (ondulado vermelho), um aviso (ondulado verde) e uma sugestão (três pontos cinzas):The following image shows three violations—one error (red squiggle), one warning (green squiggle), and one suggestion (three grey dots):

Rabiscos no editor de códigos do Visual Studio

A captura de tela a seguir mostra as mesmas três violações que aparecem no Lista de Erros:The following screenshot shows the same three violations as they appear in the Error List:

Violação de erro, aviso e informações no Lista de Erros

Muitas regras de analisador ou diagnósticostêm uma ou mais correções de código associadas que você pode aplicar para corrigir a violação de regra.Many analyzer rules, or diagnostics, have one or more associated code fixes that you can apply to correct the rule violation. As correções de código são mostradas no menu do ícone de lâmpada, juntamente com outros tipos de Ações rápidas.Code fixes are shown in the light bulb icon menu along with other types of Quick Actions. Para saber mais sobre essas correções de código, confira Ações rápidas comuns.For information about these code fixes, see Common Quick Actions.

Violação do analisador e correção de código de Ação Rápida

Severidade ' Hidden ' versus severidade ' none ''Hidden' severity versus 'None' severity

Hidden as regras de severidade habilitadas por padrão são diferentes das regras desabilitadas ou de None severidade de duas maneiras.Hidden severity rules that are enabled by default are different from disabled or None severity rules in couple of ways.

Definir a severidade da regra em um arquivo EditorConfigSet rule severity in an EditorConfig file

(Visual Studio 2019 versão 16,3 e posterior)(Visual Studio 2019 version 16.3 and later)

Você pode definir a severidade para avisos do compilador ou regras do analisador em um arquivo EditorConfig com a seguinte sintaxe:You can set the severity for compiler warnings or analyzer rules in an EditorConfig file with the following syntax:

dotnet_diagnostic.<rule ID>.severity = <severity>

Definir a severidade de uma regra em um arquivo EditorConfig tem precedência sobre qualquer severidade definida em um conjunto de regras ou em Gerenciador de Soluções.Setting a rule's severity in an EditorConfig file takes precedence over any severity that's set in a rule set or in Solution Explorer. Você pode configurar manualmente a gravidade em um arquivo EditorConfig ou automaticamente por meio da lâmpada que aparece ao lado de uma violação.You can manually configure severity in an EditorConfig file or automatically through the light bulb that appears next to a violation.

Definir a severidade da regra de várias regras do analisador de uma só vez em um arquivo EditorConfigSet rule severity of multiple analyzer rules at once in an EditorConfig file

(Visual Studio 2019 versão 16,5 e posterior)(Visual Studio 2019 version 16.5 and later)

Você pode definir a severidade para uma categoria específica de regras do analisador ou para todas as regras do analisador com uma única entrada em um arquivo EditorConfig.You can set the severity for a specific category of analyzer rules or for all analyzer rules with a single entry in an EditorConfig file.

  • Defina a severidade da regra para uma categoria de regras do analisador:Set rule severity for a category of analyzer rules:

dotnet_analyzer_diagnostic.category-<rule category>.severity = <severity>

  • Definir severidade da regra para todas as regras do analisador:Set rule severity for all analyzer rules:

dotnet_analyzer_diagnostic.severity = <severity>

Observação

As entradas para configurar várias regras do analisador ao mesmo tempo se aplicam às regras habilitadas por padrão.Entries to configure multiple analyzer rules at once only apply to rules that are enabled by default. As regras do Analyzer que são marcadas como desabilitadas por padrão no pacote do analisador devem ser habilitadas por meio de entradas explícitas dotnet_diagnostic.<rule ID>.severity = <severity> .Analyzer rules that are marked as disabled by default in the analyzer package must be enabled through explicit dotnet_diagnostic.<rule ID>.severity = <severity> entries.

Se você tiver várias entradas que são aplicáveis a uma ID de regra específica, o seguinte é a ordem de precedência para escolher a entrada aplicável:If you have multiple entries that are applicable to a specific rule ID, the following is the precedence order to choose the applicable entry:

  • A entrada de severidade para uma regra individual por ID tem precedência sobre a entrada de severidade de uma categoria.Severity entry for an individual rule by ID takes precedence over severity entry for a category.
  • A entrada de severidade para uma categoria tem precedência sobre a entrada de severidade para todas as regras do analisador.Severity entry for a category takes precedence over severity entry for all analyzer rules.

Considere o seguinte exemplo de EditorConfig, em que CA1822 tem a categoria "performance":Consider the following EditorConfig example, where CA1822 has the category "Performance":

[*.cs]
dotnet_diagnostic.CA1822.severity = error
dotnet_analyzer_diagnostic.category-performance.severity = warning
dotnet_analyzer_diagnostic.severity = suggestion

No exemplo anterior, todas as três entradas são aplicáveis a CA1822.In the preceding example, all three entries are applicable to CA1822. No entanto, usando as regras de precedência especificadas, a primeira entrada de severidade com base na ID da regra vence nas próximas entradas.However, using the specified precedence rules, the first rule ID-based severity entry wins over the next entries. Neste exemplo, o CA1822 terá uma severidade efetiva de "Error".In this example, CA1822 will have an effective severity of "error". Todas as regras restantes com a categoria "desempenho" terão a severidade "aviso".All the remaining rules with the "Performance" category will have severity "warning". Todas as demais regras do analisador, que não têm a categoria "desempenho", terão a severidade "sugestão".All the remaining analyzer rules, which do not have the "Performance" category, will have severity "suggestion".

Configurar manualmente a severidade da regra em um arquivo EditorConfigManually configure rule severity in an EditorConfig file

  1. Se você ainda não tiver um arquivo EditorConfig para seu projeto, adicione um.If you don't already have an EditorConfig file for your project, add one.

  2. Adicione uma entrada para cada regra que você deseja configurar na extensão de arquivo correspondente.Add an entry for each rule you want to configure under the corresponding file extension. Por exemplo, para definir a severidade de CA1822 como error para arquivos C#, a entrada tem a seguinte aparência:For example, to set the severity for CA1822 to error for C# files, the entry looks as follows:

    [*.cs]
    dotnet_diagnostic.CA1822.severity = error
    

Observação

Para analisadores de estilo de código IDE, você também pode configurá-los em um arquivo EditorConfig usando uma sintaxe diferente, por exemplo, dotnet_style_qualification_for_field = false:suggestion .For IDE code-style analyzers, you can also configure them in an EditorConfig file using a different syntax, for example, dotnet_style_qualification_for_field = false:suggestion. No entanto, se você definir uma severidade usando a dotnet_diagnostic sintaxe, ela terá precedência.However, if you set a severity using the dotnet_diagnostic syntax, it takes precedence. Para obter mais informações, consulte convenções de linguagem para EditorConfig.For more information, see Language conventions for EditorConfig.

Definir a severidade da regra no menu de lâmpadaSet rule severity from the light bulb menu

O Visual Studio fornece uma maneira conveniente de configurar a severidade de uma regra no menu de lâmpada de ações rápidas .Visual Studio provides a convenient way to configure a rule's severity from the Quick Actions light bulb menu.

  1. Após a ocorrência de uma violação, focalize o rabisco da violação no editor e abra o menu de lâmpada.After a violation occurs, hover over the violation squiggle in the editor and open the light bulb menu. Ou coloque o cursor na linha e pressione Ctrl + .Or, put your cursor on the line and press Ctrl+. (ponto).(period).

  2. No menu de lâmpada, selecione Configurar ou suprimir problemas > Configurar <rule ID> severidade.From the light bulb menu, select Configure or Suppress issues > Configure <rule ID> severity.

    Configurar a severidade da regra no menu de lâmpada no Visual Studio

  3. A partir daí, escolha uma das opções de severidade.From there, choose one of the severity options.

    Configurar a severidade da regra como sugestão

    O Visual Studio adiciona uma entrada ao arquivo EditorConfig para configurar a regra para o nível solicitado, conforme mostrado na caixa de visualização.Visual Studio adds an entry to the EditorConfig file to configure the rule to the requested level, as shown in the preview box.

    Dica

    Se você ainda não tiver um arquivo EditorConfig no projeto, o Visual Studio criará um para você.If you don't already have an EditorConfig file in the project, Visual Studio creates one for you.

Definir a severidade da regra na janela de Lista de ErrosSet rule severity from the Error List window

O Visual Studio também fornece uma maneira conveniente de configurar a severidade de uma regra no menu de contexto da lista de erros.Visual Studio also provides a convenient way to configure a rule's severity from the error list context menu.

  1. Após a ocorrência de uma violação, clique com o botão direito do mouse na entrada de diagnóstico na lista de erros.After a violation occurs, right-click the diagnostic entry in the error list.

  2. No menu de contexto, selecione definir severidade.From the context menu, select Set severity.

    Configurar a severidade da regra na lista de erros no Visual Studio

  3. A partir daí, escolha uma das opções de severidade.From there, choose one of the severity options.

    O Visual Studio adiciona uma entrada ao arquivo EditorConfig para configurar a regra para o nível solicitado.Visual Studio adds an entry to the EditorConfig file to configure the rule to the requested level.

    Dica

    Se você ainda não tiver um arquivo EditorConfig no projeto, o Visual Studio criará um para você.If you don't already have an EditorConfig file in the project, Visual Studio creates one for you.

Definir a severidade da regra de Gerenciador de SoluçõesSet rule severity from Solution Explorer

Você pode fazer grande parte da personalização do diagnóstico do Analyzer do Gerenciador de soluções.You can do much of the customization of analyzer diagnostics from Solution Explorer. Se você instalar os analisadores como um pacote NuGet, um nó analisadores será exibido no nó referências ou dependências em Gerenciador de soluções.If you install analyzers as a NuGet package, an Analyzers node appears under the References or Dependencies node in Solution Explorer. Se você expandir os analisadorese, em seguida, expandir um dos assemblies do analisador, verá todos os diagnósticos no assembly.If you expand Analyzers, and then expand one of the analyzer assemblies, you see all the diagnostics in the assembly.

Nó de analisadores no Gerenciador de Soluções

Você pode exibir as propriedades de um diagnóstico, incluindo sua descrição e severidade padrão, na janela Propriedades .You can view the properties of a diagnostic, including its description and default severity, in the Properties window. Para exibir as propriedades, clique com o botão direito do mouse na regra e selecione Propriedades, ou selecione a regra e pressione ALT + Enter.To view the properties, right-click the rule and select Properties, or select the rule and then press Alt+Enter.

Propriedades de diagnóstico no janela Propriedades

Para ver a documentação online de um diagnóstico, clique com o botão direito do mouse no diagnóstico e selecione Exibir ajuda.To see online documentation for a diagnostic, right-click the diagnostic and select View Help.

Os ícones ao lado de cada diagnóstico no Gerenciador de soluções correspondem aos ícones que você vê no conjunto de regras ao abri-lo no editor:The icons next to each diagnostic in Solution Explorer correspond to the icons you see in the rule set when you open it in the editor:

  • o "x" em um círculo indica uma severidade de errothe "x" in a circle indicates a severity of Error
  • o "!" em um triângulo indica uma severidade de avisothe "!" in a triangle indicates a severity of Warning
  • o "i" em um círculo indica uma severidade de informaçõesthe "i" in a circle indicates a severity of Info
  • o "i" em um círculo em um plano de fundo com cor clara indica uma severidade de ocultothe "i" in a circle on a light-colored background indicates a severity of Hidden
  • a seta apontando para baixo em um círculo indica que o diagnóstico foi suprimidothe downward-pointing arrow in a circle indicates that the diagnostic is suppressed

Ícones de diagnóstico no Gerenciador de Soluções

Converter um arquivo RuleSet existente no arquivo EditorConfigConvert an existing Ruleset file to EditorConfig file

A partir do Visual Studio 2019 versão 16,5, os arquivos RuleSet são preteridos em favor do arquivo EditorConfig para a configuração do analisador para código gerenciado.Starting in Visual Studio 2019 version 16.5, ruleset files are deprecated in favor of the EditorConfig file for analyzer configuration for managed code. A maioria das ferramentas do Visual Studio para a configuração de severidade da regra do analisador foi atualizada para funcionar em arquivos EditorConfig em vez de arquivos RuleSet.Most of the Visual Studio tooling for analyzer rule severity configuration has been updated to work on EditorConfig files instead of ruleset files. Os arquivos EditorConfig permitem que você configure ambas as opções do analisador e severidades de regra do analisador, incluindo opções de estilo de código IDE do Visual Studio.EditorConfig files allow you to configure both analyzer rule severities and analyzer options, including Visual Studio IDE code style options. É altamente recomendável que você converta o arquivo RuleSet existente em um arquivo EditorConfig.It is highly recommended that you convert your existing ruleset file to an EditorConfig file. Também é recomendável que você salve o arquivo EditorConfig na raiz do seu repositório ou na pasta da solução.It is also recommended that you save the EditorConfig file at the root of your repo or in the solution folder. Usando a raiz do seu repositório ou pasta de solução, você garante que as configurações de severidade desse arquivo sejam aplicadas automaticamente a todo o repositório ou solução, respectivamente.By using the root of your repo or solution folder, you make sure that the severity settings from this file are automatically applied to the entire repo or solution, respectively.

Há duas maneiras de converter um arquivo RuleSet existente em um arquivo EditorConfig:There are a couple ways to convert an existing ruleset file to an EditorConfig file:

  • Do editor de conjunto de regras no Visual Studio (requer o Visual Studio 2019 16,5 ou posterior).From the Ruleset Editor in Visual Studio (requires Visual Studio 2019 16.5 or later). Se o seu projeto já usa um arquivo RuleSet específico como seu CodeAnalysisRuleSet , você pode convertê-lo em um arquivo EditorConfig equivalente do editor de RuleSet no Visual Studio.If your project already uses a specific ruleset file as its CodeAnalysisRuleSet, you can convert it to an equivalent EditorConfig file from Ruleset Editor within Visual Studio.

    1. Clique duas vezes no arquivo RuleSet em Gerenciador de Soluções.Double-click the ruleset file in Solution Explorer.

      O arquivo RuleSet deve ser aberto no editor de RuleSet.The Ruleset file should open in the Ruleset Editor. Você deverá ver uma barra de edição clicável na parte superior do editor de conjunto de regras.You should see a clickable infobar at top of the ruleset editor.

      Converter RuleSet em arquivo EditorConfig no editor de RuleSet

    2. Selecione o link da barra de opções.Select the infobar link.

      Isso deve abrir uma caixa de diálogo salvar como que permite selecionar o diretório onde você deseja gerar o arquivo EditorConfig.This should open a Save As dialog that allows you to select the directory where you want to generate the EditorConfig file.

    3. Selecione o botão salvar para gerar o arquivo EditorConfig.Select the Save button to generate the EditorConfig file.

      O EditorConfig gerado deve ser aberto no editor.The generated EditorConfig should open in the editor. Além disso, a Propriedade MSBuild CodeAnalysisRuleSet é atualizada no arquivo de projeto para que ele não referencie mais o arquivo RuleSet original.Additionally, the MSBuild property CodeAnalysisRuleSet gets updated in the project file so that it no longer references the original ruleset file.

  • Na linha de comando:From the command line:

    1. Instale o pacote NuGet Microsoft. CodeAnalysis. RulesetToEditorconfigConverter.Install the NuGet package Microsoft.CodeAnalysis.RulesetToEditorconfigConverter.

    2. Execute RulesetToEditorconfigConverter.exe a partir do pacote instalado, com caminhos para arquivo RuleSet e arquivo EditorConfig como argumentos de linha de comando.Execute RulesetToEditorconfigConverter.exe from the installed package, with paths to ruleset file and EditorConfig file as command-line arguments.

    Usage: RulesetToEditorconfigConverter.exe <%ruleset_file%> [<%path_to_editorconfig%>]
    

Aqui está um exemplo de arquivo RuleSet para converter:Here is an example ruleset file to convert:

<?xml version="1.0" encoding="utf-8"?>
<RuleSet Name="Rules for ConsoleApp" Description="Code analysis rules for ConsoleApp.csproj." ToolsVersion="16.0">
  <Rules AnalyzerId="Microsoft.Analyzers.ManagedCodeAnalysis" RuleNamespace="Microsoft.Rules.Managed">
    <Rule Id="CA1001" Action="Warning" />
    <Rule Id="CA1821" Action="Warning" />
    <Rule Id="CA2213" Action="Warning" />
    <Rule Id="CA2231" Action="Warning" />
  </Rules>
</RuleSet>

Este é o arquivo EditorConfig convertido:Here is the converted EditorConfig file:

# NOTE: Requires **VS2019 16.3** or later

# Rules for ConsoleApp
# Description: Code analysis rules for ConsoleApp.csproj.

# Code files
[*.{cs,vb}]


dotnet_diagnostic.CA1001.severity = warning

dotnet_diagnostic.CA1821.severity = warning

dotnet_diagnostic.CA2213.severity = warning

dotnet_diagnostic.CA2231.severity = warning

Definir a severidade da regra de Gerenciador de SoluçõesSet rule severity from Solution Explorer

  1. Em Gerenciador de soluções, expanda referências > analisadores (ou Dependencies > analisadores de dependências para projetos do .NET Core).In Solution Explorer, expand References > Analyzers (or Dependencies > Analyzers for .NET Core projects).

  2. Expanda o assembly que contém a regra para a qual você deseja definir a severidade.Expand the assembly that contains the rule you want to set severity for.

  1. Clique com o botão direito do mouse na regra e selecione definir severidade.Right-click the rule and select Set severity. No menu de contexto, escolha uma das opções de gravidade.In the context menu, choose one of the severity options.

    O Visual Studio adiciona uma entrada ao arquivo EditorConfig para configurar a regra para o nível solicitado.Visual Studio adds an entry to the EditorConfig file to configure the rule to the requested level. Se o seu projeto usa um arquivo RuleSet em vez de um arquivo EditorConfig, a entrada de severidade é adicionada ao arquivo RuleSet.If your project uses a ruleset file instead of an EditorConfig file, the severity entry is added to the ruleset file.

    Dica

    Se você ainda não tiver um arquivo EditorConfig ou um arquivo RuleSet no projeto, o Visual Studio criará um novo arquivo EditorConfig para você.If you don't already have an EditorConfig file or ruleset file in the project, Visual Studio creates a new EditorConfig file for you.

  1. Clique com o botão direito do mouse na regra e selecione definir severidade do conjunto de regras.Right-click the rule and select Set Rule Set Severity. No menu de contexto, escolha uma das opções de gravidade.In the context menu, choose one of the severity options.

    A severidade da regra é salva no arquivo de conjunto de regras ativo.The severity for the rule is saved in the active rule set file.

Definir a severidade da regra no arquivo de conjunto de regrasSet rule severity in the rule set file

Arquivo de conjunto de regras no Gerenciador de Soluções

  1. Abra o arquivo de conjunto de regras ativo de uma das seguintes maneiras:Open the the active rule set file in one of the following ways:
  • Em Gerenciador de soluções, clique duas vezes no arquivo, clique com Referenceso botão direito do mouse no > nóanalisadores de referências e selecione abrir conjunto de regras ativas.In Solution Explorer, double click the file, right-click References > Analyzers node, and select Open Active Rule Set.

  • Na página de propriedades de análise de código do projeto, selecione abrir .On the Code Analysis property page for the project, select Open .

    Se esta for a primeira vez que você está editando o conjunto de regras, o Visual Studio faz uma cópia do arquivo de conjunto de regras padrão, nomeia-o * <projectname> . RuleSet*e o adiciona ao seu projeto.If this is the first time you're editing the rule set, Visual Studio makes a copy of the default rule set file, names it <projectname>.ruleset, and adds it to your project. Esse conjunto de regras personalizadas também se torna o conjunto de regras ativo para seu projeto.This custom rule set also becomes the active rule set for your project.

    Observação

    Os projetos .NET Core e .NET Standard não dão suporte aos comandos de menu para conjuntos de regras em Gerenciador de soluções, por exemplo, abrir conjunto de regras ativas..NET Core and .NET Standard projects do not support the menu commands for rule sets in Solution Explorer, for example, Open Active Rule Set. Para especificar um conjunto de regras não padrão para um projeto do .NET Core ou .NET Standard, adicione manualmente a propriedade CodeAnalysisRuleSet ao arquivo do projeto.To specify a non-default rule set for a .NET Core or .NET Standard project, manually add the CodeAnalysisRuleSet property to the project file. Você ainda pode configurar as regras dentro do conjunto de regras na interface do usuário do editor de conjunto de regras do Visual Studio.You can still configure the rules within the rule set in the Visual Studio rule set editor UI.

  1. Navegue até a regra expandindo seu assembly recipiente.Browse to the rule by expanding its containing assembly.

  2. Na coluna ação , selecione o valor para abrir uma lista suspensa e escolha a severidade desejada na lista.In the Action column, select the value to open a drop-down list, and choose the desired severity from the list.

    Arquivo de conjunto de regras aberto no editor

Configurar o código geradoConfigure Generated code

Os analisadores são executados em todos os arquivos de origem em um projeto e violações de relatório sobre eles.Analyzers run on all source files in a project and report violations on them. No entanto, essas violações não são úteis em arquivos de código gerados, como arquivos de código gerados pelo designer, arquivos de origem temporários gerados pelo sistema de compilação etc. Os usuários não podem editar esses arquivos manualmente e/ou não se preocupam com a correção de violações nesses tipos de arquivos gerados por ferramentas.However, these violations are not useful on generated code files, such as designer generated code files, temporary source files generated by build system, etc. Users cannot manually edit these files and/or are not concerned about fixing violations in these kind of tooling-generated files.

Por padrão, o driver do analisador que executa analisadores trata arquivos com determinado nome, extensão de arquivo ou cabeçalho de arquivo gerado automaticamente como arquivos de código gerados.By default, the analyzer driver executing analyzers treats files with certain name, file extension, or auto-generated file header as generated code files. Por exemplo, um nome de arquivo que termina com .designer.cs ou .generated.cs é considerado código gerado.For example, a file name ending with .designer.cs or .generated.cs is considered generated code. No entanto, essas heurísticas podem não ser capazes de identificar todos os arquivos de código gerados personalizados no código-fonte do usuário.However, these heuristics might not be able to identify all the custom generated code files in user's source code.

A partir do Visual Studio 2019 16,5, os usuários finais podem configurar arquivos e/ou pastas específicos para serem tratados como código gerado em um arquivo EditorConfig.Starting with Visual Studio 2019 16.5, end users can configure specific files and/or folders to be treated as generated code in an EditorConfig file. Siga as etapas abaixo para adicionar essa configuração:Follow the steps below to add such a configuration:

  1. Se você ainda não tiver um arquivo EditorConfig para seu projeto, adicione um.If you don't already have an EditorConfig file for your project, add one.

  2. Adicione a generated_code = true | false entrada para arquivos e/ou pastas específicas.Add the generated_code = true | false entry for specific files and/or folders. Por exemplo, para tratar todos os arquivos cujo nome termina com .MyGenerated.cs o código gerado, a entrada seria a seguinte:For example, to treat all files whose name ends with .MyGenerated.cs as generated code, the entry would be as follows:

    [*.MyGenerated.cs]
    generated_code = true
    

Suprimir violaçõesSuppress violations

Há várias maneiras de suprimir violações de regra:There are multiple ways to suppress rule violations:

  • Em um arquivo EditorConfigIn an EditorConfig file

    Defina a severidade como none , por exemplo, dotnet_diagnostic.CA1822.severity = none .Set the severity to none, for example, dotnet_diagnostic.CA1822.severity = none.

  • No menu analisarFrom the Analyze menu

    Selecione analisar > Compilar e suprimir problemas ativos na barra de menus para suprimir todas as violações atuais.Select Analyze > Build and Suppress Active Issues on the menu bar to suppress all current violations. Isso às vezes é chamado de "linha de base".This is sometimes referred to as "baselining".

  • No menu analisarFrom the Analyze menu

    Selecione analisar > executar análise de código e suprimir problemas ativos na barra de menus para suprimir todas as violações atuais.Select Analyze > Run Code Analysis and Suppress Active Issues on the menu bar to suppress all current violations. Isso às vezes é chamado de "linha de base".This is sometimes referred to as "baselining".

  • De Gerenciador de soluçõesFrom Solution Explorer

    Defina a severidade da regra como nenhuma.Set the rule's severity to None.

  • Do Editor de conjunto de regrasFrom the rule set editor

    Desmarque a caixa de seleção ao lado de seu nome ou defina a ação como nenhum.Clear the check box next to its name or set Action to None.

  • No Editor de códigoFrom the code editor

    Coloque o cursor na linha de código com a violação e pressione Ctrl + ponto (.) para abrir o menu ações rápidas .Place the cursor in the line of code with the violation and press Ctrl+Period (.) to open the Quick Actions menu. Selecione suprimir CAXXXX > na origem/no arquivo de supressão.Select Suppress CAXXXX > in Source/in Suppression File.

    Suprimir diagnóstico do menu de ações rápidas

  • Da lista de errosFrom the Error List

    Selecione as regras que você deseja suprimir e clique com o botão direito do mouse e selecione suprimir > na origem/no arquivo de supressão.Select the rules you want to suppress, and then right-click and select Suppress > In Source/In Suppression File.

    • Se você suprimir na origem, a caixa de diálogo Visualizar alterações será aberta e mostrará uma visualização do aviso de #pragma do C# ou Visual Basic diretiva de aviso de #Disable que é adicionada ao código-fonte.If you suppress In Source, the Preview Changes dialog opens and shows a preview of the C# #pragma warning or Visual Basic #Disable warning directive that's added to the source code.

      Visualização da adição de #pragma Aviso no arquivo de código

    • Se você selecionar no arquivo de supressão, a caixa de diálogo Visualizar alterações será aberta e mostrará uma visualização do SuppressMessageAttribute atributo que é adicionado ao arquivo de supressões global.If you select In Suppression File, the Preview Changes dialog opens and shows a preview of the SuppressMessageAttribute attribute that's added to the global suppressions file.

      Visualização da adição do atributo SuppressMessage ao arquivo de supressão

    Na caixa de diálogo Visualizar alterações , selecione aplicar.In the Preview Changes dialog, select Apply.

    Observação

    Se você não vir a opção de menu suprimir em Gerenciador de soluções, a violação provavelmente será proveniente da compilação e não da análise dinâmica.If you don't see the Suppress menu option in Solution Explorer, the violation is likely coming from build and not live analysis. O lista de erros exibe diagnósticos ou violações de regra, tanto da análise de código ao vivo quanto da compilação.The Error List displays diagnostics, or rule violations, from both live code analysis and build. Como o diagnóstico de compilação pode ser obsoleto, por exemplo, se você tiver editado o código para corrigir a violação, mas não tiver recriado, não poderá suprimir esses diagnósticos do lista de erros.Since the build diagnostics can be stale, for example, if you've edited the code to fix the violation but haven't rebuilt, you cannot suppress these diagnostics from the Error List. Os diagnósticos da análise ao vivo ou do IntelliSense estão sempre atualizados com as fontes atuais e podem ser suprimidos no lista de erros.Diagnostics from live analysis, or IntelliSense, are always up-to-date with current sources and can be suppressed from the Error List. Para excluir o diagnóstico de compilação da sua seleção, alterne o filtro de origem lista de erros do Build + IntelliSense somente para IntelliSense.To exclude build diagnostics from your selection, switch the Error List source filter from Build + IntelliSense to IntelliSense Only. Em seguida, selecione o diagnóstico que você deseja suprimir e continue conforme descrito anteriormente.Then, select the diagnostics you want to suppress and proceed as described previously.

    Lista de Erros filtro de origem no Visual Studio

Uso da linha de comandoCommand-line usage

Quando você cria seu projeto na linha de comando, violações de regra aparecem na saída da compilação se as seguintes condições forem atendidas:When you build your project at the command line, rule violations appear in the build output if the following conditions are met:

  • Os analisadores são instalados como um pacote NuGet e não como uma extensão VSIX.The analyzers are installed as a NuGet package and not as a VSIX extension.

  • Uma ou mais regras são violadas no código do projeto.One or more rules are violated in the project's code.

  • A severidade de uma regra violada é definida como aviso; nesse caso, as violações não causam a falha da compilação ou erros, caso em que as violações causam a falha da compilação.The severity of a violated rule is set to either warning, in which case violations don't cause build to fail, or error, in which case violations cause build to fail.

O detalhamento da saída da compilação não afeta se as violações de regra são mostradas.The verbosity of the build output does not affect whether rule violations are shown. Mesmo com detalhes silenciosos , violações de regra aparecem na saída da compilação.Even with quiet verbosity, rule violations appear in the build output.

Dica

Se você estiver acostumado a executar a análise herdada na linha de comando, seja com FxCopCmd.exe ou por meio do MSBuild com o sinalizador RunCodeAnalysis , veja como fazer isso com analisadores de código.If you're accustomed to running legacy analysis from the command line, either with FxCopCmd.exe or through msbuild with the RunCodeAnalysis flag, here's how to do that with code analyzers.

Para ver as violações do analisador na linha de comando ao compilar seu projeto usando o MSBuild, execute um comando como este:To see analyzer violations at the command line when you build your project using msbuild, run a command like this:

msbuild myproject.csproj /target:rebuild /verbosity:minimal

A imagem a seguir mostra a saída da compilação de linha de comando da criação de um projeto que contém uma violação de regra do analisador:The following image shows the command-line build output from building a project that contains an analyzer rule violation:

Saída do MSBuild com violação de regra

Projetos dependentesDependent projects

Em um projeto do .NET Core, se você adicionar uma referência a um projeto que tenha analisadores NuGet, esses analisadores serão automaticamente adicionados ao projeto dependente.In a .NET Core project, if you add a reference to a project that has NuGet analyzers, those analyzers are automatically added to the dependent project too. Para desabilitar esse comportamento, por exemplo, se o projeto dependente for um projeto de teste de unidade, marque o pacote NuGet como privado no arquivo . csproj ou . vbproj do projeto referenciado definindo o atributo PrivateAssets :To disable this behavior, for example if the dependent project is a unit test project, mark the NuGet package as private in the .csproj or .vbproj file of the referenced project by setting the PrivateAssets attribute:

<PackageReference Include="Microsoft.CodeAnalysis.FxCopAnalyzers" Version="2.9.0" PrivateAssets="all" />

Confira tambémSee also