Règles de performances

Les règles de performances prennent en charge les bibliothèques et applications hautes performances.

Contenu de cette section

Règle	Description
CA1802 : Utilisez des littéraux quand cela est approprié	Un champ est déclaré statique et en lecture seule (Shared et ReadOnly en Visual Basic), et est initialisé avec une valeur qui est calculable à la compilation. La valeur assignée au champ ciblé étant calculable à la compilation, remplacez la déclaration par un champ const (Const en Visual Basic) afin que la valeur soit calculée à la compilation plutôt qu’à l’exécution.
CA1805 : Ne pas initialiser inutilement	Le runtime .NET initialise tous les champs des types référence à leurs valeurs par défaut avant d’exécuter le constructeur. Dans la plupart des cas, l’initialisation explicite d’un champ à sa valeur par défaut est redondante, ce qui ajoute aux coûts de maintenance et peut dégrader les performances (par exemple, avec une augmentation de la taille de l’assembly).
CA1806 : N'ignorez pas les résultats des méthodes	Un nouvel objet est créé mais jamais utilisé, ou une méthode qui crée et retourne une nouvelle chaîne est appelée et la nouvelle chaîne n’est jamais utilisée, ou une méthode COM (Component Object Model) ou P/Invoke retourne un code HRESULT ou d’erreur qui n’est jamais utilisé.
CA1810 : Initialisez les champs statiques de type référence en ligne	Lorsqu'un type déclare un constructeur statique explicite, le compilateur juste-à-temps (JIT, Just-In-Time) ajoute une vérification à chacun des méthodes statiques et constructeurs d'instances du type afin de garantir que le constructeur statique a été appelé précédemment. Les vérifications des constructeurs statiques peuvent diminuer les performances.
CA1812 : Évitez les classes internes non instanciées	Une instance d'un type de niveau assembly n'est pas créée par le code au sein de l'assembly.
CA1813 : Évitez les attributs unsealed	.NET fournit des méthodes pour récupérer des attributs personnalisés. Par défaut, ces méthodes recherchent la hiérarchie d'héritage des attributs. Le fait de sceller l'attribut élimine la recherche dans la hiérarchie d'héritage et peut améliorer les performances.
CA1814 : Utilisez des tableaux en escalier à la place de tableaux multidimensionnels	Un tableau en escalier est un tableau dont les éléments sont des tableaux. Les tableaux qui composent les éléments peuvent être de différentes tailles, ce qui peut conduire à un gaspillage d’espace plus restreint pour certains groupes de données.
CA1815 : Remplacez Equals et l'opérateur égal à dans les types valeur	Pour les types valeur, l'implémentation héritée de Equals utilise la bibliothèque Reflection et compare le contenu de tous les champs. Le processus de réflexion sollicite fortement les ressources informatiques et la comparaison de chaque champ à la recherche d'une égalité peut s'avérer inutile. Si des utilisateurs sont susceptibles de comparer ou de trier des instances, ou de les utiliser en tant que clés de table de hachage, votre type valeur doit implémenter Equals.
CA1819 : Les propriétés ne doivent pas retourner des tableaux	Les tableaux retournés par les propriétés ne sont pas protégés en écriture, même si la propriété est en lecture seule. Pour protéger le tableau de toute falsification, la propriété doit retourner une copie du tableau. En général, les utilisateurs ne comprennent l'incidence négative en matière de performances de l'appel à une telle propriété.
CA1820 : Vérifiez la présence de chaînes vides par la longueur de chaîne	La comparaison de chaînes à l'aide de la propriété String.Length ou de la méthode String.IsNullOrEmpty est nettement plus rapide que l'utilisation d'Equals.
CA1821 : Supprimez les finaliseurs vides	Évitez autant que possible d'utiliser des finaliseurs en raison de la surcharge supplémentaire des performances impliquée dans le suivi de la durée de vie de l'objet. Un finaliseur vide entraîne une surcharge supplémentaire sans aucun avantage.
CA1822 : Marquez les membres comme static	Les membres qui n’accèdent pas aux données d’instance ou n’appellent pas de méthodes d’instance peuvent être marqués comme static (Shared en Visual Basic). Une fois que les méthodes ont été marquées comme static, le compilateur émet des sites d'appel non virtuels vers ces membres. Cette opération se traduit par un gain de performances mesurable pour le code dépendant des performances.
CA1823 : Évitez les champs privés inutilisés	Des champs privés qui ne sont pas accessibles dans l'assembly ont été détectés.
CA1824 : Marquer les assemblys avec NeutralResourcesLanguageAttribute	L’attribut NeutralResourcesLanguage informe le gestionnaire de ressources de la langue qui a été utilisée pour afficher les ressources d’une culture neutre d’un assembly. Cela permet d'améliorer les performances de recherche de la première ressource chargée et de réduire votre jeu de travail.
CA1825 : Éviter les allocations de tableau de longueur nulle	L’initialisation d’un tableau de longueur nulle entraîne une allocation de mémoire inutile. Utilisez plutôt l’instance de tableau vide allouée statiquement en appelant Array.Empty. L’allocation de mémoire est partagée entre tous les appels de cette méthode.
CA1826 : Utiliser une propriété au lieu de la méthode Linq Enumerable	La méthode LINQ Enumerable a été utilisée sur un type qui prend en charge une propriété équivalente plus efficace.
CA1827 : N’utilisez pas Count/LongCount quand Any peut être utilisé	La méthode Count ou LongCount a été utilisée là où la méthode Any serait plus efficace.
CA1828 : N’utilisez pas CountAsync/LongCountAsync quand AnyAsync peut être utilisé	La méthode CountAsync ou LongCountAsync a été utilisée là où la méthode AnyAsync serait plus efficace.
CA1829 : Utilisez la propriété Length/Count au lieu de la méthode Enumerable.Count	La méthode LINQ Count a été utilisée sur un type qui prend en charge une propriété Length ou Count équivalente plus efficace.
CA1830 : Préférer les surcharges de méthode Append et Insert fortement typées sur StringBuilder	Append et Insert fournissent des surcharges pour plusieurs types au-delà de System.String. Si possible, préférez les surcharges fortement typées qui utilisent ToString() et la surcharge basée sur des chaînes.
CA1831 : Utiliser AsSpan à la place d’indexeurs basés sur Range pour une chaîne si approprié	Lorsque vous utilisez un indexeur de plage sur une chaîne et affectez implicitement la valeur à un type ReadOnlySpan<char>, la méthode Substring sera utilisée au lieu de Slice, ce qui produit une copie de la partie demandée de la chaîne.
CA1832 : Utiliser AsSpan ou AsMemory à la place d’indexeurs basés sur Range pour obtenir la partie ReadOnlySpan ou ReadOnlyMemory d’un tableau	Lorsque vous utilisez un indexeur de plage sur un tableau et affectez implicitement la valeur à un type ReadOnlySpan<T> ou ReadOnlyMemory<T>, la méthode GetSubArray sera utilisée au lieu de Slice, ce qui produit une copie de la partie demandée du tableau.
CA1833 : Utiliser AsSpan ou AsMemory à la place d’indexeurs basés sur Range pour obtenir la partie Span ou Memory d’un tableau	Lorsque vous utilisez un indexeur de plage sur un tableau et affectez implicitement la valeur à un type Span<T> ou Memory<T>, la méthode GetSubArray sera utilisée au lieu de Slice, ce qui produit une copie de la partie demandée du tableau.
CA1834 : Utiliser StringBuilder.Append (char) pour les chaînes de caractères uniques	StringBuilder a une surcharge Append qui prend un char comme argument. Il est préférable d’appeler la surcharge char pour améliorer les performances.
CA1835 : préférez les surcharges basées sur la mémoire pour « ReadAsync » et « WriteAsync »	« Stream » a une surcharge « ReadAsync » qui prend un « Memory<Byte> » comme premier argument, et une surcharge « WriteAsync » qui prend un « ReadOnlyMemory<Byte> » comme premier argument. Il est préférable d’appeler les surcharges basées sur la mémoire qui sont plus efficaces.
CA1836 : préférez IsEmpty à Count le cas échéant	Préférez la propriété IsEmpty plus efficace que Count, LengthCount<TSource>(IEnumerable<TSource>) ou LongCount<TSource>(IEnumerable<TSource>) pour déterminer si l’objet contient ou non des éléments.
CA1837 : utilisez Environment.ProcessId au lieu de Process.GetCurrentProcess().Id	Environment.ProcessId est plus simple et plus rapide que Process.GetCurrentProcess().Id.
CA1838 : évitez les paramètres StringBuilder pour les P/Invokes	Le marshaling de StringBuilder crée toujours une copie de la mémoire tampon native, ce qui entraîne plusieurs allocations pour une seule opération de marshaling.
CA1839 : utilisez Environment.ProcessPath au lieu de Process.GetCurrentProcess().MainModule.FileName	Environment.ProcessPath est plus simple et plus rapide que Process.GetCurrentProcess().MainModule.FileName.
CA1840 : utilisez Environment.CurrentManagedThreadId au lieu de Thread.CurrentThread.ManagedThreadId	Environment.CurrentManagedThreadId est plus compact et plus efficace que Thread.CurrentThread.ManagedThreadId.
CA1841 : préférez les méthodes Dictionary.Contains	L’appel Contains sur la collection Values ou Keys peut souvent être plus coûteux que l’appel de ContainsKey ou ContainsValue sur le dictionnaire lui-même.
CA1842 : n’utilisez pas « WhenAll » avec une seule tâche	L’utilisation de WhenAll avec une seule tâche peut entraîner une perte de performances. Attendez ou retournez la tâche à la place.
CA1843 : n’utilisez pas « WaitAll » avec une seule tâche	L’utilisation de WaitAll avec une seule tâche peut entraîner une perte de performances. Attendez ou retournez la tâche à la place.
CA1844 : fournissez des remplacements basés sur la mémoire des méthodes asynchrones lors du sous-classement de « Stream »	Pour améliorer les performances, remplacez les méthodes asynchrones basées sur la mémoire lors du sous-classement de « Stream ». Implémentez ensuite les méthodes basées sur un tableau en termes de méthodes basées sur la mémoire.
CA1845 : utilisez la méthode basée sur l’étendue « string.Concat »	Il est plus efficace d’utiliser AsSpan et string.Concat, au lieu de Substring et un opérateur de concaténation.
CA1846 : préférez AsSpan à Substring	AsSpan est plus efficace que Substring. Substring effectue une copie de chaîne O(n), alors que AsSpan ne le fait pas et présente un coût constant. AsSpan n’effectue pas non plus d’allocations de tas.
CA1847 : utilisez un littéral char pour une recherche de caractère unique	Utilisez String.Contains(char) plutôt que String.Contains(string) lors de la recherche d’un caractère unique.
CA1848 : utiliser les délégués LoggerMessage	Pour améliorer les performances, utilisez les délégués LoggerMessage.
CA1849 : appeler des méthodes asynchrones dans une méthode asynchrone	Dans une méthode déjà asynchrone, les appels d’autres méthodes doivent être à leurs versions asynchrones, là où elles existent.
CA1850 : préférez la méthode HashData statique par rapport à ComputeHash	Il est plus efficace d’utiliser la méthode HashData statique que de créer et gérer une instance HashAlgorithm pour appeler ComputeHash.
CA1851 : Énumérations multiples possibles de la collection IEnumerable	Plusieurs énumérations possibles de la collection IEnumerable. Envisagez d’utiliser une implémentation qui évite plusieurs énumérations.
CA1852 : scellez les types internes	Un type qui n’est pas accessible en dehors de son assembly et n’a aucun sous-type dans son assembly conteneur n’est pas scellé.
CA1853 : appel inutile à « Dictionary.ContainsKey(key) »	Il n’est pas nécessaire de protéger Dictionary.Remove(key) avec Dictionary.ContainsKey(key). Dictionary<TKey,TValue>.Remove(TKey) vérifie déjà si la clé existe et n’est pas levée si elle n’existe pas.
CA1854 : préférez la méthode « IDictionary.TryGetValue(TKey, out TValue) »	Préférez « TryGetValue » à un indexeur de dictionnaire protégé par une vérification « ContainsKey ». « ContainsKey » et l’indexeur recherchent tous deux la clé, de sorte que l’utilisation de « TryGetValue » évite la recherche supplémentaire.
CA1855 : utilisez Span<T>.Clear() au lieu de Span<T>.Fill()	Il est plus efficace d’appeler Span<T>.Clear() que d’appeler Span<T>.Fill(T) pour remplir les éléments de l’étendue avec une valeur par défaut.
CA1856 : Utilisation incorrecte de l’attribut ConstantExpected	L’attribut ConstantExpectedAttribute n’est pas appliqué correctement à un paramètre.
CA1857 : Le paramètre attend une constante pour des performances optimales	Un argument non valide est passé à un paramètre annoté avec ConstantExpectedAttribute.
CA1858 : utilisez StartsWith au lieu d’IndexOf	Il est plus efficace d’appeler String.StartsWith que d’appeler String.IndexOf pour vérifier si une chaîne commence par un préfixe donné.
CA1859 : Utiliser des types concrets lorsque cela est possible pour améliorer les performances	Le code utilise des types d’interface ou des types abstraits, ce qui entraîne des appels d’interface ou des appels virtuels inutiles.
CA1860 : Éviter d’utiliser la méthode d’extension 'Enumerable.Any()'	Il est plus efficace et plus simple d’utiliser Length, Count ou IsEmpty (si possible) que d’appeler Enumerable.Any pour déterminer si un type de collection comporte des éléments.
CA1861 : Éviter les tableaux constants en tant qu’arguments	Les tableaux constants passés en tant qu’arguments ne sont pas réutilisés, ce qui implique une surcharge de performances. Envisagez de les extraire dans des champs « statiques en lecture seule » pour améliorer les performances.
CA1862 : Utilisez les surcharges de méthode « StringComparison » pour effectuer des comparaisons de chaînes qui ne respectent pas la casse	Quand le code appelle ToLower() ou ToUpper() pour effectuer une comparaison de chaînes ne respectant pas la casse, une allocation inutile est effectuée.
CA1863 : Utiliser « CompositeFormat »	Pour réduire le coût de mise en forme, mettez en cache et utilisez une instance CompositeFormat comme argument pour String.Format ou StringBuilder.AppendFormat.
CA1864 : Préférer la méthode « IDictionary.TryAdd(TKey, TValue) »	Dictionary<TKey,TValue>.ContainsKey(TKey) et Dictionary<TKey,TValue>.Add effectuent une recherche, ce qui est redondant. Il est plus efficace d’appeler Dictionary<TKey,TValue>.TryAdd, qui retourne un bool indiquant si la valeur a été ajoutée ou non. TryAdd ne remplace pas la valeur de la clé si la clé est déjà présente.
CA1865-CA1867 : Utiliser la surcharge char	La surcharge char est une surcharge plus performante pour une chaîne avec un seul char.
CA1868 : Appel inutile à 'Contains' pour les jeux	Les deux ISet<T>.Add(T) et ICollection<T>.Remove(T) effectuent une recherche, ce qui le rend redondant pour appeler ICollection<T>.Contains(T) au préalable. Il est plus efficace d’appeler Add(T) ou Remove(T) directement, qui retourne une valeur booléenne indiquant si l’élément a été ajouté ou supprimé.
CA1869 : mise en cache et réutilisation des instances de 'JsonSerializerOptions'	L’utilisation d’une instance locale de JsonSerializerOptions pour la sérialisation ou la désérialisation peut considérablement dégrader le niveau de performance de votre application si votre code s’exécute plusieurs fois, car System.Text.Json met en cache en interne les métadonnées liées à la sérialisation dans l’instance fournie.
CA1870 : Utiliser une instance « SearchValues » mise en cache	L’utilisation d’une instance SearchValues<T> mise en cache est plus efficace que de passer des valeurs à « IndexOfAny » ou « ContainsAny » directement.
CA1871 : Ne passez pas de struct nullable à ' ArgumentNullException.ThrowIfNull'	'ArgumentNullException.ThrowIfNull' accepte un 'object', de sorte que le passage d’un struct nullable peut entraîner la boxe de la valeur.
CA1872 : Préférer « Convert.ToHexString » et « Convert.ToHexStringLower » aux chaînes d’appel basées sur « BitConverter.ToString »	Utilisez Convert.ToHexString ou Convert.ToHexStringLower lors de l’encodage d’octets dans une représentation sous forme de chaîne hexadécimale. Ces méthodes sont plus efficaces et plus conviviales que d’utiliser BitConverter.ToString en combinaison avec String.Replace les tirets et String.ToLowerles tirets.