Reglas de rendimiento

Las reglas de rendimiento admiten aplicaciones y bibliotecas de alto rendimiento.

En esta sección

Regla	Descripción
CA1802: Utilizar literales cuando sea apropiado	Un campo se declara como estático y de solo lectura (Shared y ReadOnly en Visual Basic) y se inicializa con un valor que se puede calcular en tiempo de compilación. Dado que el valor asignado al campo de destino se calcula en tiempo de compilación, cambie la declaración a un campo const (Const en Visual Basic) para que el valor se calcule en tiempo de compilación en lugar de en tiempo de ejecución.
CA1805: No inicializar innecesariamente	El entorno de ejecución de .NET inicializa todos los campos de tipos de referencia a sus valores predeterminados antes de ejecutar el constructor. En la mayoría de los casos, la inicialización explícita de un campo en su valor predeterminado es redundante, lo que aumenta los costos de mantenimiento y puede degradar el rendimiento (por ejemplo, con un mayor tamaño de ensamblado).
CA1806: No omita el resultado de un método	Se crea un objeto pero nunca se utiliza, o se llama a un método que crea y devuelve una cadena nueva y esta nunca se utiliza, o bien un método de Component Object Model [Modelo de objetos componentes (COM)] o P/Invoke devuelve un código de error o HRESULT que nunca se utiliza.
CA1810: Inicializar en línea los campos estáticos de referencia	Cuando un tipo declara un constructor estático explícito, el compilador Just-In-Time (JIT) agrega una comprobación a cada constructor de instancia y a cada método estático del tipo para asegurarse de que se ha llamado anteriormente al constructor estático. Las comprobaciones del constructor estático pueden reducir el rendimiento.
CA1812: Evitar las clases internas sin instancia	Una instancia de un tipo de nivel de ensamblado no es creada por código del ensamblado.
CA1813: Evitar los atributos no sellados	.NET proporciona métodos para recuperar atributos personalizados. De forma predeterminada, estos métodos buscan la jerarquía de herencia de atributo. La acción de sellar el atributo elimina la búsqueda en la jerarquía de herencia y puede mejorarse el rendimiento.
CA1814: Preferir matrices escalonadas antes que multidimensionales	Una matriz escalonada es una matriz cuyos elementos son matrices. Las matrices que constituyen los elementos pueden ser de tamaños diferentes, lo que reduce el espacio desaprovechado para algunos conjuntos de datos.
CA1815: Invalidar Equals y el operador Equals en los tipos de valores	Para los tipos de valor, la implementación heredada de Equals utiliza la biblioteca de reflexión y compara el contenido de todos los campos. La reflexión es costosa en términos computacionales, y comparar cada campo para determinar la igualdad podría ser innecesario. Si espera que los usuarios comparen u ordenen instancias, o utilicen instancias como claves de tabla hash, el tipo de valor debe implementar Equals.
CA1819: Las propiedades no deben devolver matrices	Las matrices devueltas por las propiedades no están protegidas contra escritura, incluso si la propiedad es de solo lectura. Para que el array esté protegido contra modificaciones, la propiedad debe devolver una copia del array. Por lo general, los usuarios no suelen comprender las consecuencias negativas para el rendimiento de llamar a una propiedad de este tipo.
CA1820: Comprobar si las cadenas están vacías mediante la longitud de cadena	El uso de la propiedad String.Length o del método String.IsNullOrEmpty para comparar cadenas es mucho más rápido que el uso de Equals.
CA1821: Eliminar finalizadores vacíos	Siempre que pueda, evite los finalizadores debido a la sobrecarga de rendimiento adicional necesaria para el seguimiento de la duración del objeto. Un finalizador vacío supone una sobrecarga adicional sin ninguna ventaja.
CA1822: Marcar miembros como estáticos	Los miembros que no acceden a datos de instancia ni llaman a métodos de instancia se pueden marcar como estáticos (Shared en Visual Basic). Después de marcar los métodos como static, el compilador emite los sitios de llamada no virtuales para estos miembros. Esto puede proporcionar una mejora apreciable del rendimiento del código en el que el rendimiento es fundamental.
CA1823: Evitar los campos privados sin utilizar	Se detectaron campos privados a los que no parece que se tenga acceso en el ensamblado.
CA1824: Marcar los ensamblados con el atributo NeutralResourcesLanguageAttribute	El atributo NeutralResourcesLanguage indica al administrador de recursos el idioma que se utilizó para mostrar los recursos de una cultura neutra de un ensamblado. Esto mejora el rendimiento de búsqueda del primer recurso que cargas y puede reducir tu conjunto de trabajo.
CA1825: Evitar asignaciones de matrices de longitud cero	Al inicializar una matriz de longitud cero, se produce una asignación de memoria innecesaria. En su lugar, use la instancia de matriz vacía asignada estáticamente mediante una llamada a Array.Empty. La asignación de memoria se comparte entre todas las invocaciones de este método.
CA1826: Usar la propiedad en lugar del método Linq Enumerable	El método Enumerable de LINQ se ha usado en un tipo que admite una propiedad equivalente y más eficaz.
CA1827: No usar Count/LongCount si se puede usar Any	Se ha usado el método Count o LongCount, cuando el método Any sería más eficaz.
CA1828: No usar CountAsync/LongCountAsync si se puede usar AnyAsync	Se ha usado el método CountAsync o LongCountAsync, cuando el método AnyAsync sería más eficaz.
CA1829: Usar la propiedad Length/Count en lugar del método Enumerable.Count	El método Count de LINQ se ha usado en un tipo que admite una propiedad Length o Count equivalente y más eficaz.
CA1830: Prefiera las sobrecargas de los métodos Append e Insert con tipos seguros en StringBuilder	Append y Insert proporcionan sobrecargas para varios tipos más allá de System.String. Siempre que sea posible, prefiera las sobrecargas con tipado seguro en lugar de usar ToString() y la sobrecarga basada en cadenas.
CA1831: Usar AsSpan en lugar de indizadores basados en intervalos para una cadena cuando proceda	Cuando se usa un indizador de intervalo en una cadena y se asigna implícitamente el valor a un tipo ReadOnlySpan<char>, se utilizará el método en Substring lugar de Slice, que genera una copia de la parte solicitada de la cadena.
CA1832: Usar AsSpan o AsMemory en lugar de indizadores basados en intervalos para obtener la parte ReadOnlySpan o ReadOnlyMemory de una matriz	Cuando se usa un indizador de intervalo en una matriz y se asigna implícitamente el valor a un tipo ReadOnlySpan<T> o ReadOnlyMemory<T>, se utilizará el método GetSubArray en lugar de Slice, lo que genera una copia de la parte solicitada de la matriz.
CA1833: Usar AsSpan o AsMemory en lugar de indizadores basados en intervalos para obtener la parte Span o Memory de una matriz	Cuando se usa un indizador de intervalo en una matriz y se asigna implícitamente el valor a un tipo Span<T> o Memory<T>, se utilizará el método GetSubArray en lugar de Slice, lo que genera una copia de la parte solicitada de la matriz.
CA1834: Usar StringBuilder.Append(char) para cadenas de un solo carácter	StringBuilder tiene una sobrecarga de Append que acepta char como argumento. Es preferible llamar a la sobrecarga de char para mejorar el rendimiento.
CA1835: Preferir las sobrecargas basadas en "Memory" para "ReadAsync" y "WriteAsync"	"Stream" tiene una sobrecarga de "ReadAsync" que toma un valor "Memory<Byte>" como primer argumento y una sobrecarga de "WriteAsync " que toma un valor "ReadOnlyMemory<Byte>" como primer argumento. Es preferible usar las sobrecargas que usan memoria, ya que son más eficientes.
CA1836: Preferencia de IsEmpty con respecto a Count cuando esté disponible	Se prefiere la propiedad IsEmpty que es más eficaz que Count, Length, Count<TSource>(IEnumerable<TSource>) o LongCount<TSource>(IEnumerable<TSource>) para determinar si el objeto contiene o no elementos.
CA1837: Uso de Environment.ProcessId en lugar de Process.GetCurrentProcess().Id	Environment.ProcessId es más sencillo y rápido que Process.GetCurrentProcess().Id.
CA1838: Evitar parámetros StringBuilder en las invocaciones a P/Invoke	La ordenación de StringBuilder siempre crea una copia del búfer nativo, lo que da lugar a múltiples asignaciones de memoria para una sola operación de ordenación.
CA1839: Usar Environment.ProcessPath en lugar de Process.GetCurrentProcess().MainModule.FileName	Environment.ProcessPath es más sencillo y rápido que Process.GetCurrentProcess().MainModule.FileName.
CA1840: Use Environment.CurrentManagedThreadId en lugar de Thread.CurrentThread.ManagedThreadId	Environment.CurrentManagedThreadId es más compacto y eficaz que Thread.CurrentThread.ManagedThreadId.
CA1841: Prefiera los métodos Contains de Dictionary	A menudo, llamar a Contains en la colección Keys o Values puede resultar más costoso que llamar a ContainsKey o ContainsValue en el propio diccionario.
CA1842: No usar 'WhenAll' con una sola tarea	El uso de WhenAll con una sola tarea puede provocar una pérdida de rendimiento. Espere o devuelva la tarea en su lugar.
CA1843: No usar "WaitAll" con una sola tarea	El uso de WaitAll con una sola tarea puede provocar una pérdida de rendimiento. Espere o devuelva la tarea en su lugar.
CA1844: Proporcionar reemplazos basados en memoria de métodos asincrónicos al crear una subclase de 'Stream'	Para mejorar el rendimiento, invalide los métodos asincrónicos basados en memoria al crear subclases "Stream". A continuación, implemente los métodos basados en matriz en términos de los métodos basados en memoria.
CA1845: Use 'string.Concat' basado en Span	Es más eficaz usar AsSpan y string.Concat, en lugar de Substring y un operador de concatenación.
CA1846: Preferencia de AsSpan sobre Substring	AsSpan es más eficaz que Substring. Substring realiza una copia de cadena O(n), mientras que AsSpan no lo hace y tiene un costo constante. AsSpan tampoco realiza ninguna asignación de montón.
CA1847: Use el literal char para buscar un solo carácter	Use String.Contains(char) en lugar de String.Contains(string) al buscar un solo carácter.
CA1848: Usar los delegados de LoggerMessage	Para obtener un mejor rendimiento, use los delegados LoggerMessage.
CA1849: Llame a métodos asincrónicos cuando esté en un método asincrónico	En un método que ya es asincrónico, las llamadas a otros métodos deben ser a sus versiones asincrónicas, donde existan.
CA1850: Preferencia del método estático HashData sobre ComputeHash	Es más eficiente usar el método estático HashData que crear y administrar una instancia de HashAlgorithm para llamar a ComputeHash.
CA1851: Posibles enumeraciones múltiples de la colección IEnumerable	Posibles enumeraciones múltiples de la colección IEnumerable. Considere la posibilidad de usar una implementación que evite varias enumeraciones.
CA1852: Tipos internos de sello	Un tipo que no es accesible fuera de su ensamblado y que no tiene subtipos en el ensamblado que lo contiene no está precintado.
CA1853: Llamada innecesaria a 'Dictionary.ContainsKey(key)'	No es necesario proteger Dictionary.Remove(key) con Dictionary.ContainsKey(key). Dictionary<TKey,TValue>.Remove(TKey) ya comprueba si la clave existe y no inicia si no existe.
CA1854: Preferir el método 'IDictionary.TryGetValue(TKey, out TValue)'	Es preferible usar 'TryGetValue' en lugar de acceder al indexador de un diccionario precedido de una comprobación con 'ContainsKey'. 'ContainsKey' y el indexador buscan la clave, por lo que el uso de 'TryGetValue' evita la búsqueda adicional.
CA1855: Use Span<T>.Clear() en lugar de Span<T>.Fill()	Es más eficaz llamar aSpan<T>.Clear() que llamar a Span<T>.Fill(T) para rellenar los elementos del intervalo con un valor predeterminado.
CA1856: Uso incorrecto del atributo ConstantExpected	El atributo ConstantExpectedAttribute no se aplica correctamente en un parámetro.
CA1857: El parámetro espera una constante para un rendimiento óptimo	Un argumento no válido se pasa a un parámetro anotado con ConstantExpectedAttribute.
CA1858: Usar "StartsWith" en lugar de IndexOf	Es más eficaz llamar a String.StartsWith que llamar a String.IndexOf para comprobar si una cadena comienza con un prefijo determinado.
CA1859: Usar tipos concretos cuando sea posible para mejorar el rendimiento	El código usa tipos de interfaz o tipos abstractos, lo que genera llamadas virtuales o llamadas de interfaz innecesarias.
CA1860: evite usar el método de extensión "Enumerable.Any()"	Es más eficiente y claro utilizar Length, Count o IsEmpty (si es posible) que llamar a Enumerable.Any para determinar si un tipo de colección tiene algún elemento.
CA1861: Evitar matrices constantes como argumentos	Las matrices constantes pasadas como argumentos no se reutilizan, lo que implica una sobrecarga de rendimiento. Considere la posibilidad de extraerlas en campos "static readonly" para mejorar el rendimiento.
CA1862: Usar las sobrecargas del método "StringComparison" para realizar comparaciones de cadenas que no distinguen mayúsculas de minúsculas	Cuando el código llama a ToLower() o ToUpper() para realizar una comparación de cadenas que no distingue mayúsculas de minúsculas, se realiza una asignación innecesaria.
CA1863: Usar 'CompositeFormat'	Para reducir el costo de formato, almacene en caché y use una instancia CompositeFormat como argumento para String.Format o StringBuilder.AppendFormat.
CA1864: Se prefiere el método "IDictionary.TryAdd(TKey, TValue)"	Tanto Dictionary<TKey,TValue>.ContainsKey(TKey) como Dictionary<TKey,TValue>.Add realizan una búsqueda, que es redundante. Es más eficaz llamar a Dictionary<TKey,TValue>.TryAdd, que devuelve un valor bool que indica si el valor se agregó o no. TryAdd no sobrescribe el valor de la clave si la clave ya está presente.
CA1865-CA1867: Usar la sobrecarga de char	La sobrecarga de char es una sobrecarga de mejor rendimiento para una cadena con un único char.
CA1868: llamada innecesaria a "Contains" para conjuntos	Tanto ISet<T>.Add(T) como ICollection<T>.Remove(T) realizan una búsqueda, lo que hace que sea redundante llamar a ICollection<T>.Contains(T) de antemano. Es más eficaz llamar a Add(T) o Remove(T) directamente, lo que devuelve un valor booleano que indica si el elemento se ha agregado o quitado.
CA1869: Almacenamiento en caché y reutilización de instancias de "JsonSerializerOptions"	El uso de una instancia local de JsonSerializerOptions para la serialización o deserialización puede degradar considerablemente el rendimiento de la aplicación si el código se ejecuta varias veces, ya que System.Text.Json almacena internamente en caché los metadatos relacionados con la serialización en la instancia proporcionada.
CA1870: Uso de una instancia de "SearchValues" almacenada en caché	Usar una instancia en caché SearchValues<T> es más eficaz que pasar directamente valores a 'IndexOfAny' o 'ContainsAny'.
CA1871: No pasar una estructura anulable a 'ArgumentNullException.ThrowIfNull'	'ArgumentNullException.ThrowIfNull' acepta un 'object', por lo que pasar una estructura que acepta valores NULL podría hacer que el valor se boxee.
CA1872: Preferir 'Convert.ToHexString' y 'Convert.ToHexStringLower' en vez de cadenas de llamadas basadas en 'BitConverter.ToString'	Use Convert.ToHexString o Convert.ToHexStringLower al codificar bytes en una representación de cadena hexadecimal. Estos métodos son más eficientes y requieren menos asignaciones de memoria que usar BitConverter.ToString en combinación con String.Replace para reemplazar guiones y String.ToLower.
CA1873: Evitar el registro de eventos que pueda resultar costoso	Cuando se llama a los métodos de registro, sus argumentos se evalúan independientemente de si el nivel de registro está habilitado. Esto puede dar lugar a que se ejecuten operaciones costosas incluso cuando no se escriba el mensaje de registro. Para mejorar el rendimiento, proteja las llamadas de registro costosas con una comprobación a IsEnabled o use el patrón LoggerMessage.
CA1874: Usar 'Regex.IsMatch'	Regex.IsMatch es más sencillo y rápido que Regex.Match(...).Success.
CA1875: Usar 'Regex.Count'	Regex.Count es más sencillo y rápido que Regex.Matches(...).Count.
CA1877: Utilice las sobrecargas "Path.Combine" o "Path.Join"	Se pueden agrupar varias operaciones consecutivas de Path.Combine o Path.Join en una única llamada mediante sobrecargas que aceptan múltiples segmentos de ruta de acceso.
CA1878: Preferir las propiedades ReadOnlySpan a los campos de array de solo lectura	Un campo `private static readonly` de array constante se puede reemplazar por una propiedad ReadOnlySpan<T> para que el compilador de C# pueda evitar la asignación de un array administrado.