Regras de desempenho

As regras de desempenho suportam bibliotecas e aplicativos de alto desempenho.

Nesta secção

Regra	Description
CA1802: Use 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 em tempo de compilação. Como o valor atribuído ao campo alvo é computável em tempo de compilação, altera a declaração para um campo const (Const no Visual Basic) para que o valor seja calculado em tempo de compilação em vez de em tempo de execução.
CA1805: Não inicializar desnecessariamente	O tempo de execução do .NET inicializa todos os campos de tipos de referência para seus valores padrão antes de executar o construtor. Na maioria dos casos, inicializar explicitamente um campo com seu valor padrão é redundante, o que aumenta os custos de manutenção e pode degradar o desempenho (como com o aumento do tamanho da montagem).
CA1806: Não ignore os 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 nunca é usada, ou um método COM (Component Object Model) ou P/Invoke retorna um HRESULT ou código de erro que nunca é usado.
CA1810: Inicializar campos estáticos do tipo de referência embutidos	Quando um tipo declara um construtor estático explícito, o compilador just-in-time (JIT) adiciona uma verificação a cada método estático e construtor de instância do tipo para certificar-se de que o construtor estático foi chamado anteriormente. As verificações estáticas do construtor podem diminuir o desempenho.
CA1812: Evite classes internas não instanciadas	Uma instância de um tipo de nível de assembly não é criada por código no assembly.
CA1813: Evite 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 de atributos. A selagem do atributo elimina a pesquisa através da hierarquia de herança e pode melhorar o desempenho.
CA1814: Prefira matrizes irregulares em vez de multidimensionais	Uma matriz irregular é uma matriz cujos elementos são matrizes. As matrizes que compõem os elementos podem ser de tamanhos diferentes, o que pode resultar em menos espaço desperdiçado para alguns conjuntos de dados.
CA1815: Substituir é igual e operador é igual 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 cara, e comparar todos os campos para 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, seu tipo de valor deve implementar Equals.
CA1819: As propriedades não devem retornar matrizes	As matrizes retornadas por propriedades não são protegidas contra gravação, mesmo que a propriedade seja somente leitura. Para manter a matriz inviolável, a propriedade deve retornar uma cópia da matriz. Normalmente, os usuários não entenderão as implicações de desempenho adverso de chamar tal propriedade.
CA1820: Teste para cadeias de caracteres vazias usando o comprimento da cadeia de caracteres	Comparar cadeias de caracteres usando a propriedade String.Length ou o método String.IsNullOrEmpty é significativamente mais rápido do que usar Equals.
CA1821: Remover finalizadores vazios	Sempre que puder, evite finalizadores devido à sobrecarga de desempenho adicional envolvida no controle da vida útil do objeto. Um finalizador vazio incorre em sobrecarga adicional sem qualquer benefício.
CA1822: Marcar membros como estáticos	Os membros que não acessam dados de instância ou métodos de instância de chamada podem ser marcados como estáticos (Compartilhado no Visual Basic). Depois de 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 código sensível ao desempenho.
CA1823: Evite campos privados não utilizados	Foram detetados campos privados que não parecem ser acessados no assembly.
CA1824: Marcar assemblies com NeutralResourcesLanguageAttribute	O atributo NeutralResourcesLanguage informa o Resource Manager sobre a linguagem que foi usada para exibir os recursos de uma cultura neutra para um assembly. Isso melhora o desempenho de pesquisa para o primeiro recurso que você carrega e pode reduzir seu conjunto de trabalho.
CA1825: Evite alocações de array de comprimento zero	A inicialização de uma matriz de comprimento zero leva a uma 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 do método Linq Enumerable	Enumerable O método LINQ foi usado em um tipo que suporta uma propriedade equivalente e mais eficiente.
CA1827: Não use Count/LongCount quando algum pode ser usado	Count ou LongCount método onde Any o método seria mais eficiente.
CA1828: Não use CountAsync/LongCountAsync quando AnyAsync pode ser usado	CountAsync ou LongCountAsync método onde AnyAsync o método seria mais eficiente.
CA1829: Use a propriedade Length/Count em vez do método Enumerable.Count	CountO método LINQ foi usado em um tipo que suporta uma propriedade ou Length equivalente, mais eficienteCount.
CA1830: Prefira sobrecargas de método Append e Insert fortemente tipadas no StringBuilder	Append e Insert fornecer sobrecargas para vários 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: Use AsSpan em vez de indexadores baseados em intervalo para cadeia de caracteres quando apropriado	Ao usar um indexador de intervalo em uma cadeia de caracteres e atribuir implicitamente o valor a um tipo de char ReadOnlySpan<, o método > será usado em vez de Substring, que produz uma cópia da parte solicitada da cadeia de caracteres.Slice
CA1832: Use 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 ReadOnlySpan<T> ou ReadOnlyMemory<T> tipo, o método GetSubArray será usado em vez de Slice, que produz uma cópia da parte solicitada da matriz.
CA1833: Use 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 Span<T> ou Memory<T> tipo, o método GetSubArray será usado em vez de Slice, que produz uma cópia da parte solicitada da matriz.
CA1834: Use StringBuilder.Append(char) para cadeias de caracteres únicos	StringBuilder tem uma Append sobrecarga que toma um char como argumento. Prefira chamar a sobrecarga para melhorar o char desempenho.
CA1835: Prefira as sobrecargas baseadas em 'Memória' para 'ReadAsync' e 'WriteAsync'	'Stream' tem uma sobrecarga 'ReadAsync' que usa um 'Memory<Byte>' como o primeiro argumento e uma sobrecarga 'WriteAsync' que usa um 'ReadOnlyMemory<Byte>' como o primeiro argumento. Prefira chamar as sobrecargas baseadas em memória, que são mais eficientes.
CA1836: Prefira IsEmpty quando Count disponível	Prefira IsEmpty a propriedade que seja mais eficiente do que Count, LengthCount<TSource>(IEnumerable<TSource>) ou LongCount<TSource>(IEnumerable<TSource>) para determinar se o objeto contém ou não nenhum item.
CA1837: Use Environment.ProcessId em vez de Process.GetCurrentProcess().Id	Environment.ProcessId é mais simples e mais rápido do que Process.GetCurrentProcess().Id.
CA1838: Evite StringBuilder parâmetros para P/Invokes	O marshalling de sempre cria uma cópia de buffer nativa, resultando em várias alocações para uma operação de StringBuilder empacotamento.
CA1839: Use Environment.ProcessPath em vez de Process.GetCurrentProcess(). MainModule.FileName	Environment.ProcessPath é mais simples e mais rápido do que Process.GetCurrentProcess().MainModule.FileName.
CA1840: Use Environment.CurrentManagedThreadId em vez de Thread.CurrentThread.ManagedThreadId	Environment.CurrentManagedThreadId é mais compacto e eficiente do que Thread.CurrentThread.ManagedThreadId.
CA1841: Prefer Dictionary contém métodos	Recorrer Contains à coleção ou Keys pode muitas vezes ser mais dispendioso Values do que telefonar ContainsKey ou ContainsValue recorrer ao próprio dicionário.
CA1842: Não use 'WhenAll' com uma única tarefa	Usar WhenAll com uma única tarefa pode resultar em perda de desempenho. Aguarde ou retorne a tarefa.
CA1843: Não use 'WaitAll' com uma única tarefa	Usar WaitAll com uma única tarefa pode resultar em perda de desempenho. Aguarde ou retorne a tarefa.
CA1844: Fornecer substituições baseadas em memória de 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 em termos de métodos baseados em memória.
CA1845: Use a cadeia de caracteres baseada em span. Concat»	É mais eficiente para usar AsSpan e string.Concat, em vez de e um operador de Substring concatenação.
CA1846: Prefira AsSpan mais Substring	AsSpan é mais eficiente do que Substring. Substring executa uma cópia de cadeia de caracteres O(n), enquanto AsSpan não e tem um custo constante. AsSpan também não executa nenhuma alocação de heap.
CA1847: Use literal de caracteres para uma pesquisa de um único caractere	Use String.Contains(char) em vez de String.Contains(string) ao procurar um único caractere.
CA1848: Usar os delegados LoggerMessage	Para melhorar o desempenho, use os LoggerMessage delegados.
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 para suas versões assíncronas, quando existirem.
CA1850: Prefira o método estático HashData em vez do ComputeHash	É mais eficiente usar o método estático HashData em vez de criar e gerenciar uma HashAlgorithm instância para chamar ComputeHash.
CA1851: Possíveis enumerações múltiplas de IEnumerable coleção	Possíveis enumerações múltiplas de IEnumerable coleção. Considere o uso de uma implementação que evite várias enumerações.
CA1852: Tipos internos de vedação	Um tipo que não é acessível fora de sua montagem e não tem subtipos dentro de sua montagem de contenção não é lacrado.
CA1853: Chamada desnecessária para 'Dictionary.ContainsKey(key)'	Não há necessidade de se proteger Dictionary.Remove(key) com Dictionary.ContainsKey(key). Dictionary<TKey,TValue>.Remove(TKey) já verifica se a chave existe e não lança se não existir.
CA1854: Prefira o método 'IDictionary.TryGetValue(TKey, out TValue)'	Prefira 'TryGetValue' em vez de um acesso ao indexador de dicionário protegido por uma verificação 'ContainsKey'. 'ContainsKey' e o indexador procuram a chave, portanto, usar 'TryGetValue' evita a pesquisa extra.
CA1855: Use o Span<T>. Clear() em vez de Span<T>. Preenchimento()	É mais eficiente chamar Span<T>.Clear() do que chamar Span<T>.Fill(T) para preencher os elementos da extensão com um valor padrão.
CA1856: Uso incorreto do atributo ConstantExpected	O ConstantExpectedAttribute atributo 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 anotado com ConstantExpectedAttribute.
CA1858: Use 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: Use tipos de concreto quando possível para melhorar o desempenho	O código usa tipos de interface ou tipos abstratos, levando a chamadas de interface desnecessárias ou chamadas virtuais.
CA1860: Evite usar o método de extensão 'Enumerable.Any()'	É mais eficiente e claro usar Length, Countou IsEmpty (se possível) do que chamar Enumerable.Any para determinar se um tipo de coleção tem algum elemento.
CA1861: Evite matrizes constantes como argumentos	Matrizes constantes passadas como argumentos não são reutilizadas, o que implica uma sobrecarga de desempenho. Considere extraí-los para campos "somente leitura estática" para melhorar 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, uma alocação desnecessária é executada.
CA1863: Usar 'CompositeFormat'	Para reduzir o custo de formatação, armazene em cache e use uma CompositeFormat instância como argumento para String.Format ou StringBuilder.AppendFormat.
CA1864: Prefira o método 'IDictionary.TryAdd(TKey, TValue)'	Ambos Dictionary<TKey,TValue>.ContainsKey(TKey) e Dictionary<TKey,TValue>.Add realizar uma pesquisa, que é redundante. É mais eficiente chamar Dictionary<TKey,TValue>.TryAdd, que retorna uma bool indicação se o valor foi adicionado ou não. TryAdd não substitui o valor da chave se ela já estiver presente.
CA1865-CA1867: Usar sobrecarga de caracteres	A sobrecarga char é uma sobrecarga de melhor desempenho para uma string com um único char.
CA1868: Chamada desnecessária para 'Contém' para conjuntos	Ambos ISet<T>.Add(T) e ICollection<T>.Remove(T) realizar uma pesquisa, o que torna redundante ligar ICollection<T>.Contains(T) antecipadamente. É mais eficiente chamar Add(T) ou Remove(T) diretamente, o que retorna um valor booleano indicando se o item foi adicionado ou removido.
CA1869: Armazenar em cache e reutilizar instâncias 'JsonSerializerOptions'	Usar uma instância local de JsonSerializerOptions para serialização ou desserialização pode degradar substancialmente o desempenho do seu aplicativo se o código for executado várias vezes, já que System.Text.Json armazena internamente em cache metadados relacionados à serialização na instância fornecida.
CA1870: Usar uma instância 'SearchValues' armazenada em cache	Usar uma instância armazenada em SearchValues<T> 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 fáceis de alocação do que usar BitConverter.ToString em combinação com String.Replace para substituir traços e String.ToLower.
CA1873: Evite o registro potencialmente caro	Quando os métodos de 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 um melhor desempenho, proteja chamadas de registro caras com uma verificação ao IsEnabled ou use o padrão LoggerMessage.
CA1874: Usar 'Regex.IsMatch'	Regex.IsMatch é mais simples e mais rápido do que Regex.Match(...).Success.
CA1875: Usar 'Regex.Count'	Regex.Count é mais simples e mais 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 recolhidas em uma única chamada usando sobrecargas que aceitam vários segmentos de caminho.