Regras de qualidade de código
A análise de código do .NET fornece regras que visam melhorar a qualidade do código. Essas regras são organizadas em áreas como design, globalização, desempenho e segurança. Algumas regras são específicas para o uso da API do .NET, enquanto outras tratam da qualidade geral do código.
Índice de regras
A tabela a seguir lista as regras de análise de qualidade de código.
| ID da regra e aviso | Descrição |
|---|---|
| CA1000: Não declarar membros estáticos em tipos genéricos | Quando um membro estático de um tipo genérico é chamado, o argumento de tipo deve ser especificado para o tipo. Quando um membro de instância genérico que não dá suporte à inferência é chamado, o argumento de tipo deve ser especificado para o membro. Nesses dois casos, a sintaxe para especificar o argumento de tipo é diferente e facilmente confundida. |
| CA1001: Tipos com campos descartáveis devem ser descartáveis | Uma classe declara e implementa um campo de instância que é um tipo System.IDisposable, e a classe não implementa IDisposable. Uma classe que declara um campo IDisposable indiretamente possui um recurso não gerenciado e deve implementar a interface IDisposable. |
| CA1002: Não expor listas genéricas | A System.Collections.Generic.List<(Of <(T>)>) é uma coleção genérica projetada para desempenho, não para herança. Por isso, List não contém membros virtuais. As coleções genéricas projetadas para herança devem ser expostas em seu lugar. |
| CA1003: Usar instâncias do manipulador de eventos genérico | Um tipo contém um representante que retorna nulo, cuja assinatura contém dois parâmetros (o primeiro um objeto e o segundo um tipo atribuível a EventArgs), e o destino do assembly de contenção é o Microsoft .NET Framework 2.0. |
| CA1005: Evitar parâmetros excessivos em tipos genéricos | Quanto mais parâmetros de tipo um tipo genérico contiver, mais difícil será saber e lembrar-se do que cada parâmetro de tipo representa. Geralmente, a função é óbvia com um parâmetro de tipo, como em List<T>, e em certos casos com dois parâmetros de tipo, como em Dictionary<TKey, TValue>. No entanto, se houver mais de dois parâmetros de tipo, a dificuldade ficará muito grande para a maioria dos usuários. |
| CA1008: Enumerações devem ter valor zero | O valor padrão de uma enumeração não inicializada, assim como o de outros tipos de valor, é zero. Uma enumeração atribuída por nonflags deve definir um membro usando o valor de zero de forma que o valor padrão seja um valor válido da enumeração. Se uma enumeração que tem o atributo FlagsAttribute aplicado definir um membro com valor, seu nome deverá ser “None” para indicar que nenhum valor foi definido na enumeração. |
| CA1010: Coleções devem implementar uma interface genérica | Para ampliar a usabilidade de uma coleção, implemente uma das interfaces da coleção genéricas. Em seguida, a coleção pode ser usada para popular tipos de coleção genéricos. |
| CA1012: tipos abstratos não devem ter construtores públicos | Construtores em tipos abstratos só podem ser chamados por tipos derivados. Como construtores públicos criam instâncias de um tipo e não é possível criar instâncias de um tipo abstrato, um tipo abstrato com um construtor público é projetado incorretamente. |
| CA1014: Marcar assemblies com CLSCompliantAttribute | A CLS (Common Language Specification) define restrições de nomenclatura, tipos de dados e regras que assemblies deverão respeitar se forem usados em todas as linguagens de programação. Um bom design determina que todos os assemblies indiquem explicitamente a conformidade com CLS usando-se CLSCompliantAttribute. Se esse atributo não estiver presente em um assembly, o assembly não será compatível. |
| CA1016: Marcar assemblies com AssemblyVersionAttribute | O .NET usa o número da versão para identificar exclusivamente um assembly e fazer a associação com tipos em assemblies fortemente nomeados. O número de versão é usado com a versão e a política do publicador. Por padrão, os aplicativos só são executados com a versão do assembly com que foram criados. |
| CA1017: Marcar assemblies com ComVisibleAttribute | ComVisibleAttribute determina como clientes COM acessam código gerenciado. Um bom design determina que os assemblies indiquem explicitamente a visibilidade de COM. A visibilidade de COM pode ser definida para todo o assembly e, em seguida, substituída por tipos individuais e membros de tipo. Caso esse atributo não esteja presente, o conteúdo do assembly permanece visível aos clientes COM. |
| CA1018: Marcar atributos com AttributeUsageAttribute | Ao definir um atributo personalizado, você o marca usando AttributeUsageAttribute para indicar onde o atributo personalizado pode ser aplicado no código-fonte. O significado e o uso desejado de um atributo determinarão seus locais válidos no código. |
| CA1019: Definir acessadores para argumentos de atributo | Os atributos podem definir argumentos obrigatórios que devem ser especificados quando você aplica o atributo a um destino. Eles também são conhecidos como argumentos posicionais porque são fornecidos a construtores de atributos como parâmetros posicionais. Para cada argumento obrigatório, o atributo também deve fornecer uma propriedade somente leitura correspondente de forma que o valor do argumento possa ser recuperado no tempo de execução. Os atributos também podem definir argumentos opcionais, que também são conhecidos como argumentos nomeados. Esses argumentos são fornecidos a construtores de atributo por nome e devem ter uma propriedade de leitura/gravação correspondente. |
| CA1021: Evitar parâmetros out | A passagem de tipos por referência (usando out ou ref) requer experiência com ponteiros, compreensão das diferenças entre tipos de valor e tipos de referência e os métodos de tratamento com vários valores de retorno. Além disso, a diferença entre parâmetros out e ref não é amplamente compreendida. |
| CA1024: Usar propriedades quando apropriado | Um método público ou protegido tem um nome que começa com "Get", não utiliza parâmetros e retorna um valor que não é uma matriz. O método pode ser um bom candidato a se tornar uma propriedade. |
| CA1027: Marcar enumerações com FlagsAttribute | Uma enumeração é um tipo de valor que define um conjunto de constantes nomeadas relacionadas. Aplique FlagsAttribute a uma enumeração quando suas constantes nomeadas puderem ser combinadas de maneira significativa. |
| CA1028: O armazenamento de enumerações deve ser Int32 | Uma enumeração é um tipo de valor que define um conjunto de constantes nomeadas relacionadas. Por padrão, o tipo de dados System.Int32 é usado para armazenar o valor constante. Embora seja possível alterar esse tipo subjacente, isso não é necessário ou recomendado na maioria dos cenários. |
| CA1030: Usar eventos quando apropriado | Essa regra detecta métodos que têm nomes que seriam usados normalmente em eventos. Se um método for chamado em resposta a uma alteração de estado claramente definida, o método deverá ser invocado por um manipulador de eventos. Os objetos que chamam o método devem acionar eventos, em vez de chamar o método diretamente. |
| CA1031: Não capturar tipos de exceção geral | As exceções gerais não devem ser capturadas. Capture uma exceção mais específica ou relance a exceção geral como a última instrução no bloco de captura. |
| CA1032: Implementar construtores de exceção padrão | Deixar de fornecer o conjunto completo de construtores pode dificultar o tratamento correto das exceções. |
| CA1033: Métodos de interface devem ser chamados por tipos filho | Um tipo visível externamente sem lacre fornece uma implementação de método explícita de uma interface pública e não fornece um método visível externamente alternativo com o mesmo nome. |
| CA1034: Tipos aninhados não devem ser visíveis | Um tipo aninhado é um tipo declarado no escopo de outro tipo. Os tipos aninhados são úteis para encapsular detalhes de implementação privados do tipo de contenção. Usados para essa finalidade, os tipos aninhados não devem ser visíveis externamente. |
| CA1036: Substituir métodos em tipos comparáveis | Um público ou um tipo protegido implementa a interface System.IComparable. Ele não substitui Object.Equals nem sobrecarrega o operador específico da linguagem para igualdade, desigualdade, menor que ou maior que. |
| CA1040: Evitar interfaces vazias | As interfaces definem os membros que fornecem um contrato de comportamento ou de uso. A funcionalidade descrita pela interface pode ser adotada por qualquer tipo, independentemente de onde o tipo seja exibido na hierarquia de herança. Um tipo implementa uma interface fornecendo implementações para os membros da interface. Uma interface vazia não define membros; por isso, ela não define um contrato que pode ser implementado. |
| CA1041: Fornecer a mensagem ObsoleteAttribute | Um tipo ou um membro é marcado usando-se um atributo System.ObsoleteAttribute que não tem sua propriedade ObsoleteAttribute.Message especificada. Quando um tipo ou um membro marcado usando-se ObsoleteAttribute é compilado, a propriedade Message do atributo é exibida. Isso dá ao usuário informações sobre o tipo ou o membro obsoleto. |
| CA1043: Usar argumento integral ou de cadeia de caracteres para indexadores | Os indicadores (ou seja, propriedades indexadas) devem usar tipos integrais ou de cadeia de caracteres no índice. Esses tipos normalmente são usados na indexação de estruturas de dados e aumentam a usabilidade da biblioteca. O uso do tipo Object deve ser restrito a esses casos em que o tipo integral ou de cadeia de caracteres específico não pode ser especificado no tempo de design. |
| CA1044: Propriedades não devem ser somente gravação | Embora seja aceitável e normalmente necessário ter uma propriedade somente leitura, as diretrizes de design proíbem o uso de propriedades somente gravação. Isso é porque a permissão para que um usuário defina um valor e o impedimento posterior para ele exiba esse valor não dão nenhuma segurança. Além disso, sem acesso de leitura, o estado de objetos compartilhados não pode ser exibido, o que limita sua utilidade. |
| CA1045: Não passar tipos por referência | A passagem de tipos por referência (usando out ou ref) requer experiência com ponteiros, compreensão das diferenças entre tipos de valor e tipos de referência e os métodos de tratamento que têm vários valores de retorno. Os arquitetos de bibliotecas com designs que visam um público geral não devem esperar que os usuários se tornem proficientes em trabalhar com parâmetros out ou ref. |
| CA1046: Não sobrecarregar o operador equals em tipos de referência | Para tipos de referência, a implementação padrão do operador de igualdade está quase sempre correta. Por padrão, duas referências só serão iguais se apontarem para o mesmo objeto. |
| CA1047: Não declarar membros protegidos em tipos selados | Os tipos declaram membros protegidos de forma que a herança de tipos possa acessar ou substituir o membro. Por definição, os tipos vedados não podem ser lacrados, o que significa que os métodos protegidos em tipos lacrados não podem ser chamados. |
| CA1050: Declarar tipos em namespaces | Tipos são declarados em namespaces para evitar conflitos de nome e são uma maneira de organizar tipos relacionados em uma hierarquia de objetos. |
| CA1051: Não declarar campos de instância visíveis | O principal uso de um campo deve ser um como um detalhe da implementação. Os campos devem ser privados ou internos e devem ser expostos usando-se propriedades. |
| CA1052: Tipos de suporte estático devem ser selados | Um tipo público ou protegido contém apenas membros estáticos e não é declarado usando-se o modificador (Reference do C#) (NotInheritable). Um tipo que não é deve ser herdado deve ser marcado usando-se o modificador lacrado para evitar seu uso como um tipo de base. |
| CA1053: Tipos de suporte estático não devem ter construtores | Um tipo público ou público aninhado declara apenas membros estáticos e tem um construtor padrão público ou protegido. O construtor é desnecessário porque chamar membros estáticos não exige uma instância do tipo. A sobrecarga de cadeia de caracteres deve chamar a sobrecarga do URI (Uniform Resource Identifier) usando-se o argumento de cadeia de caracteres por questões de segurança. |
| CA1054: Parâmetros de URI não devem ser cadeias de caracteres | Se um método utilizar uma representação de cadeia de caracteres de um URI, uma sobrecarga correspondente deverá ser fornecida utilizando uma instância da classe do URI, que oferece esses serviços de maneira segura e protegida. |
| CA1055: Valores de retorno de URI não devem ser cadeias de caracteres | Esta regra pressupõe que o método retorne um URI. Uma representação de cadeia de caracteres de um URI está propensa a erros de análise e de codificação, e pode resultar em vulnerabilidades de segurança. A classe System.Uri fornece esses serviços de maneira segura. |
| CA1056: Propriedades de URI não devem ser cadeias de caracteres | Esta regra pressupõe que a propriedade represente o URI. Uma representação de cadeia de caracteres de um URI está propensa a erros de análise e de codificação, e pode resultar em vulnerabilidades de segurança. A classe System.Uri fornece esses serviços de maneira segura. |
| CA1058: Tipos não devem estender determinados tipos base | Um tipo visível externamente estende determinados tipos de base. Use uma das alternativas. |
| CA1060: mover P/Invokes para a classe NativeMethods | O código não gerenciado pode ser acessado por métodos de invocação de plataforma, como aqueles marcados com o atributo System.Runtime.InteropServices.DllImportAttribute, ou métodos definidos com a palavra-chave Declare no Visual Basic. Esses métodos devem ser da classe NativeMethods, SafeNativeMethods ou UnsafeNativeMethods. |
| CA1061: Não ocultar métodos de classe base | Um método em um tipo de base permanece oculto por um método nomeado identicamente em um tipo derivado, quando a assinatura do parâmetro do método derivado difere apenas pelos tipos derivados de maneira mais fraca do que os tipos correspondentes na assinatura do parâmetro do método de base. |
| CA1062: Validar argumentos de métodos públicos | Todos os argumentos de referência passados para os métodos visíveis externamente devem ser verificados em relação que serão nulos. |
| CA1063: Implementar IDisposable corretamente | Todos os tipos IDisposable devem implementar o padrão Dispose corretamente. |
| CA1064: Exceções devem ser públicas | Uma exceção interna só permanece visível dentro do próprio escopo interno. Depois que a exceção falha fora do escopo interno, somente a exceção de base pode ser usada para capturar a exceção. Se a exceção interna for herdada de Exception, SystemException ou ApplicationException, o código externo não terá informações suficientes para saber o que fazer com a exceção. |
| CA1065: Não acionar exceções em locais inesperados | Um método que não deve acionar exceções aciona uma exceção. |
| CA1066: Implementar IEquatable ao substituir Equals | Um tipo de valor substitui o método Equals, mas não implementa IEquatable<T>. |
| CA1067: Substituir Equals ao implementar IEquatable | Um tipo implementa IEquatable<T>, mas não substitui o método Equals. |
| CA1068: Os parâmetros CancellationToken devem vir por último | Um método tem um parâmetro CancellationToken que não é o último parâmetro. |
| CA1069: Enumerações não devem ter valores duplicados | Uma enumeração tem diversos membros explicitamente atribuídos ao mesmo valor de constante. |
| CA1070: Não declarar os campos de evento como virtuais | Um evento do tipo campo foi declarado como virtual. |
| CA1200: Evitar o uso de marcas cref com um prefixo | O atributo cref em uma marca de documentação XML significa "referência de código". Ele especifica que o texto interno da marca é um elemento de código, como um tipo, método ou propriedade. Evite usar marcas cref com prefixos, pois isso impede que o compilador verifique as referências. Também impede que o IDE (ambiente de desenvolvimento integrado) do Visual Studio localize e atualize essas referências de símbolo durante refatorações. |
| CA1303: Não passar literais como parâmetros localizados | Um método visível externamente transmite um literal de cadeia de caracteres como um parâmetro para um construtor ou método do .NET e essa cadeia de caracteres deve ser localizável. |
| CA1304: Especificar CultureInfo | Um método ou um construtor chama um membro que tem uma sobrecarga que aceita um parâmetro System.Globalization.CultureInfo, e o método ou o construtor não chama a sobrecarga que utiliza o parâmetro CultureInfo. Quando um objeto CultureInfo ou System.IFormatProvider não for fornecido, o valor padrão fornecido pelo membro sobrecarregado poderá não ter o efeito desejado em todas as localidades. |
| CA1305: Especificar IFormatProvider | Um método ou um construtor chama um ou mais membros que têm sobrecargas que aceitam um parâmetro System.IFormatProvider, e o método ou o construtor não chama a sobrecarga que utiliza o parâmetro IFormatProvider. Quando um objeto System.Globalization.CultureInfo ou System.IFormatProvider não for fornecido, o valor padrão fornecido pelo membro sobrecarregado poderá não ter o efeito desejado em todas as localidades. |
| CA1307: Especificar StringComparison para garantir a clareza | Uma operação de comparação de cadeia de caracteres usa uma sobrecarga de método que não define um parâmetro StringComparison. |
| CA1308: Normalizar cadeias de caracteres em maiúsculas | As cadeias de caracteres devem ser normalizadas em maiúsculas. Um pequeno grupo de caracteres não pode fazer uma viagem de ida e volta quando são convertidos em minúsculas. |
| CA1309: Usar StringComparison ordinal | Uma operação de comparação de cadeia de caracteres não linguística não define o parâmetro StringComparison como Ordinal ou OrdinalIgnoreCase. Definindo-se explicitamente o parâmetro como StringComparison.Ordinal ou StringComparison.OrdinalIgnoreCase, o código normalmente ganha velocidade, fica mais correto e se torna mais confiável. |
| CA1310: Especificar StringComparison para garantir a exatidão | Uma operação de comparação de cadeia de caracteres usa uma sobrecarga de método que não define um parâmetro StringComparison e usa, por padrão, uma comparação de cadeia de caracteres específica da cultura. |
| CA1311: Especificar uma cultura ou usar uma versão invariável | Especifique uma cultura ou use uma cultura invariável para evitar a dependência implícita da cultura atual ao chamar ToUpper ou ToLower. |
| CA1401: os P/Invokes não devem estar visíveis | Um método público ou protegido em um tipo público tem o atributo System.Runtime.InteropServices.DllImportAttribute (também implementado pela palavra-chave Declare no Visual Basic). Esses métodos não devem ser expostos. |
| CA1416: validar a compatibilidade da plataforma | O uso de APIs dependentes de plataforma em um componente faz com que o código não funcione mais em todas as plataformas. |
CA1417: não usar OutAttribute em parâmetros de cadeia de caracteres para P/Invokes |
Parâmetros de cadeia de caracteres transmitidos por valor com OutAttribute podem desestabilizar o runtime quando a cadeia de caracteres é interna. |
| CA1418: usar uma cadeia de caracteres de plataforma válida | O analisador de compatibilidade de plataforma requer um nome e uma versão de plataforma válidos. |
| CA1419: fornecer um construtor sem parâmetros que seja tão visível quanto o tipo de contenção para tipos concretos derivados de 'System.Runtime.InteropServices.SafeHandle' | Fornecer um construtor sem parâmetros que seja tão visível quanto o tipo contido para um tipo derivado de System.Runtime.InteropServices.SafeHandle permite melhor desempenho e uso com soluções de interoperabilidade geradas pela origem. |
| CA1420: propriedade, tipo ou atributo requer marshaling de runtime | O uso de recursos que exigem marshaling no runtime, quando o marshaling de runtime está desabilitado, resulta em exceções de runtime. |
| CA1421: o método usa marshalling de runtime quando DisableRuntimeMarshallingAttribute é aplicado | Um método usa marshaling de runtime e o marshaling de runtime está explicitamente desabilitado. |
| CA1422: validar a compatibilidade da plataforma | Não é recomendável chamar uma API de obsoleta em um determinado sistema operacional (versão) de um site de chamada acessível por meio desse sistema operacional (versão). |
| CA1501: Evitar herança excessiva | Um tipo está mais de quatro níveis abaixo na hierarquia de herança. As hierarquias de tipo profundamente aninhado podem ser difíceis de seguir, compreender e manter. |
| CA1502: Evitar complexidade excessiva | Esta regra mede o número de caminhos linearmente independentes por meio do método, o que é determinado pelo número e pela complexidade das ramificações condicionais. |
| CA1505: Evitar código de difícil manutenção | Um tipo ou um método tem um baixo valor de índice de facilidade de manutenção. Um baixo índice de facilidade de manutenção indica que um tipo ou um método é provavelmente difícil de manter e seria um bom candidato para um novo design. |
| CA1506: Evitar acoplamento de classes excessivo | Esta regra mede o acoplamento de classes contando o número de referências de tipo exclusivas que um tipo ou um método contém. |
| CA1507: Usar nameof no lugar da cadeia de caracteres | Um literal de cadeia de caracteres é usado como um argumento em que uma expressão nameof pode ser usada. |
| CA1508: Evitar código condicional morto | Um método tem um código condicional que é sempre avaliado para true ou false no runtime. Isso leva a um código morto na ramificação false da condição. |
| CA1509: Entrada inválida no arquivo de configuração de métrica de código | Regras de métricas de código, como CA1501, CA1502, CA1505 e CA1506, forneceram um arquivo de configuração nomeado CodeMetricsConfig.txt que tem uma entrada inválida. |
| CA1510: Usar o auxiliar de lançamento ArgumentNullException | Os auxiliares de lançamento são mais simples e eficientes do que if blocos que constrói uma nova instância de exceção. |
| CA1511: Usar o auxiliar de lançamento argumentException | Os auxiliares de lançamento são mais simples e eficientes do que if blocos que constrói uma nova instância de exceção. |
| CA1512: Usar o auxiliar de lançamento ArgumentOutOfRangeException | Os auxiliares de lançamento são mais simples e eficientes do que blocos if que constrói uma nova instância de exceção. |
| CA1513: Usar o auxiliar de lançamento ObjectDisposedException | Os auxiliares de lançamento são mais simples e eficientes do que blocos if que constrói uma nova instância de exceção. |
| CA1514: evite argumento de comprimento redundante | Um argumento de comprimento redundante é usado ao dividir até o final de uma cadeia de caracteres ou buffer. Um comprimento calculado pode ser propenso a erro e também é desnecessário. |
| CA1515: Considere tornar os tipos públicos internos | Ao contrário de uma biblioteca de classes, a API de um aplicativo normalmente não é referenciada publicamente, portanto, os tipos podem ser marcados como internos. |
| CA1700: Não nomear valores de enumeração 'Reserved' | Esta regra pressupõe que um membro da enumeração que tenha um nome que contém "reserved" não é usado atualmente, mas é um espaço reservado a ser renomeado ou removido em uma versão futura. Renomear ou remover um membro é uma alteração drástica. |
| CA1707: Identificadores não devem conter sublinhados | Por convenção, os nomes de identificador não contêm o caractere de sublinhado (_). Esta regra verifica namespaces, tipos, membros e parâmetros. |
| CA1708: Identificadores devem ser diferentes em algo além das maiúsculas e minúsculas | Os identificadores de namespaces, tipos, membros e parâmetros não podem se diferenciar apenas por maiúsculas porque linguagens com o Common Language Runtime como destino não precisam diferenciar maiúsculas e minúsculas. |
| CA1710: Identificadores devem ter um sufixo correto | Por convenção, os nomes de tipos que estendem determinados tipos de base ou que implementam determinadas interfaces, ou tipos derivados desses tipos, têm um sufixo associado ao tipo de base ou à interface. |
| CA1711: Identificadores não devem ter um sufixo incorreto | Por convenção, apenas os nomes de tipos que estendem determinados tipos de base ou que implementam determinadas interfaces, ou tipos derivados desses tipos, devem terminar com sufixos reservados específicos. Outros nomes de tipo não devem usar esses sufixos reservados. |
| CA1712: Não prefixar valores de enumeração com um nome de tipo | Os nomes dos membros de enumeração não são prefixados usando-se o nome de tipo porque as ferramentas de desenvolvimento devem fornecer informações de tipo. |
| CA1713: Eventos não devem ter o prefixo anterior ou posterior | O nome de um evento começa com "Before" ou "After". Para nomear eventos relacionados acionados em uma sequência específica, use o presente ou o pretérito para indicar a posição relativa na sequência de ações. |
| CA1714: Enumerações de sinalizador devem ter nomes no plural | Uma enumeração pública tem o atributo System.FlagsAttribute, e seu nome não termina com "s". Tipos marcados usando FlagsAttribute têm nomes que estão no plural porque o atributo indica que mais de um valor pode ser especificado. |
| CA1715: Identificadores devem ter um prefixo correto | O nome de uma interface visível externamente não começa com "I" em maiúsculas. O nome de um parâmetro de tipo genérico em um tipo visível externamente ou método não começa com um "T" em maiúsculas. |
| CA1716: Identificadores não devem corresponder a palavras-chave | Um nome de namespace ou um nome de tipo corresponde a uma palavra-chave reservada em uma linguagem de programação. Os identificadores de namespaces e tipos não devem corresponder a palavras-chave definidas por com o Common Language Runtime como destino. |
| CA1717: Apenas enumerações FlagsAttribute devem ter nomes no plural | As convenções de nomenclatura determinam que um nome no plural para uma enumeração indica que mais de um valor de enumeração pode ser especificado ao mesmo tempo. |
| CA1720: Identificadores não devem conter nomes de tipos | O nome de um parâmetro em um membro visível externamente contém um nome de tipo de dados, ou o nome de um membro visível externamente contém um nome de tipo de dados específico da linguagem. |
| CA1721: Nomes de propriedades não devem corresponder a métodos get | O nome de um membro público ou protegido começa com "Get" e, de outra forma, corresponde ao nome de uma propriedade pública ou protegida. Métodos "Get" e propriedades devem ter nomes que diferenciem claramente a função. |
| CA1724: Nomes de tipos não devem corresponder a namespaces | Os nomes de tipo não devem corresponder aos nomes dos namespaces do .NET. A violação dessa regra pode reduzir a usabilidade da biblioteca. |
| CA1725: Nomes de parâmetros devem corresponder à declaração base | A nomenclatura consistente dos parâmetros em uma hierarquia de substituição aumenta a usabilidade das substituições de método. Um nome de parâmetro em um método derivado diferente do nome na declaração de base pode causar confusão em relação à possibilidade do método ser uma substituição do método de base ou de uma nova sobrecarga do método. |
| CA1727: usar PascalCase para espaços reservados nomeados | Usar PascalCase para espaços reservados nomeados no modelo de mensagem de registro em log. |
| CA1801: Examinar parâmetros não utilizados | Uma assinatura de método inclui um parâmetro que não é usado no corpo do método. |
| CA1802: Usar literais quando apropriado | Um campo é declarado estático e somente leitura (Shared e ReadOnly no Visual Basic) e é inicializado usando um valor que é computável no runtime. Como o valor atribuído ao campo de destino é computável no tempo de compilação, altere a declaração para um campo “const” (Const no Visual Basic) a fim de que o valor seja calculado no tempo de compilação em vez de no runtime. |
| CA1805: Não inicializar desnecessariamente | O runtime do .NET inicializa todos os campos de tipos de referência com os valores padrão antes de executar o construtor. Na maioria dos casos, a inicialização explícita de um campo com seu valor padrão é redundante, o que aumenta os custos de manutenção e pode prejudicar o desempenho (como com o aumento do tamanho do assembly). |
| CA1806: Não ignorar resultados do método | Um novo objeto é criado, mas nunca é usado; ou um método que cria e retorna uma nova cadeia de caracteres é chamado e a nova cadeia de caracteres jamais é usada; um método ou COM ou P/Invoke retorna um HRESULT ou um código de erro que nunca é usado. |
| CA1810: Inicializar campos estáticos de tipo de referência em linha | Quando um tipo declara um construtor estático explícito, o compilador JIT (just-in-time) adiciona uma verificação a cada método estático e construtor de instância do tipo para garantir que o construtor estático tenha sido chamado anteriormente. As verificações de construtor estático podem diminuir o desempenho. |
| CA1812: Evitar classes internas sem instâncias | Uma instância de um tipo no nível de assembly não é criada pelo código no assembly. |
| CA1813: Evitar atributos não selados | O .NET fornece métodos para recuperar atributos personalizados. Por padrão, esses métodos pesquisam a hierarquia de herança do atributo. A validação do atributo elimina a pesquisa na hierarquia de herança e pode melhorar o desempenho. |
| CA1814: Preferir matrizes denteadas a matrizes multidimensionais | Uma matriz denteada é uma matriz cujos elementos são matrizes. As matrizes que constituem os elementos podem ter tamanhos diferentes, o que leva a menos espaço desperdiçado para alguns conjuntos de dados. |
| CA1815: Substituir equals e o operador equals em tipos de valor | Para tipos de valor, a implementação herdada de Equals usa a biblioteca Reflection e compara o conteúdo de todos os campos. Reflection é computacionalmente cara, e pode ser desnecessário comparar a igualdade de cada campo. Se você espera que os usuários comparem ou classifiquem instâncias, ou usem instâncias como chaves de tabela de hash, o tipo de valor deverá implementar Equals. |
| CA1816: Chamar GC.SuppressFinalize corretamente | Um método que é uma implementação de Dispose não chama GC.SuppressFinalize; ou um método que não é uma implementação de Dispose chama GC.SuppressFinalize; ou um método chama GC.SuppressFinalize e passa algo que não seja isso (Me no Visual Basic). |
| CA1819: Propriedades não devem retornar matrizes | As matrizes retornadas por propriedades não estão protegidas contra a gravação, mesmo quando a propriedade é somente leitura. Para manter a matriz à prova de adulteração, a propriedade deve retornar uma cópia da matriz. Normalmente, os usuários não compreenderão as implicações adversas no desempenho de chamar uma propriedade assim. |
| CA1820: Testar para verificar se há cadeias de caracteres vazias usando o tamanho da cadeia de caracteres | A comparação de cadeias de caracteres usando-se a propriedade String.Length ou o método String.IsNullOrEmpty é significativamente mais rápida do que o uso de Equals. |
| CA1821: Remover finalizadores vazios | Sempre que possível, evite finalizadores por conta da sobrecarga adicional no desempenho envolvida no acompanhamento do tempo de vida do objeto. Um finalizador vazio incorre na sobrecarga adicionada e não oferece benefícios. |
| CA1822: Marcar membros como estáticos | Os membros que não acessam dados de instância ou chamam métodos de instância podem ser marcados como estáticos (Shared no Visual Basic). Depois que você marcar os métodos como estáticos, o compilador emitirá sites de chamada não virtuais para esses membros. Isso pode proporcionar um ganho de desempenho mensurável para o código sensível ao desempenho. |
| CA1823: Evitar campos particulares não utilizados | Foram detectados campos particulares que aparentemente não são acessados no assembly. |
| CA1824: Marque assemblies com NeutralResourcesLanguageAttribute | O atributo NeutralResourcesLanguage informa ao gerenciador de recursos a linguagem usada para exibir os recursos de uma cultura neutra para um assembly. Isso melhora o desempenho da pesquisa para o primeiro recurso carregado e pode reduzir o conjunto de trabalho. |
| CA1825: Evitar alocações de matriz de comprimento zero | Inicializar uma matriz de comprimento zero leva à alocação de memória desnecessária. Em vez disso, use a instância de matriz vazia alocada estaticamente chamando Array.Empty. A alocação de memória é compartilhada em todas as invocações desse método. |
| CA1826: Usar a propriedade em vez do método Linq Enumerable | O método LINQ Enumerable foi usado em um tipo que dá suporte a uma propriedade equivalente e mais eficiente. |
| CA1827: Não usar Count/LongCount quando Any puder ser usado | O método Count ou LongCount foi usado quando o método Any seria mais eficiente. |
| CA1828: Não usar CountAsync/LongCountAsync quando AnyAsync puder ser usado | O método CountAsync ou LongCountAsync foi usado quando o método AnyAsync seria mais eficiente. |
| CA1829: Usar a propriedade Length/Count em vez do método Enumerable.Count | O método LINQ Count foi usado em um tipo que dá suporte a uma propriedade Length ou Count equivalente e mais eficiente. |
| CA1830: Preferir os métodos Acrescentar e Inserir fortemente tipados provoca uma sobrecarga no StringBuilder | Tanto Append quanto Insert fornecem sobrecargas para diversos tipos além de String. Quando possível, prefira as sobrecargas fortemente tipadas, em vez de usar ToString() e a sobrecarga baseada em cadeia de caracteres. |
| CA1831: Usar AsSpan em vez de indexadores baseados em intervalo na cadeia de caracteres quando apropriado | Ao usar um indexador de intervalo em uma cadeia de caracteres e atribuir implicitamente o valor ao tipo <char> ReadOnlySpan, o método Substring é usado em vez de Slice, que produz uma cópia da parte solicitada da cadeia de caracteres. |
| CA1832: Usar AsSpan ou AsMemory em vez de indexadores baseados em intervalo para obter a parte ReadOnlySpan ou ReadOnlyMemory de uma matriz | Ao usar um indexador de intervalo em uma matriz e atribuir implicitamente o valor a um tipo ReadOnlySpan<T> ou ReadOnlyMemory<T>, o método GetSubArray é usado em vez de Slice, que produz uma cópia da parte solicitada da matriz. |
| CA1833: Usar AsSpan ou AsMemory em vez de indexadores baseados em intervalo para obter a parte Span ou Memory de uma matriz | Ao usar um indexador de intervalo em uma matriz e atribuir implicitamente o valor a um tipo Span<T> ou Memory<T>, o método GetSubArray é usado em vez de Slice, que produz uma cópia da parte solicitada da matriz. |
| CA1834: usar StringBuilder.Append (char) para cadeias de caracteres únicas | StringBuilder tem uma sobrecarga Append que utiliza char como argumento. Priorize chamar a sobrecarga char por motivos de desempenho. |
| CA1835: priorizar as sobrecargas baseadas em 'Memory' para 'ReadAsync' e 'WriteAsync' | 'Stream' tem uma sobrecarga 'ReadAsync' que utiliza um 'Memory<Byte>' como o primeiro argumento e uma sobrecarga 'WriteAsync' que usa um 'ReadOnlyMemory<Byte>' como o primeiro argumento. Priorize chamar as sobrecargas baseadas em memória, que são mais eficientes. |
CA1836: priorizar IsEmpty em vez de Count sempre que disponível |
Priorize a propriedade IsEmpty que é mais eficiente do que Count, Length, Count<TSource>(IEnumerable<TSource>) ou LongCount<TSource>(IEnumerable<TSource>) para determinar se o objeto contém ou não algum item. |
CA1837: usar Environment.ProcessId em vez de Process.GetCurrentProcess().Id |
Environment.ProcessId é mais simples e rápido do que Process.GetCurrentProcess().Id. |
CA1838: evitar parâmetros StringBuilder para P/Invokes |
O marshaling de 'StringBuilder' sempre cria uma cópia de buffer nativa, que resulta em diversas alocações para uma operação de marshaling. |
| CA1839: usar Environment.ProcessPath em vez de Process.GetCurrentProcess().MainModule.FileName | Environment.ProcessPath é mais simples e rápido do que Process.GetCurrentProcess().MainModule.FileName. |
| CA1840: usar Environment.CurrentManagedThreadId em vez de Thread.CurrentThread.ManagedThreadId | Environment.CurrentManagedThreadId é mais compacto e eficiente do que Thread.CurrentThread.ManagedThreadId. |
| CA1841: preferir métodos Dictionary Contains | Chamar Contains a coleção or Values geralmente pode ser mais caro Keys do que chamar ContainsKey ou ContainsValue no próprio dicionário. |
| CA1842: não usar 'WhenAll' com uma única tarefa | O uso WhenAll com uma única tarefa pode resultar em perda de desempenho. Aguarde ou retorne a tarefa. |
| CA1843: não usar 'WaitAll' com uma tarefa única | O uso WaitAll com uma única tarefa pode resultar em perda de desempenho. Aguarde ou retorne a tarefa. |
| CA1844: fornecer substituições baseadas em memória dos métodos assíncronos ao subclassificar 'Stream' | Para melhorar o desempenho, substitua os métodos assíncronos baseados em memória ao subclassificar 'Stream'. Em seguida, implemente os métodos baseados em matriz com relação aos métodos baseados em memória. |
| CA1845: usar 'string.Concat' com base em span | É mais eficiente usar AsSpan e string.Concat, em vez de Substring e um operador de concatenação. |
CA1846: priorizar AsSpan em vez de Substring |
AsSpan é mais eficiente do que Substring. Substring executa uma cópia de cadeia de caracteres O(n), enquanto AsSpan não o faz e tem um custo constante. AsSpan também não executa alocações de heap. |
| CA1847: usar literal char para uma pesquisa de caractere único | Use String.Contains(char) em vez de String.Contains(string) ao pesquisar um único caractere. |
| CA1848: usar os representantes de LoggerMessage | Para melhorar o desempenho, use os representantes LoggerMessage. |
| CA1849: chamar métodos assíncronos quando em um método assíncrono | Em um método que já é assíncrono, as chamadas para outros métodos devem ser feitas para as versões assíncronas, quando existentes. |
CA1850: priorizar o método HashData estático em vez de ComputeHash |
É mais eficiente usar o método HashData estático em vez de criar e gerenciar uma instância HashAlgorithm para chamar ComputeHash. |
CA1851: diversas enumerações da coleção IEnumerable são possíveis |
Diversas enumerações da coleção IEnumerable são possíveis. Considere usar uma implementação que evite diversas enumerações. |
| CA1852: selar tipos internos | Um tipo que não é acessível fora de seu assembly e não tem subtipos dentro de seu assembly que contém não está selado. |
| CA1853: chamada desnecessária para 'Dictionary.ContainsKey(key)' | Não há necessidade de proteger Dictionary.Remove(key) com Dictionary.ContainsKey(key). Dictionary<TKey,TValue>.Remove(TKey) já verifica se a chave existe e não é lançada se ela não existe. |
| CA1854: priorizar o método 'IDictionary.TryGetValue(TKey, out TValue)' | Priorize 'TryGetValue' em vez de um acesso de indexador Dictionary protegido por uma verificação 'ContainsKey'. 'ContainsKey' e o indexador pesquisam a chave, portanto, usar 'TryGetValue' evita a pesquisa extra. |
| CA1855: Usar Span<T>.Clear() em vez de Span<T>.Fill() | É mais eficiente chamar Span<T>.Clear() do que chamar Span<T>.Fill(T) para preencher os elementos do intervalo com um valor padrão. |
| CA1856: Uso incorreto do atributo ConstantExpected | O atributo ConstantExpectedAttribute não é aplicado corretamente em um parâmetro. |
| CA1857: O parâmetro espera uma constante para um desempenho ideal | Um argumento inválido é passado para um parâmetro que é anotado com ConstantExpectedAttribute. |
| CA1858: usar "StartsWith" em vez de "IndexOf" | É mais eficiente chamar String.StartsWith do que chamar String.IndexOf para verificar se uma cadeia de caracteres começa com um determinado prefixo. |
| CA1859: Usar tipos concretos quando possível para aprimorar o desempenho | O código usa tipos de interface ou tipos abstratos, levando a chamadas de interface ou chamadas virtuais desnecessárias. |
| CA1860: evite usar o método de extensão 'Enumerable.Any()' | É mais eficiente e mais claro usar Length, Count ou IsEmpty (se possível) do que chamar Enumerable.Any para determinar se um tipo de coleção tem algum elemento. |
| CA1861: Evitar matrizes constantes como argumentos | Matrizes constantes passadas como argumentos não são reutilizadas, o que implica em uma sobrecarga de desempenho. Considere extraí-las para campos "estáticos somente leitura" para aprimorar o desempenho. |
| CA1862: use as sobrecargas do método "StringComparison" para executar comparações de cadeia de caracteres que não diferenciam maiúsculas de minúsculas | Quando o código chama ToLower() ou ToUpper() para executar uma comparação de cadeia de caracteres que não diferencia maiúsculas de minúsculas, há a execução de uma alocação desnecessária. |
| CA1863: use "CompositeFormat" | Para reduzir o custo de formatação, armazene em cache e use uma instância CompositeFormat como argumento para String.Format ou StringBuilder.AppendFormat. |
| CA1864: preferir o método 'IDictionary.TryAdd(TKey, TValue)' method | Dictionary<TKey,TValue>.ContainsKey(TKey)e Dictionary<TKey,TValue>.Add executam uma pesquisa, o que é redundante. É mais eficiente chamar Dictionary<TKey,TValue>.TryAdd, que retorna um bool que indica se o valor foi adicionado ou não. TryAdd não sobrescreve o valor da chave se a chave já estiver presente. |
| CA1865-CA1867: usar sobrecarga de char | A sobrecarga de char é uma sobrecarga de melhor desempenho para uma cadeia de caracteres com um único char. |
| CA1868: Chamada desnecessária a "Contains" para conjuntos | Ambos ISet<T>.Add(T) e ICollection<T>.Remove(T) executam uma pesquisa, o que o torna redundante chamar ICollection<T>.Contains(T) com antecedência. É mais eficiente chamar Add(T) ou Remove(T) diretamente, o que retorna um valor booliano que indica se o item foi adicionado ou removido. |
| CA1869: armazenar em cache e reutilizar instâncias de "JsonSerializerOptions" | O uso de uma instância local de JsonSerializerOptions para serialização ou desserialização pode prejudicar substancialmente o desempenho do aplicativo se o código for executado várias vezes, já que System.Text.Json armazena internamente metadados relacionados à serialização na instância fornecida. |
| CA1870: usar uma instância de "SearchValues" armazenada em cache | Usar uma instância de SearchValues<T> armazenada em cache é mais eficiente do que passar valores para 'IndexOfAny' ou 'ContainsAny' diretamente. |
| CA1871: Não passar um struct anulável para 'ArgumentNullException.ThrowIfNull' | 'ArgumentNullException.ThrowIfNull' aceita um 'objeto', portanto, passar um struct anulável pode fazer com que o valor seja convertido. |
| CA1872: prefira 'Convert.ToHexString' e 'Convert.ToHexStringLower' em vez de cadeias de chamadas baseadas em 'BitConverter.ToString' | Use Convert.ToHexString ou Convert.ToHexStringLower ao codificar bytes para uma representação de cadeia de caracteres hexadecimal. Esses métodos são mais eficientes e fáceis de alocar do que usar BitConverter.ToString em combinação com String.Replace para substituir traços e String.ToLower. |
| CA2000: Descartar objetos antes de perder o escopo | Como pode ocorrer um evento excepcional que impedirá a execução do finalizador de um objeto, o objeto deve ser explicitamente descartado antes que todas as referências a ele estejam fora do escopo. |
| CA2002: Não bloquear objetos com identidade fraca | Diz-se que um objeto tem uma identidade fraca quando puder ser acessado diretamente em todos os limites de domínio do aplicativo. Um thread que tente adquirir um bloqueio em um objeto com uma identidade fraca pode ser bloqueado por um segundo thread em um domínio de aplicativo diferente com um bloqueio no mesmo objeto. |
| CA2007: não aguardar diretamente uma tarefa | Um método assíncrono aguarda um Task diretamente. Quando um método assíncrono aguarda um Task diretamente, a continuação ocorre no mesmo thread que criou a tarefa. Esse comportamento pode ser caro em termos de desempenho e pode resultar em um deadlock no thread da IU. Considere chamar Task.ConfigureAwait(Boolean) para sinalizar sua intenção de continuar. |
| CA2008: Não criar tarefas sem passar um TaskScheduler | Uma operação de criação ou continuação de tarefa usa uma sobrecarga de método que não especifica um parâmetro TaskScheduler. |
| CA2009: Não chamar ToImmutableCollection em um valor ImmutableCollection | O método ToImmutable foi chamado desnecessariamente em uma coleção imutável do namespace System.Collections.Immutable. |
| CA2011: Não atribuir a propriedade em seu próprio setter | Uma propriedade recebeu acidentalmente um valor dentro de seu próprio acessador de conjunto. |
| CA2012: Usar ValueTasks corretamente | As ValueTasks retornadas de invocações de membros devem ser aguardadas diretamente. Tentativas de consumir um ValueTask várias vezes ou acessar diretamente o resultado antes que ele seja concluído podem resultar em uma exceção ou corrupção. Ignorar esse ValueTask provavelmente é uma indicação de um bug funcional e pode degradar o desempenho. |
| CA2013: Não usar ReferenceEquals com tipos de valor | Ao comparar valores usando System.Object.ReferenceEquals, se objA e objB forem tipos de valor, eles serão colocados em caixas antes de serem transmitidos ao método ReferenceEquals. Isso significa que, mesmo que objA e objB representem a mesma instância de um tipo de valor, o método ReferenceEquals retorna false. |
| CA2014: não usar stackalloc em loops. | O espaço de pilha alocado por um stackalloc só é liberado no final da invocação do método atual. Usá-lo em um loop pode resultar em crescimento de pilha ilimitado e em eventuais condições de estouro de pilha. |
| CA2015: não definir finalizadores para tipos derivados de MemoryManager<T> | Adicionar um finalizador a um tipo derivado de MemoryManager<T> pode permitir que a memória seja liberada enquanto ainda está em uso por um Span<T>. |
| CA2016: Encaminhe o parâmetro CancellationToken para os métodos que recebem um | Encaminhe o parâmetro CancellationToken para os métodos que o usam a fim de garantir que as notificações de cancelamento de operação sejam propagadas corretamente ou transmita CancellationToken.None explicitamente para indicar que o token não será propagado intencionalmente. |
| CA2017: incompatibilidade de contagem de parâmetros | O número de parâmetros fornecido no modelo de mensagem de registro em log não corresponde ao número de espaços reservados nomeados. |
CA2018: o argumento count para Buffer.BlockCopy deve especificar o número de bytes a serem copiados |
Ao usar Buffer.BlockCopy, o argumento count especifica o número de bytes a serem copiados. Você só deve usar Array.Length para o argumento count em matrizes com elementos que têm exatamente um byte de tamanho. As matrizes byte, sbyte e bool têm elementos com o tamanho de um byte. |
CA2019: os campos ThreadStatic não devem usar inicialização embutida |
Um campo anotado com ThreadStaticAttribute é inicializado em linha ou explicitamente em um construtor static (Shared no Visual Basic). |
| CA2020: impedir alteração comportamental causada por operadores internos de IntPtr/UIntPtr | Alguns operadores internos adicionados ao .NET 7 se comportam de forma diferente dos operadores definidos pelo usuário no .NET 6 e versões anteriores. Alguns operadores que costumavam gerar contexto desmarcado durante o estouro não são mais gerados, a menos que estejam encapsulados dentro do contexto verificado. Alguns operadores que anteriormente não lançavam o contexto verificado agora são lançados, a menos que estejam encapsulados dentro do contexto desmarcado. |
| CA2021: não chame Enumerable.Cast<T> ou Enumerable.OfType<T> com tipos incompatíveis | Uma chamada a Enumerable.Cast<TResult>(IEnumerable) ou Enumerable.OfType<TResult>(IEnumerable) especifica um parâmetro de tipo que é incompatível com o tipo da coleção de entrada. |
| CA2022: Evitar leitura inexata com Stream.Read | Uma chamada para pode retornar menos bytes do que o Stream.Read solicitado, resultando em código não confiável se o valor retornado não for verificado. |
| CA2100: Examinar consultas SQL em busca de vulnerabilidades de segurança | Um método define a propriedade System.Data.IDbCommand.CommandText usando uma cadeia de caracteres criada com base em um argumento da cadeia de caracteres para o método. Esta regra pressupõe que o argumento da cadeia de caracteres contenha a entrada do usuário. Uma cadeia de caracteres de comando SQL criada com base na entrada do usuário é vulnerável a ataques de injeção SQL. |
| CA2101: especificar marshaling para argumentos de cadeia de caracteres P/Invoke | Um membro de invocação da plataforma permite chamadores parcialmente confiáveis, tem um parâmetro de cadeia de caracteres e não realiza marshaling da cadeia de caracteres explicitamente. Isso pode causar uma vulnerabilidade de segurança em potencial. |
| CA2109: Examinar manipuladores de eventos visíveis | Um método público ou protegido de tratamento de eventos foi detectado. Os métodos de tratamento de eventos não devem ser expostos, a menos que seja absolutamente necessário. |
| CA2119: Selar métodos que atendem a interfaces particulares | Um tipo público herdável fornece uma implementação de método substituível de uma interface (Friend no Visual Basic) interna. Para corrigir uma violação dessa regra, evite que o método seja substituído fora do assembly. |
| CA2153: Evitar tratamento de Exceções de Estado Corrompido | As CSE (exceções de estado corrompido) indicam que há corrupção de memória no processo. Capturá-las em vez de permitir que o processo falhe pode levar a vulnerabilidades de segurança, pois um invasor poderia colocar um exploit na região da memória corrompida. |
| CA2200: Relançar para preservar detalhes da pilha | Uma exceção é lançada novamente e a exceção é especificada explicitamente na instrução throw. Se uma exceção for lançada novamente pela especificação da exceção na instrução throw, a lista de chamadas de método entre o método original que lançou a exceção e o método atual será perdida. |
| CA2201: Não acionar tipos de exceção reservados | Isso torna o erro original difícil de detectar e depurar. |
| CA2207: Inicializar campos estáticos de tipo de valor em linha | Um tipo de valor declara um construtor estático explícito. Para corrigir uma violação dessa regra, inicialize todos os dados estáticos quando declarados e remova o construtor estático. |
| CA2208: Criar instância de exceções de argumento corretamente | Uma chamada é feita para o construtor padrão (sem parâmetros) de um tipo de exceção que é ou deriva de , ou um argumento de cadeia de ArgumentExceptioncaracteres incorreto é passado para um construtor parametrizado de um tipo de exceção que é ou deriva de ArgumentException. |
| CA2211: Campos não constantes não devem ser visíveis | Os campos estáticos que não são constantes nem somente leitura não são thread-safe. O acesso a esse campo deve ser controlado cuidadosamente e exige técnicas de programação avançadas para sincronizar o acesso ao objeto da classe. |
| CA2213: Campos descartáveis devem ser descartados | Um tipo que implementa System.IDisposable declara campos que são de tipos que também implementam IDisposable. O método Dispose do campo não é chamado pelo método Dispose do tipo declarante. |
| CA2214: Não chamar métodos substituíveis em construtores | Quando um construtor chama um método virtual, o construtor da instância que invoca o método pode não ter sido executado. |
| CA2215: Métodos Dispose devem chamar o descarte da classe base | Se for herdado de um tipo descartável, um tipo deverá chamar o método Dispose do tipo de base em seu próprio método Dispose. |
| CA2216: Tipos descartáveis devem declarar o finalizador | Um tipo que implementa System.IDisposable e tem campos que sugerem o uso de recursos não gerenciados não implementa um finalizador, conforme descrito por Object.Finalize. |
| CA2217: Não marcar enumerações com FlagsAttribute | Uma enumeração visível externamente é marcada usando-se FlagsAttribute e tem um ou mais valores que não são potências de dois ou uma combinação dos outros valores definidos na enumeração. |
| CA2218: Substituir GetHashCode ao substituir Equals | Um tipo público substitui System.Object.Equals, mas não substitui System.Object.GetHashCode. |
| CA2219: Não acionar exceções em cláusulas de exceção | Quando uma exceção é acionada em uma cláusula finally ou fault, a nova exceção oculta a exceção ativa. Quando uma exceção é acionada em uma cláusula de filtro, runtime a captura silenciosamente. Isso torna o erro original difícil de detectar e depurar. |
| CA2224: Substituir equals ao sobrecarregar operador equals | Um tipo público implementa o operador de igualdade, mas não substitui System.Object.Equals. |
| CA2225: Sobrecargas de operador têm alternativas nomeadas | Uma sobrecarga de operador foi detectada, e o método alternativo nomeado esperado não foi encontrado. O membro alternativo nomeado fornece acesso à mesma funcionalidade que o operador, e é fornecido para desenvolvedores que programem em linguagens que não dão suporte a operadores sobrecarregados. |
| CA2226: Operadores devem ter sobrecargas simétricas | Um tipo implementa o operador de igualdade ou de desigualdade e não implementa o operador oposto. |
| CA2227: Propriedades de coleção devem ser somente leitura | Uma propriedade collection gravável permite que um usuário substitua a coleção por uma coleção diferente. Uma propriedade somente leitura evita que a coleção seja substituída, mas ainda permite que membros individuais sejam definidos. |
| CA2229: Implementar construtores de serialização | Para corrigir uma violação dessa regra, implemente o construtor de serialização. Para uma classe lacrada, torne o construtor particular; do contrário, deixe-o protegido. |
| CA2231: Sobrecarregar operador equals ao substituir ValueType.Equals | Um tipo de valor substitui Object.Equals, mas não implementa o operador de igualdade. |
| CA2234: Passar objetos System.Uri em vez de cadeias de caracteres | Foi feita uma chamada para um método com um parâmetro de cadeia de caracteres cujo nome contém "uri", "URI", "urn", "URN", "url" ou "URL". O tipo declarante do método contém uma sobrecarga do método correspondente que possui um parâmetro System.Uri. |
| CA2235: Marcar todos os campos não serializáveis | Um campo de instância de um tipo que não seja serializável é declarado em um tipo que é serializável. |
| CA2237: Marcar tipos ISerializable com SerializableAttribute | Para serem reconhecidos pelo Common Language Runtime como serializáveis, os tipos devem ser marcados usando-se o atributo SerializableAttribute, mesmo quando o tipo usa uma rotina de serialização personalizada por meio da implementação da interface ISerializable. |
| CA2241: Fornecer argumentos corretos para métodos de formatação | O argumento format passado para System.String.Format não contém um item de formato correspondente a cada argumento do objeto ou vice-versa. |
| CA2242: Testar para NaN corretamente | Essa expressão testa um valor em Single.Nan ou Double.Nan. Use Single.IsNan (único) ou Double.IsNan (duplo) para testar o valor. |
| CA2243: Literais de cadeias de caracteres de atributo devem ser analisados corretamente | O parâmetro literal da cadeia de caracteres de um atributo não é analisado corretamente para uma URL, um GUID ou uma versão. |
| CA2244: Não duplicar inicializações de elementos indexados | Um inicializador de objeto tem mais de um inicializador de elemento indexado com o mesmo índice de constante. Todos, exceto o último inicializador, são redundantes. |
| CA2245: Não atribuir uma propriedade a si mesma | Uma propriedade foi acidentalmente atribuída a si mesma. |
| CA2246: Não designar um símbolo e o membro dele na mesma instrução | Não é recomendado atribuir um símbolo e seu membro, ou seja, um campo ou uma propriedade, na mesma instrução. Não está claro se o acesso do membro visava usar o valor antigo do símbolo antes da atribuição ou o novo valor da atribuição nesta instrução. |
| CA2247: o argumento transmitido para o construtor TaskCompletionSource deve ser a enumeração TaskCreationOptions em vez de a enumeração TaskContinuationOptions. | TaskCompletionSource tem construtores que usam TaskCreationOptions para controlar a tarefa subjacente e construtores que usam o estado do objeto armazenado na tarefa. A transmissão acidental de TaskContinuationOptions em vez de TaskCreationOptions resultará na chamada tratando as opções como estado. |
| CA2248: Fornecer o argumento de enumeração correto para Enum.HasFlag | O tipo enumerado transmitido como argumento para a chamada do método HasFlag é diferente do tipo enumerado da chamada. |
| CA2249: Considerar o uso de String.Contains em vez de String.IndexOf | As chamadas para string.IndexOf, em que o resultado é usado para verificar a presença/ausência de uma substring, podem ser substituídas por string.Contains. |
CA2250: usar ThrowIfCancellationRequested |
ThrowIfCancellationRequested verifica automaticamente se o token foi cancelado e emite OperationCanceledException se isso aconteceu. |
CA2251: usar String.Equals em vez de String.Compare |
É mais claro e provavelmente mais rápido usar String.Equals em vez de comparar o resultado de String.Compare com zero. |
| CA2252: optar pela versão prévia dos recursos | Opte pela versão prévia dos recursos antes de usar APIs de versão prévia. |
| CA2253: espaços reservados nomeados não devem ser valores numéricos | Espaços reservados nomeados no modelo de mensagem de registro em log não devem ser compostos somente por caracteres numéricos. |
| CA2254: o modelo deve ser uma expressão estática | O modelo de mensagem de registro em log não deve variar entre as chamadas. |
CA2255: o atributo ModuleInitializer não deve ser usado em bibliotecas |
Os inicializadores de módulo devem ser usados pelo código do aplicativo para garantir que os componentes do aplicativo sejam inicializados antes do início da execução do código do aplicativo. |
| CA2256: todos os membros declarados nas interfaces pai devem ter uma implementação em uma interface atribuída a DynamicInterfaceCastableImplementation | Os tipos atribuídos com DynamicInterfaceCastableImplementationAttribute atuam como uma implementação de interface para um tipo que implementa o tipo IDynamicInterfaceCastable. Como resultado, deve ser fornecida uma implementação de todos os membros definidos nas interfaces herdadas, pois o tipo que implementa IDynamicInterfaceCastable não os fornecerá de outra forma. |
| CA2257: membros definidos em uma interface com 'DynamicInterfaceCastableImplementationAttribute' devem ser 'static' | Como um tipo que implementa pode não implementar uma interface dinâmica em metadados, as chamadas para um membro da IDynamicInterfaceCastable interface de instância que não é uma implementação explícita definida nesse tipo provavelmente falharão em tempo de execução. Marque novos membros da interface com static para evitar erros no runtime. |
| CA2258: não há suporte para o fornecimento de uma interface 'DynamicInterfaceCastableImplementation' no Visual Basic | Para fornecer uma interface funcional atribuída a DynamicInterfaceCastableImplementationAttribute, é necessário o recurso Membros de Interface Padrão, que não tem suporte no Visual Basic. |
CA2259: garantir que ThreadStatic seja usado apenas com campos estáticos |
ThreadStaticAttribute afeta apenas campos static (Shared no Visual Basic). Quando aplicado a campos de instância, o atributo não tem impacto sobre o comportamento. |
| CA2260: implementar interfaces matemáticas genéricas corretamente | As interfaces matemáticas genéricas exigem que o próprio tipo derivado seja usado para o parâmetro de tipo recorrente. |
CA2261: não use ConfigureAwaitOptions.SuppressThrowing com Task<TResult> |
A opção ConfigureAwaitOptions.SuppressThrowing não é compatível com o genérico Task<TResult>, pois isso pode levar ao retorno de um TResult inválido. |
CA2262: MaxResponseHeadersLength definido corretamente |
Certifique-se de que o valor MaxResponseHeadersLength tenha sido fornecido corretamente. Esse valor é medido em quilobytes. |
| CA2263: prefira sobrecarga genérica quando o tipo é conhecido | Usar uma sobrecarga genérica é preferível a passar um System.Type argumento quando o tipo é conhecido, pois eles promovem um código mais limpo e mais seguro para tipos com verificações aprimoradas em tempo de compilação. |
| CA2264: Não passar um valor não anulável para 'ArgumentNullException.ThrowIfNull' | 'ArgumentNullException.ThrowIfNull' é gerado quando o argumento passado é 'null'. Sabe-se que certas construções, como structs não anuláveis e expressões 'nameof()' e 'new', nunca são nulas, portanto, 'ArgumentNullException.ThrowIfNull' nunca será lançada. |
CA2265: Não comparar Span<T> ou nulldefault |
Comparar um intervalo com null ou default pode não fazer o que você pretendia. default e o null literal são implicitamente convertidos em Span<T>.Empty. |
| CA2300: Não usar o desserializador BinaryFormatter não seguro | Desserializadores não seguros são vulneráveis ao desserializar dados não confiáveis. Um invasor pode modificar os dados serializados visando incluir tipos inesperados para injetar objetos com efeitos colaterais mal-intencionados. |
| CA2301: Não chamar BinaryFormatter.Deserialize sem antes definir BinaryFormatter.Binder | Desserializadores não seguros são vulneráveis ao desserializar dados não confiáveis. Um invasor pode modificar os dados serializados visando incluir tipos inesperados para injetar objetos com efeitos colaterais mal-intencionados. |
| CA2302: Verificar se o BinaryFormatter.Binder está definido antes de chamar BinaryFormatter.Deserialize | Desserializadores não seguros são vulneráveis ao desserializar dados não confiáveis. Um invasor pode modificar os dados serializados visando incluir tipos inesperados para injetar objetos com efeitos colaterais mal-intencionados. |
| CA2305: Não usar o desserializador inseguro LosFormatter | Desserializadores não seguros são vulneráveis ao desserializar dados não confiáveis. Um invasor pode modificar os dados serializados visando incluir tipos inesperados para injetar objetos com efeitos colaterais mal-intencionados. |
| CA2310: Não usar o desserializador inseguro NetDataContractSerializer | Desserializadores não seguros são vulneráveis ao desserializar dados não confiáveis. Um invasor pode modificar os dados serializados visando incluir tipos inesperados para injetar objetos com efeitos colaterais mal-intencionados. |
| CA2311: Não desserializar sem definir primeiro NetDataContractSerializer.Binder | Desserializadores não seguros são vulneráveis ao desserializar dados não confiáveis. Um invasor pode modificar os dados serializados visando incluir tipos inesperados para injetar objetos com efeitos colaterais mal-intencionados. |
| CA2312: Verificar se NetDataContractSerializer.Binder foi definido antes de desserializar | Desserializadores não seguros são vulneráveis ao desserializar dados não confiáveis. Um invasor pode modificar os dados serializados visando incluir tipos inesperados para injetar objetos com efeitos colaterais mal-intencionados. |
| CA2315: Não usar o desserializador inseguro ObjectStateFormatter | Desserializadores não seguros são vulneráveis ao desserializar dados não confiáveis. Um invasor pode modificar os dados serializados visando incluir tipos inesperados para injetar objetos com efeitos colaterais mal-intencionados. |
| CA2321: Não desserializar com JavaScriptSerializer usando um SimpleTypeResolver | Desserializadores não seguros são vulneráveis ao desserializar dados não confiáveis. Um invasor pode modificar os dados serializados visando incluir tipos inesperados para injetar objetos com efeitos colaterais mal-intencionados. |
| CA2322: Garantir que o JavaScriptSerializer não seja inicializado com SimpleTypeResolver antes de desserializar | Desserializadores não seguros são vulneráveis ao desserializar dados não confiáveis. Um invasor pode modificar os dados serializados visando incluir tipos inesperados para injetar objetos com efeitos colaterais mal-intencionados. |
| CA2326: Não usar valores de TypeNameHandling diferentes de None | Desserializadores não seguros são vulneráveis ao desserializar dados não confiáveis. Um invasor pode modificar os dados serializados visando incluir tipos inesperados para injetar objetos com efeitos colaterais mal-intencionados. |
| CA2327: Não usar JsonSerializerSettings não seguras | Desserializadores não seguros são vulneráveis ao desserializar dados não confiáveis. Um invasor pode modificar os dados serializados visando incluir tipos inesperados para injetar objetos com efeitos colaterais mal-intencionados. |
| CA2328: Verificar se as JsonSerializerSettings são seguras | Desserializadores não seguros são vulneráveis ao desserializar dados não confiáveis. Um invasor pode modificar os dados serializados visando incluir tipos inesperados para injetar objetos com efeitos colaterais mal-intencionados. |
| CA2329: Não desserializar com JsonSerializer usando uma configuração não segura | Desserializadores não seguros são vulneráveis ao desserializar dados não confiáveis. Um invasor pode modificar os dados serializados visando incluir tipos inesperados para injetar objetos com efeitos colaterais mal-intencionados. |
| CA2330: Verificar se o JsonSerializer tem uma configuração segura durante a desserialização | Desserializadores não seguros são vulneráveis ao desserializar dados não confiáveis. Um invasor pode modificar os dados serializados visando incluir tipos inesperados para injetar objetos com efeitos colaterais mal-intencionados. |
| CA2350: verifique se a entrada do DataTable.ReadXml() é confiável | Quando você desserializa um DataTable com entrada não confiável, um invasor pode criar uma entrada mal-intencionada para executar um ataque de negação de serviço. Pode haver vulnerabilidades desconhecidas de execução remota de código. |
| CA2351: verifique se a entrada do DataSet.ReadXml() é confiável | Quando você desserializa um DataSet com entrada não confiável, um invasor pode criar uma entrada mal-intencionada para executar um ataque de negação de serviço. Pode haver vulnerabilidades desconhecidas de execução remota de código. |
| CA2352: DataSet ou DataTable não seguros no tipo serializável podem ser vulneráveis a ataques de execução de código remoto | Uma classe ou um struct marcado com SerializableAttribute contém um campo ou propriedade DataSet ou DataTable e não tem um GeneratedCodeAttribute. |
| CA2353: DataSet ou DataTable não seguros no tipo serializável | Uma classe ou um struct marcado com um atributo de serialização XML ou um atributo de contrato de dados contém um campo ou propriedade DataSet ou DataTable. |
| CA2354: DataSet ou DataTable não seguros no grafo de objetos desserializados podem ser vulneráveis a ataques de execução de código remoto | Desserialização com um System.Runtime.Serialization.IFormatter serializado, em que o grafo de objetos do tipo convertido pode incluir DataSet ou DataTable. |
| CA2355: DataSet ou DataTable não seguros no grafo de objetos desserializados | Desserialização quando o grafo de objetos do tipo convertido ou especificado pode incluir DataSet ou DataTable. |
| CA2356: DataSet ou DataTable não seguro no grafo de objetos desserializados da Web | Um método com um System.Web.Services.WebMethodAttribute ou System.ServiceModel.OperationContractAttribute tem um parâmetro que pode fazer referência a um DataSet ou DataTable. |
| CA2361: verifique se a classe gerada automaticamente que contém DataSet.ReadXml() não é usada quando os dados não são confiáveis | Quando você desserializa um DataSet com entrada não confiável, um invasor pode criar uma entrada mal-intencionada para executar um ataque de negação de serviço. Pode haver vulnerabilidades desconhecidas de execução remota de código. |
| CA2362: DataSet ou DataTable não seguros em um tipo serializável gerado automaticamente podem ser vulneráveis a ataques de execução remota de código | Desserialização de uma entrada não confiável com BinaryFormatter, em que o grafo de objetos desserializados contém DataSet ou DataTable e um invasor pode criar um conteúdo mal-intencionado para executar um ataque de execução de código remoto. |
| CA3001: Examinar código quanto a vulnerabilidades de injeção de SQL | Ao trabalhar com comandos SQL e de entrada não confiáveis, tenha atenção quanto a ataques de injeção de SQL. Um ataque de injeção de SQL pode executar comandos SQL mal-intencionados que comprometem a segurança e a integridade do aplicativo. |
| CA3002: Examinar código quanto a vulnerabilidades de XSS | Ao trabalhar com entradas não confiáveis de solicitações da Web, tenha atenção quanto a ataques XSS (cross-site scripting). Um ataque XSS injeta uma entrada não confiável na saída HTML bruta, a fim de que o invasor execute scripts mal-intencionados ou modifique maliciosamente conteúdos em sua página da Web. |
| CA3003: Examinar código quanto a vulnerabilidades de injeção de caminho | Ao trabalhar com entradas não confiáveis de solicitações da Web, lembre-se de usar a entrada controlada pelo usuário ao especificar caminhos para arquivos. |
| CA3004: Examinar código quanto a vulnerabilidades de divulgação de informações | A divulgação de informações de exceção fornece aos invasores insights sobre a parte interna do aplicativo, o que pode ajudá-los a encontrar outras vulnerabilidades a serem exploradas. |
| CA3005: Examinar o código para vulnerabilidades de injeção de LDAP | Ao trabalhar com entrada não confiável, esteja atento aos ataques de injeção do protocolo LDAP (Lightweight Directory Access Protocol). Um invasor pode executar instruções LDAP mal-intencionadas em diretórios de informações. Os aplicativos que usam a entrada do usuário para construir instruções LDAP dinâmicas para acessar serviços de diretório são particularmente vulneráveis. |
| CA3006: Examinar código quanto a vulnerabilidades de injeção de comando de processo | Ao trabalhar com entradas não confiáveis, tenha atenção quanto a ataques de injeção de comando. Um ataque de injeção de comando pode executar comandos mal-intencionados no sistema operacional subjacente, comprometendo a segurança e a integridade do servidor. |
| CA3007: Examinar código quanto a vulnerabilidades de redirecionamento aberto | Ao trabalhar com entradas não confiáveis, tenha atenção quanto a vulnerabilidades de redirecionamento aberto. Um invasor pode explorar uma vulnerabilidade de redirecionamento aberto usando seu site para dar a aparência de uma URL legítima, mas realizando o redirecionamento dos visitantes desavisados para uma página da Web de phishing ou mal-intencionada. |
| CA3008: Examinar código quanto a vulnerabilidades de injeção de XPath | Ao trabalhar com entradas não confiáveis, tenha atenção quanto a ataques de injeção de XPath. A construção de consultas XPath usando entrada não confiável pode permitir que um invasor manipule maliciosamente a consulta para retornar um resultado não intencional e, possivelmente, divulgar o conteúdo do XML consultado. |
| CA3009: Examinar código quanto a vulnerabilidades de injeção de XML | Ao trabalhar com entradas não confiáveis, tenha atenção quanto a ataques de injeção de XML. |
| CA3010: Examinar código quanto a vulnerabilidades de injeção de XAML | Ao trabalhar com entradas não confiáveis, tenha atenção quanto a ataques de injeção de XAML. XAML é uma linguagem de marcação que representa diretamente a instanciação e execução de objetos. Isso significa que os elementos criados em XAML podem interagir com recursos do sistema (por exemplo, acesso à rede e E/S do sistema de arquivos). |
| CA3011: Examinar código quanto a vulnerabilidades de injeção de DLL | Ao trabalhar com entradas não confiáveis, tenha atenção quanto ao carregamento de códigos não confiáveis. Se o aplicativo Web carregar código não confiável, um invasor poderá injetar DLLs mal-intencionadas em seu processo e executar código mal-intencionado. |
| CA3012: Examinar código quanto a vulnerabilidades de injeção de regex | Ao trabalhar com entradas não confiáveis, tenha atenção quanto a ataques de injeção de regex. Um invasor pode usar a injeção de regex para modificar maliciosamente uma expressão regular, a fim de que ela corresponda a resultados não intencionais ou consuma CPU excessiva, resultando em um ataque de negação de serviço. |
| CA3061: Não adicionar esquema por URL | Não use a sobrecarga não segura do método Add porque isso pode causar referências externas perigosas. |
| CA3075: Processamento de DTD não seguro | Se você usar instâncias DTDProcessing inseguras ou fazer referência a fontes de entidade externa, o analisador poderá aceitar entrada não confiável e divulgar informações confidenciais aos invasores. |
| CA3076: Execução de script XSLT não seguro | Se você executar XSLT (Extensible Stylesheet Language Transformations) em aplicativos .NET de forma insegura, o processador poderá resolver referências de URI não confiáveis que podem divulgar informações confidenciais a invasores, levando a ataques de negação de serviço e entre sites. |
| CA3077: Processamento não seguro no design de API, no documento XML e no leitor de texto XML | Ao criar uma API derivada de XMLDocument e de XMLTextReader, tenha atenção quanto a DtdProcessing. O uso de instâncias DTDProcessing inseguras ao fazer referência ou resolver fontes de entidade externa ou definir valores inseguros no XML pode levar à divulgação de informações. |
| CA3147: Marcar manipuladores de verbo com ValidateAntiForgeryToken | Ao criar um controlador MVC do ASP.NET, tenha atenção quanto a ataques CSRF (solicitação intersite forjada). Um ataque de solicitação intersite forjada pode enviar solicitações mal-intencionadas de um usuário autenticado para o controlador MVC do ASP.NET. |
| CA5350: Não usar algoritmos de criptografia fracos | Algoritmos de criptografia fracos e funções de hash são usados hoje por vários motivos, mas não devem ser usados para garantir a confidencialidade ou integridade dos dados protegidos. Esta regra é disparada quando algoritmos TripleDES, SHA1 ou RIPEMD160 são localizados no código. |
| CA5351: não usar algoritmos de criptografia desfeitos | Algoritmos criptográficos desfeitos não são considerados seguros e seu uso é fortemente desencorajado. Esta regra é disparada quando o algoritmo de hash MD5 ou os algoritmos de criptografia DES ou RC2 são localizados no código. |
| CA5358: Não usar modos de criptografia não seguros | Não usar modos de criptografia não seguros |
| CA5359: Não desabilitar a validação de certificado | Um certificado pode ajudar a autenticar a identidade do servidor. Os clientes devem validar o certificado do servidor para garantir que as solicitações sejam enviadas ao servidor desejado. Se ServerCertificateValidationCallback sempre retornar true, qualquer certificado passará pela validação. |
| CA5360: Não chamar métodos perigosos durante a desserialização | A desserialização não segura é uma vulnerabilidade que ocorre quando dados não confiáveis são usados para abusar da lógica de um aplicativo, realizar um ataque DoS (negação de serviço) ou até mesmo executar códigos arbitrários após a desserialização. É muito provável que usuários mal-intencionados abusem desses recursos de desserialização quando o aplicativo está desserializando dados não confiáveis sob controle deles. Especificamente, a invocação de métodos perigosos no processo de desserialização. Ataques de desserialização não segura bem-sucedidos podem permitir que um invasor realize ataques DoS, bypasses de autenticação e execução de código remoto. |
| CA5361: Não desabilite o uso de criptografia forte do Schannel | A configuração de Switch.System.Net.DontEnableSchUseStrongCrypto como true enfraquece a criptografia usada em conexões TLS (Transport Layer Security) de saída. Uma criptografia mais fraca pode comprometer a confidencialidade da comunicação entre o aplicativo e o servidor, facilitando a escuta de dados confidenciais por invasores. |
| CA5362: Ciclo de referência potencial no grafo de objetos desserializado | Ao desserializar dados não confiáveis, qualquer código que processe o grafo de objetos desserializado precisará lidar com ciclos de referência sem entrar em loops infinitos. Isso inclui tanto o código que faz parte de um retorno de chamada de desserialização quanto aquele que processa o grafo de objetos após a conclusão da desserialização. Caso contrário, um invasor poderia executar um ataque de negação de serviço com dados mal-intencionados que contêm um ciclo de referência. |
| CA5363: Não desabilitar a validação de solicitação | A validação de solicitação é um recurso no ASP.NET que examina solicitações HTTP e determina se elas contêm conteúdos potencialmente perigosos que podem levar a ataques de injeção, incluindo cross-site scripting. |
| CA5364: Não use protocolos de segurança preteridos | O TLS (Transport Layer Security) protege a comunicação entre computadores, mais comumente com o HTTPS (Hypertext Transfer Protocol Secure). Versões mais antigas do protocolo TLS são menos seguras do que o TLS 1.2 e o TLS 1.3 e mais propensas a terem novas vulnerabilidades. Evite versões de protocolo mais antigas para minimizar o risco. |
| CA5365: Não desabilitar a verificação de cabeçalho HTTP | A verificação de cabeçalho HTTP permite a codificação do retorno de carro e dos caracteres de nova linha, \r e \n, encontrados em cabeçalhos de resposta. Essa codificação pode ajudar a evitar ataques de injeção que exploram um aplicativo que ecoa dados não confiáveis contidos no cabeçalho. |
| CA5366: Usar XmlReader para XML da leitura do conjunto de dados | Usar um DataSet para ler XML com dados não confiáveis pode carregar referências externas perigosas, que devem ser restritas usando um XmlReader com um resolvedor seguro ou com o processamento DTD desabilitado. |
| CA5367: Não serializar tipos com campos de ponteiro | Esta regra verifica se há uma classe serializável com uma propriedade ou um campo de ponteiro. Os membros que não podem ser serializados podem ser um ponteiro, como membros estáticos ou campos marcados com NonSerializedAttribute. |
| CA5368: Definir ViewStateUserKey para as classes derivadas da página | Definir a propriedade ViewStateUserKey pode ajudar a evitar ataques no aplicativo, pois permite atribuir um identificador à variável de estado de exibição para usuários individuais a fim de que invasores não possam usar a variável para gerar um ataque. Caso contrário, haverá vulnerabilidades relacionadas a solicitações intersite forjadas. |
| CA5369: Usar o XmlReader para desserializar | O processamento de esquemas DTD e XML não confiáveis pode permitir o carregamento de referências externas perigosas, que devem ser restritas usando um XmlReader com um resolvedor seguro ou com o processamento de esquema embutido DTD e XML desabilitado. |
| CA5370: Usar o XmlReader para validar o leitor | O processamento de esquemas DTD e XML não confiáveis pode permitir o carregamento de referências externas perigosas. Esse carregamento perigoso pode ser restringido usando um XmlReader com um resolvedor seguro ou o processamento de esquema embutido DTD e XML desabilitado. |
| CA5371: Usar o XmlReader para a leitura do esquema | O processamento de esquemas DTD e XML não confiáveis pode permitir o carregamento de referências externas perigosas. Usar um XmlReader com um resolvedor seguro ou o processamento de esquema embutido DTD e XML desabilitado ajuda a aplicar essa restrição. |
| CA5372: Usar o XmlReader para o XPathDocument | O processamento de XML de dados não confiáveis pode carregar referências externas perigosas, que podem ser restritas usando um XmlReader com um resolvedor seguro ou com o processamento DTD desabilitado. |
| CA5373: Não usar a função de derivação de chave obsoleta | Esta regra detecta a invocação de métodos System.Security.Cryptography.PasswordDeriveBytes e Rfc2898DeriveBytes.CryptDeriveKey de derivação de chave fraca. System.Security.Cryptography.PasswordDeriveBytes usou um algoritmo fraco PBKDF1. |
| CA5374: Não usar XslTransform | Esta regra verifica se System.Xml.Xsl.XslTransform criou uma instância no código. System.Xml.Xsl.XslTransform agora está obsoleto e não deve ser usado. |
| CA5375: Não usar a assinatura de acesso compartilhado da conta | Uma SAS de conta pode delegar acesso a operações de leitura, gravação e exclusão em contêineres de blob, tabelas, filas e compartilhamentos de arquivos que não têm permissão com uma SAS de serviço. No entanto, ela não dá suporte a políticas em nível de contêiner e tem menos flexibilidade e controle sobre as permissões concedidas. Se ela for obtida por usuários mal-intencionados, sua conta de armazenamento será comprometida facilmente. |
| CA5376: Usar SharedAccessProtocol HttpsOnly | A SAS é um dado confidencial que não pode ser transportado em texto sem formatação em HTTP. |
| CA5377: Usar política de acesso no nível de contêiner | Uma política de acesso em nível de contêiner pode ser modificada ou revogada a qualquer momento. Ela fornece maior flexibilidade e controle sobre as permissões concedidas. |
| CA5378: Não desabilite ServicePointManagerSecurityProtocols | A configuração de Switch.System.ServiceModel.DisableUsingServicePointManagerSecurityProtocols como true limita as conexões TLS do WCF (Windows Communication Framework) ao uso do TLS 1.0. Essa versão do TLS será preterida. |
| CA5379: não usar um algoritmo de função de derivação de chaves fraco | A classe Rfc2898DeriveBytes usa o algoritmo SHA1 como padrão. Você deve especificar o algoritmo de hash a ser usado em algumas sobrecargas do construtor com SHA256 ou superior. Observe que a propriedade HashAlgorithm tem apenas um acessador get e não tem um modificador overridden. |
| CA5380: Não adicionar certificados ao repositório raiz | Esta regra detecta o código que potencialmente adiciona um certificado ao repositório de certificados de Autoridades de Certificação Raiz Confiáveis. Por padrão, o repositório de certificados de Autoridades de Certificação Raiz Confiáveis é configurado com um conjunto de CAs públicas que atende aos requisitos do programa de certificado raiz da Microsoft. |
| CA5381: Verificar que os certificados não sejam adicionados ao repositório raiz | Esta regra detecta o código que potencialmente adiciona um certificado ao repositório de certificados de Autoridades de Certificação Raiz Confiáveis. Por padrão, o repositório de certificados de Autoridades de Certificação Raiz Confiáveis é configurado com um conjunto de CAs (autoridades de certificação) públicas que atende aos requisitos do programa de certificado raiz da Microsoft. |
| CA5382: Usar cookies seguros no ASP.NET Core | Os aplicativos disponíveis sobre HTTPS devem usar cookies seguros, que indicam ao navegador que o cookie só deve ser transmitido usando SSL (Secure Sockets Layer). |
| CA5383: Garantir o uso de cookies seguros no ASP.NET Core | Os aplicativos disponíveis sobre HTTPS devem usar cookies seguros, que indicam ao navegador que o cookie só deve ser transmitido usando SSL (Secure Sockets Layer). |
| CA5384: Não usar o DSA (algoritmo de assinatura digital) | O DSA é um algoritmo de criptografia assimétrica fraco. |
| CA5385: Usar o algoritmo RSA (Rivest–Shamir–Adleman) com um tamanho de chave suficiente | Uma chave RSA menor que 2048 bits é mais vulnerável a ataques de força bruta. |
| CA5386: Evitar codificar o valor SecurityProtocolType | O TLS (Transport Layer Security) protege a comunicação entre computadores, mais comumente com o HTTPS (Hypertext Transfer Protocol Secure). As versões do protocolo TLS 1.0 e TLS 1.1 são preteridas, enquanto o TLS 1.2 e o TLS 1.3 representam as atuais. No futuro, o TLS 1.2 e o TLS 1.3 podem ser preteridos. Para garantir que seu aplicativo permaneça seguro, evite codificar uma versão de protocolo e tenha em mente pelo menos o .NET Framework v4.7.1. |
| CA5387: Não usar a função de derivação de chaves fraca com uma contagem de iteração insuficiente | Esta regra verifica se uma chave criptográfica foi gerada por Rfc2898DeriveBytes com uma contagem de iteração inferior a 100.000. Uma contagem de iteração mais alta pode ajudar a atenuar os ataques de dicionário que tentam adivinhar a chave criptográfica gerada. |
| CA5388: Assegurar uma contagem de iteração suficiente ao usar a função de derivação de chaves fraca | Essa regra verifica se uma chave criptográfica foi gerada por Rfc2898DeriveBytes com uma contagem de iteração que pode ser inferior a 100.000. Uma contagem de iteração mais alta pode ajudar a atenuar os ataques de dicionário que tentam adivinhar a chave criptográfica gerada. |
| CA5389: Não adicionar o caminho do item de arquivo ao caminho do sistema de arquivos de destino | O caminho do arquivo pode ser relativo e resultar no acesso a um sistema de arquivos fora do caminho de destino esperado do sistema de arquivos, levando a alterações de configuração mal-intencionadas e execução de código remoto por meio da técnica de lay-and-wait. |
| CA5390: Não embutir a chave de criptografia em código | Para que um algoritmo simétrico seja bem-sucedido, a chave secreta deve ser conhecida apenas pelo remetente e pelo receptor. Quando uma chave é embutida no código, ela é facilmente descoberta. Mesmo com binários compilados, é fácil para usuários mal-intencionados extraí-la. Depois que a chave privada é comprometida, o texto de criptografia pode ser descriptografado diretamente e não está mais protegido. |
| CA5391: Usar tokens antifalsificação em controladores MVC do ASP.NET Core | Lidar com uma POSTsolicitação , PUT, PATCHou DELETE sem validar um token antifalsificação pode ser vulnerável a ataques de falsificação de solicitação entre sites. Um ataque de solicitação intersite forjada pode enviar solicitações mal-intencionadas de um usuário autenticado para o controlador MVC do ASP.NET Core. |
| CA5392: Usar o atributo DefaultDllImportSearchPaths para P/Invokes | Por padrão, as funções P/Invoke que usam DllImportAttribute investigam vários diretórios, incluindo o diretório de trabalho atual da biblioteca a ser carregada. Isso pode ser um problema de segurança para determinados aplicativos, levando ao sequestro de DLL. |
| CA5393: Não usar o valor DllImportSearchPath não seguro | Pode haver uma DLL mal-intencionada nos diretórios de pesquisa de DLL padrão e nos diretórios de assembly. Dependendo de onde o aplicativo é executado, também pode haver uma DLL mal-intencionada no diretório do aplicativo. |
| CA5394: Não usar aleatoriedade não segura | O uso de um gerador de números pseudo-aleatórios criptograficamente fraco pode permitir que um invasor preveja qual valor sensível à segurança será gerado. |
| CA5395: Ignorar o atributo HttpVerb para métodos de ação | Todos os métodos de ação que criam, editam, excluem ou modificam dados precisam ser protegidos com o atributo antifalsificação de ataques de solicitação intersite forjada. A execução de uma operação GET deve ser segura, não tem efeitos colaterais e não modifica os dados persistentes. |
| CA5396: Definir HttpOnly como true para HttpCookie | Como uma medida de defesa em profundidade, verifique se cookies HTTP sensíveis à segurança estão marcados como HttpOnly. Isso indica que os navegadores da Web não devem permitir que scripts acessem os cookies. Scripts mal-intencionados injetados são uma maneira comum de roubar cookies. |
| CA5397: Não usar valores de SslProtocols preteridos | O TLS (Transport Layer Security) protege a comunicação entre computadores, mais comumente com o HTTPS (Hypertext Transfer Protocol Secure). Versões mais antigas do protocolo TLS são menos seguras do que o TLS 1.2 e o TLS 1.3 e mais propensas a terem novas vulnerabilidades. Evite versões de protocolo mais antigas para minimizar o risco. |
| CA5398: Evitar valores de SslProtocols fixos | O TLS (Transport Layer Security) protege a comunicação entre computadores, mais comumente com o HTTPS (Hypertext Transfer Protocol Secure). As versões do protocolo TLS 1.0 e TLS 1.1 são preteridas, enquanto o TLS 1.2 e o TLS 1.3 representam as atuais. No futuro, o TLS 1.2 e o TLS 1.3 podem ser preteridos. Para garantir que o aplicativo permaneça seguro, evite codificar uma versão de protocolo. |
| CA5399: Desabilitar definitivamente a verificação da lista de certificados revogados do HttpClient | Um certificado revogado não é mais confiável. Ele pode ser usado por invasores que passam alguns dados mal-intencionados ou roubam dados confidenciais na comunicação HTTPS. |
| CA5400: Certificar-se de que a verificação da lista de certificados revogados do HttpClient não está desabilitada | Um certificado revogado não é mais confiável. Ele pode ser usado por invasores que passam alguns dados mal-intencionados ou roubam dados confidenciais na comunicação HTTPS. |
| CA5401: Não usar CreateEncryptor com IV não padrão | A criptografia simétrica sempre deve usar um vetor de inicialização que não possa ser repetido para evitar ataques de dicionário. |
| CA5402: Usar CreateEncryptor com o IV padrão | A criptografia simétrica sempre deve usar um vetor de inicialização que não possa ser repetido para evitar ataques de dicionário. |
| CA5403: Não embutir o certificado em código | O parâmetro data ou rawData de um construtor X509Certificate ou X509Certificate2 é codificado. |
| CA5404: não desabilitar as verificações de validação de token | As propriedades TokenValidationParameters que controlam a validação de token não devem ser definidas como false. |
| CA5405: nem sempre omitir a validação de token em representantes | O retorno de chamada atribuído a AudienceValidator ou LifetimeValidator sempre retorna true. |
| IL3000: evitar o acesso ao caminho do arquivo do Assembly ao publicar como um só arquivo | Evite acessar o caminho do arquivo do assembly ao publicar como um único arquivo. |
| IL3001: evitar o acesso ao caminho do arquivo do Assembly ao publicar como um só arquivo | Evite acessar o caminho do arquivo do assembly ao publicar como um único arquivo. |
| IL3002: evitar chamar membros anotados com 'RequiresAssemblyFilesAttribute' em publicações como um só arquivo | Evitar chamar membros anotados com 'RequiresAssemblyFilesAttribute' ao publicar como um único arquivo |
| As anotações IL3003: 'RequiresAssemblyFilesAttribute' devem ser correspondentes em todas as implementações ou substituições de interface. | As anotações 'RequiresAssemblyFilesAttribute' devem ser correspondentes em todas as implementações ou substituições de interface. |
Legenda
A tabela a seguir mostra o tipo de informação fornecida para cada regra na documentação de referência.
| Item | Descrição |
|---|---|
| Type | O TypeName da regra. |
| ID da regra | O identificador exclusivo da regra. RuleId e Category são usados para supressão de um aviso na origem. |
| Categoria | A categoria da regra, por exemplo, segurança. |
| A correção ocorre com interrupção ou sem interrupção | Se a correção de uma violação da regra é uma alteração interruptiva. Alteração interruptiva significa que um assembly que tem uma dependência no destino que causou a violação não será recompilado com a nova versão corrigida ou poderá falhar no runtime devido à alteração. Quando várias correções estão disponíveis e pelo menos uma correção é uma alteração interruptiva e uma não é, tanto 'Com interrupção' quanto 'Sem interrupção' são especificados. |
| Causa | O código gerenciado específico que faz com que a regra gere um aviso. |
| Descrição | Discute as questões que levaram ao aviso. |
| Como corrigir violações | Explica como alterar o código-fonte para atender à regra e impedir que ela gere um aviso. |
| Quando suprimir avisos | Descreve quando é seguro suprimir um aviso da regra. |
| Código de exemplo | Exemplos que violam a regra e exemplos corrigidos que atendem à regra. |
| Regras relacionadas | Regras relacionadas. |
Colaborar conosco no GitHub
A fonte deste conteúdo pode ser encontrada no GitHub, onde você também pode criar e revisar problemas e solicitações de pull. Para obter mais informações, confira o nosso guia para colaboradores.
