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 : Utiliser des littéraux lorsque 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. Étant donné que la valeur affectée au champ ciblé est computable au moment de la compilation, remplacez la déclaration par un champ const (Const en Visual Basic) afin que la valeur soit calculée au moment de la compilation au lieu de 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 défini au niveau de l’assembly n’est pas créée par le code de l’assembly.
CA1813 : Évitez les attributs non scellés	.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 : Préférez les tableaux irréguliers aux tableaux multidimensionnels	Un tableau irrégulier 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 : Redéfinir Equals et l’opérateur d’égalité pour 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 renvoyé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 garantir que le tableau ne puisse pas être modifié, la propriété doit retourner une copie du tableau. En général, les utilisateurs ne comprennent pas les effets négatifs sur les performances liés à l'appel d'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 : Marquer les membres comme statiques	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 assemblages avec l’attribut NeutralResourcesLanguageAttribute	L’attribut NeutralResourcesLanguage indique au Gestionnaire de ressources la langue utilisée pour afficher les ressources d’une culture neutre pour un assembly. Cela améliore les temps de recherche lors du chargement de la première ressource et peut réduire votre ensemble 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 plutôt que d’utiliser ToString() et la surcharge basée sur une chaîne.
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 possède une surcharge Append qui accepte un char en 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. Préférez utiliser les surcharges utilisant la mémoire, car elles 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 Contains de Dictionary	L’appel Contains sur la collection Keys ou Values 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. Attendre ou renvoyer 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 renvoyez plutôt la tâche.
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’allocation sur le tas.
CA1847 : utilisez un littéral de caractère pour une recherche sur un seul caractère	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 de meilleures 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 : Sceller les types internes	Un type qui n’est pas accessible en dehors de son assemblage et qui n’a aucun sous-type dans l’assemblage qui le contient 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 » à l’accès à un dictionnaire via un indexeur précédé d’un test « 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 la méthode « StringComparison » pour effectuer des comparaisons de chaînes sans tenir compte de la casse	Quand le code appelle ToLower() ou ToUpper() pour effectuer une comparaison de chaînes insensible à 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 de char	La surcharge char offre de meilleures performances pour une chaîne composée d’un seul caractère.
CA1868 : Appel inutile à 'Contains' pour les ensembles	ISet<T>.Add(T) et ICollection<T>.Remove(T) effectuent tous deux une recherche, ce qui rend redondant l’appel préalable à ICollection<T>.Contains(T). 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 transmettez pas de structure nullable à 'ArgumentNullException.ThrowIfNull'	'ArgumentNullException.ThrowIfNull' accepte un 'object', de sorte que le fait de passer une structure nullable peut entraîner une mise en boîte 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 économes en allocations que l’utilisation de BitConverter.ToString en combinaison avec String.Replace pour remplacer les tirets et String.ToLower.
CA1873 : Éviter la journalisation potentiellement coûteuse	Lorsque les méthodes de journalisation sont appelées, leurs arguments sont évalués, que le niveau de journalisation soit activé ou non. Cela peut entraîner l’exécution d’opérations coûteuses même lorsque le message de journal n’est pas écrit. Pour de meilleures performances, protégez les appels de journalisation coûteux avec une vérification de IsEnabled ou utilisez le modèle LoggerMessage.
CA1874 : Utiliser « Regex.IsMatch »	Regex.IsMatch est plus simple et plus rapide que Regex.Match(...).Success.
CA1875 : Utiliser « Regex.Count »	Regex.Count est plus simple et plus rapide que Regex.Matches(...).Count.
CA1877 : Utiliser les surcharges « Path.Combine » ou « Path.Join »	Plusieurs opérations Path.Combine ou Path.Join consécutives peuvent être combinées en un seul appel grâce à des surcharges qui acceptent plusieurs segments de chemin.
CA1878 : Préférer les propriétés ReadOnlySpan sur les champs de tableau en lecture seule	Un champ de tableau privé statique en lecture seule peut être remplacé par une propriété ReadOnlySpan<T> afin que le compilateur C# puisse éviter l’allocation d’un tableau managé.