Regras de desempenho

  • Artigo

As regras de desempenho dão suporte a bibliotecas e aplicativos de alto desempenho.

Nesta seção

Regra Descrição
CA1802: Usar literais quando apropriado Um campo é declarado estático e somente leitura (Shared e ReadOnly no Visual Basic) e é inicializado com um valor que é computável no tempo de compilação. 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, inicializar explicitamente um campo com o valor padrão é redundante, o que aumenta os custos de manutenção e pode prejudicar o desempenho (como no aumento do tamanho da montagem).
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 COM (Component Object Model) 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 pode resultar em 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.
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 adicional sem benefício algum.
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 Resource Manager 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 System.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 a um 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. Prefira chamar a sobrecarga de char para melhorar o 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 Muitas vezes, chamar Contains na coleção Keys ou Values pode ser mais caro do que chamar ContainsKey ou ContainsValue no próprio dicionário.
CA1842: não usar 'WhenAll' com uma única tarefa O uso de 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 de 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 passe uma struct anulável para 'ArgumentNullException.ThrowIfNull' 'ArgumentNullException.ThrowIfNull' aceita um 'objeto', portanto, passar uma struct anulável pode fazer com que o valor seja encaixotado.
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 alocáveis do que usar BitConverter.ToString em combinação com String.Replace para substituir traços e String.ToLower.