Regras de desempenho

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 em tempo de compilação, altere a declaração para um campo const (Const no Visual Basic) para que o valor seja computado em tempo de compilação em vez de em 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 internal não instanciadas	Uma instância de um tipo no nível do assembly não é criada por 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. Selar o atributo elimina a busca 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. A reflexão é computacionalmente dispendiosa, e comparar todos os campos para verificar a igualdade pode ser desnecessário. 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 entenderão os impactos negativos no desempenho ao acessar esse tipo de propriedade.
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 nem invocam 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 os 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 busca para o primeiro recurso que você carrega e pode reduzir o conjunto de trabalho.
CA1825: Evite alocações de matrizes 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: Use a propriedade em vez de método Enumerable do LINQ	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 com tipagem forte em vez de usar ToString() e a sobrecarga baseada em string.
CA1831: Usar AsSpan em vez de indexadores baseados em Range para string, 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 possui uma sobrecarga Append que recebe um 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 em invocações de P/Invoke	O empacotamento de StringBuilder sempre cria uma cópia nativa do buffer, resultando em múltiplas alocações para uma única operação de empacotamento.
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: Prefira os métodos Contains de Dictionary	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 devolva 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 devolva a tarefa em vez disso.
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 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 do assembly que o contém não é selado.
CA1853: Chamada desnecessária ao '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 gera erro caso ela não exista.
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 `static readonly` para melhorar o desempenho.
CA1862: Use as sobrecargas do método "StringComparison" para realizar comparações de cadeias de caracteres sem diferenciar 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)'	Ambos Dictionary<TKey,TValue>.ContainsKey(TKey) e Dictionary<TKey,TValue>.Add executam uma busca, 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 ao '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 estrutura anulável para 'ArgumentNullException.ThrowIfNull'	'ArgumentNullException.ThrowIfNull' aceita um 'objeto', portanto, passar uma estrutura anulável pode fazer com que o valor seja encapsulado.
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 mais favoráveis em termos de alocação do que usar BitConverter.ToString em combinação com String.Replace para substituir traços e String.ToLower.
CA1873: Evite registro em log potencialmente oneroso	Quando os métodos de registro em log são chamados, seus argumentos são avaliados independentemente de o nível de log estar habilitado. Isso pode resultar em operações caras sendo executadas mesmo quando a mensagem de log não será gravada. Para melhorar o desempenho, proteja chamadas de registro de alto custo com uma verificação IsEnabled ou utilize o padrão LoggerMessage.
CA1874: Usar 'Regex.IsMatch'	Regex.IsMatch é mais simples e rápido do que Regex.Match(...).Success.
CA1875: Usar 'Regex.Count'	Regex.Count é mais simples e rápido do que Regex.Matches(...).Count.
CA1877: Use sobrecargas 'Path.Combine' ou 'Path.Join'	Várias operações consecutivas Path.Combine ou Path.Join podem ser combinadas em uma única chamada usando sobrecargas capazes de aceitar múltiplos segmentos de caminho.
CA1878: Prefira propriedades do tipo ReadOnlySpan em vez de campos de matriz somente leitura	Um campo de matriz constante estático privado pode ser substituído por uma ReadOnlySpan<T> propriedade para que o compilador C# possa evitar uma alocação de matriz gerenciada.