Règles de qualité du code

L’analyse du code .NET fournit des règles qui visent à améliorer la qualité du code. Les avertissements sont organisés en domaines de règles, tels que la conception, la localisation, les performances et la sécurité. Certaines règles sont spécifiques à l’utilisation de l’API .NET, tandis que d’autres concernent la qualité du code générique.

Index des règles

Le tableau suivant répertorie les règles d’analyse de la qualité du code.

ID de règle et avertissement	Description
CA1000 : Ne pas déclarer de membres statiques sur les types génériques	Lorsqu'un membre statique d'un type générique est appelé, l'argument de type doit être spécifié pour le type. Lorsqu'un membre d'instance générique qui ne prend pas en charge l'inférence est appelé, l'argument de type doit être spécifié pour le membre. Dans ces deux cas, la syntaxe permettant de spécifier l'argument de type est différente et peut être facilement confondue.
CA1001 : Les types qui possèdent des champs supprimables doivent être supprimables	Une classe déclare et implémente un champ d'instance qui est un type System.IDisposable, et elle n'implémente pas IDisposable. Une classe qui déclare un champ IDisposable possède indirectement une ressource non managée et doit implémenter l'interface IDisposable.
CA1002 : Ne pas exposer de listes génériques	System.Collections.Generic.List<(Of <(T>)>) est une collection générique conçue pour les performances et non l’héritage. Par conséquent, la liste ne contient aucun membre virtuel. Les collections génériques qui sont conçues pour l’héritage doivent être exposées à la place.
CA1003 : Utiliser les instances du gestionnaire d'événements génériques	Un type contient un délégué qui retourne void, dont la signature contient deux paramètres (le premier est un objet et le second est un type pouvant être assigné à EventArgs), et l'assembly conteneur cible Microsoft .NET Framework 2.0.
CA1005 : Éviter les paramètres excessifs sur les types génériques	Plus un type générique contient de paramètres de type, plus il est difficile de déterminer et de mémoriser la représentation de chaque paramètre de type. Cela est généralement évident avec un paramètre de type, comme dans List<T>, et dans certains cas avec deux paramètres de type, comme dans Dictionary<TKey, TValue>. Cependant, s’il existe plus de deux paramètres de type, la difficulté devient trop grande pour la plupart des utilisateurs.
CA1008 : Les enums doivent avoir la valeur zéro	La valeur par défaut d'une énumération non initialisée, comme d'autres types valeur, est zéro. Une énumération attribuée sans indicateur doit définir un membre de valeur zéro afin que la valeur par défaut soit une valeur valide de l'énumération. Si une énumération à laquelle l'attribut FlagsAttribute est appliqué définit un membre de valeur zéro, son nom doit être "None" pour indiquer qu'aucune valeur n'a été définie dans l'énumération.
CA1010 : Les collections doivent implémenter une interface générique	Pour étendre la facilité d’utilisation d’une collection, implémentez l’une des interfaces de collection génériques. La collection peut être ensuite utilisée pour remplir des types de collection génériques.
CA1012 : Les types abstract ne doivent pas avoir de constructeurs publics	Les constructeurs des types abstraits peuvent être appelés uniquement par des types dérivés. Étant donné que les constructeurs publics créent des instances d'un type et que vous ne pouvez pas créer d'instance d'un type abstrait, un type abstrait doté d'un constructeur public est de conception incorrecte.
CA1014 : Marquer les assemblys avec CLSCompliantAttribute	La spécification de langage commun CLS (Common Language Specification) définit des restrictions de dénomination, des types de données, et des règles auxquelles les assemblys doivent se conformer s'ils doivent être utilisés à l'échelle de différents langages de programmation. Un design correct stipule que tous les assemblys indiquent explicitement la conformité CLS avec CLSCompliantAttribute. Si cet attribut n'est pas présent sur un assembly, l'assembly n'est pas conforme.
CA1016 : Marquer les assemblys avec AssemblyVersionAttribute	.NET utilise le numéro de version pour identifier un assembly de manière unique, et créer une liaison avec des types présents dans des assemblys à nom fort. Le numéro de version est utilisé conjointement avec la version et la stratégie d'éditeur. Par défaut, les applications s'exécutent uniquement avec la version d'assembly avec laquelle elles ont été construites.
CA1017 : Marquer les assemblys avec ComVisibleAttribute	ComVisibleAttribute détermine comment les clients COM accèdent à du code managé. Un bon design stipule que les assemblys indiquent explicitement la visibilité COM. La visibilité COM peut être définie pour l'assembly en entier, puis être substituée pour des types et des membres de type individuels. Si cet attribut n'est pas présent, les clients COM peuvent voir le contenu de l'assembly.
CA1018 : Marquer les attributs avec AttributeUsageAttribute	Lorsque vous définissez un attribut personnalisé, marquez-le à l'aide d'AttributeUsageAttribute pour indiquer où l'attribut personnalisé peut être appliqué dans le code source. La signification et l'utilisation prévue d'un attribut déterminent ses emplacements valides au sein d'un code.
CA1019 : Définir des accesseurs pour les arguments d'attribut	Les attributs peuvent définir des arguments obligatoires qui doivent être spécifiés lorsque vous appliquez l’attribut à une cible. Ceux-ci sont également appelés arguments positionnels parce qu’ils sont fournis aux constructeurs d’attributs en tant que paramètres positionnels. Pour chaque argument obligatoire, l'attribut doit également fournir une propriété en lecture seule correspondante afin que la valeur de l'argument puisse être récupérée au moment de l'exécution. Les attributs peuvent également définir des arguments facultatifs, qui sont également appelés arguments nommés. Ces arguments sont fournis aux constructeurs d’attributs par noms et doivent disposer d’une propriété en lecture/écriture correspondante.
CA1021 : Éviter les paramètres out	Passer des types par référence (en utilisant out ou ref) nécessite une certaine expérience des pointeurs, de comprendre la différence entre les types valeur et les types référence, ainsi que la gestion de méthodes impliquant plusieurs valeurs de retour. Par ailleurs, la différence entre les paramètres out et ref est généralement peu comprise.
CA1024 : Utiliser les propriétés lorsque cela est approprié	Le nom d'une méthode publique ou protégée commence par « Get », n'accepte aucun paramètre et retourne une valeur qui n'est pas un tableau. La méthode est susceptible de devenir une propriété.
CA1027 : Marquer les enums avec FlagsAttribute	Une énumération est un type valeur qui définit un jeu de constantes nommées associées. Appliquez FlagsAttribute à une énumération lorsque ses constantes nommées peuvent être combinées de manière pertinente.
CA1028 : Enum Storage doit être Int32	Une énumération est un type valeur qui définit un jeu de constantes nommées associées. Par défaut, le type de données System.Int32 est utilisé pour stocker la valeur de constante. Bien que vous puissiez modifier ce type sous-jacent, ce n'est ni obligatoire, ni recommandé dans la plupart des scénarios.
CA1030 : Utiliser des événements lorsque cela est approprié	Cette règle détecte des méthodes qui présentent des noms qui ordinairement seraient utilisés pour des événements. Si une méthode est appelée en réponse à une modification d'état clairement définie, la méthode doit être appelée par un gestionnaire d'événements. Les objets qui appellent la méthode doivent déclencher des événements au lieu d'appeler directement la méthode.
CA1031 : Ne pas intercepter des types d'exception générale	Les exceptions générales ne doivent pas être interceptées. Interceptez une exception plus spécifique ou levez à nouveau l'exception générale en tant que dernière instruction dans le bloc catch.
CA1032 : Implémenter des constructeurs d'exception standard	Ne pas fournir le jeu complet de constructeurs peut rendre difficile une gestion des exceptions correcte.
CA1033 : Les méthodes d'interface doivent pouvoir être appelées par les types enfants	Un type unsealed visible de l'extérieur fournit une implémentation de méthode explicite d'une interface publique mais ne fournit aucune méthode de substitution visible de l'extérieur de même nom.
CA1034 : Les types imbriqués ne doivent pas être visibles	Un type imbriqué représente un type déclaré dans la portée d'un autre type. Les types imbriqués sont utiles pour encapsuler les détails de l'implémentation privée du type conteneur. Utilisés à cette fin, les types imbriqués ne doivent pas être visibles de l'extérieur.
CA1036 : Substituer les méthodes sur les types Comparable	Un type public ou protégé implémente l'interface System.IComparable. Il ne substitue pas Object.Equals, ni ne surcharge l'opérateur égal à, différent de, inférieur à ou supérieur à propre au langage.
CA1040 : Éviter les interfaces vides	Les interfaces définissent des membres qui fournissent un comportement ou un contrat d'utilisation. Les fonctionnalités décrites par l'interface peuvent être adoptées par tout type, indépendamment de l'endroit où le type figure dans la hiérarchie d'héritage. Un type implémente une interface en fournissant des implémentations pour les membres de celle-ci. Une interface vide ne définit aucun membre ; par conséquent, elle ne définit aucun contrat pouvant être implémenté.
CA1041 : Fournir un message ObsoleteAttribute	Un type ou un membre est marqué avec un attribut System.ObsoleteAttribute dont la propriété ObsoleteAttribute.Message n'est pas spécifiée. Lorsqu'un type ou membre marqué avec ObsoleteAttribute est compilé, la propriété Message de l'attribut est affichée. Cela fournit à l'utilisateur des informations sur le type ou le membre obsolète.
CA1043 : Utiliser un argument de chaîne ou intégral pour les indexeurs	Les indexeurs (c'est-à-dire les propriétés indexées) doivent utiliser des types intégral ou chaîne pour l'index. Ces types sont généralement utilisés pour indexer des structures de données et augmentent la facilité d'utilisation de la bibliothèque. L'utilisation du type Object doit se restreindre aux cas où le type intégral ou de chaîne spécifique ne peut pas être spécifié au moment du design.
CA1044 : Les propriétés ne doivent pas être en écriture seule	Bien qu'il soit acceptable et souvent nécessaire de disposer d'une propriété en lecture seule, les règles de conception interdisent l'utilisation de propriétés en écriture seule. Le fait de permettre à un utilisateur de définir une valeur et l'empêcher ensuite de la consulter n'offre aucune garantie de sécurité. De plus, sans accès en lecture, l'état des objets partagés ne peut s'afficher, ce qui limite leur utilité.
CA1045 : Ne pas passer de types par référence	Passer des types par référence (en utilisant out ou ref) nécessite une certaine expérience des pointeurs, de comprendre la différence entre les types valeur et les types référence, ainsi que la gestion de méthodes impliquant plusieurs valeurs de retour. Les architectes de bibliothèques qui réalisent un travail de conception destiné à une audience générale ne doivent pas s’attendre à ce que les utilisateurs maîtrisent l’utilisation des paramètres out ou ref.
CA1046 : Ne pas surcharger l'opérateur égal à sur les types référence	Pour les types référence, l'implémentation par défaut de l'opérateur d'égalité est presque toujours correcte. Par défaut, deux références sont égales uniquement si elles pointent sur le même objet.
CA1047 : Ne pas déclarer les membres protégés dans les types sealed	Les types déclarent des membres protégés afin que des types qui héritent puissent accéder au membre ou le substituer. Par définition, les types sealed ne peuvent pas être hérités, ce qui signifie que les méthodes protégées sur les types sealed ne peuvent pas être appelées.
CA1050 : Déclarer les types dans des espaces de noms	Les types sont déclarés au sein d'espaces de noms pour empêcher des collisions de dénomination, ainsi qu'en guise que méthode d'organisation de types connexes au sein d'une hiérarchie d'objets.
CA1051 : Ne pas déclarer de champs d'instances visibles	Un champ s'utilise principalement en tant que détail d'implémentation. Les champs doivent être privés ou internes, et doivent être exposés au moyen de propriétés.
CA1052 : Les types de conteneurs statiques doivent être sealed	Un type public ou protégé contient uniquement des membres statiques et n'est pas déclaré avec le modificateur sealed (Référence C#) (NotInheritable). Un type qui n'est pas destiné à être hérité doit être marqué avec le modificateur sealed pour empêcher son utilisation en tant que type de base.
CA1053 : Les types de conteneurs statiques ne doivent pas comporter de constructeur	Un type public ou imbriqué déclare uniquement des membres statiques et dispose d'un constructeur par défaut public ou protégé. Le constructeur est inutile car l'appel à des membres statiques ne requiert aucune instance du type. La surcharge de chaîne doit appeler la surcharge d'URI (Uniform Resource Identifier) à l'aide de l'argument de chaîne pour des raisons de sécurité.
CA1054 : Les paramètres URI ne doivent pas être des chaînes	Si une méthode accepte une représentation sous forme de chaîne d'un URI, une surcharge correspondante qui accepte une instance de la classe URI doit être fournie ; elle-même fournit ces services de manière sûre et sécurisée.
CA1055 : Les valeurs de retour URI ne doivent pas être des chaînes	Cette règle considère que la méthode retourne un URI. Une représentation sous forme de chaîne d'un URI est sujette aux erreurs d'analyse et d'encodage, et peut entraîner des failles de sécurité. La classe System.Uri fournit ces services de manière sûre et sécurisée.
CA1056 : Les propriétés URI ne doivent pas être des chaînes	Cette règle considère que la propriété représente un URI (Uniform Resource Identifier). Une représentation sous forme de chaîne d'un URI est sujette aux erreurs d'analyse et d'encodage, et peut entraîner des failles de sécurité. La classe System.Uri fournit ces services de manière sûre et sécurisée.
CA1058 : Les types ne doivent pas étendre certains types de base	Un type visible de l'extérieur étend certains types de base. Utilisez l'une des solutions de remplacement.
CA1060 : Déplacer les P/Invoke vers une classe NativeMethods	Les méthodes d’appel de code non managé, telles que celles qui sont marquées avec l’attribut System.Runtime.InteropServices.DllImportAttribute, ou les méthodes définies à l’aide du mot clé Declare en Visual Basic, accèdent à du code non managé. Ces méthodes doivent être de la classe NativeMethods, SafeNativeMethods ou UnsafeNativeMethods.
CA1061 : Ne pas masquer les méthodes de la classe de base	Une méthode dans un type de base est masquée par une méthode portant le même nom dans un type dérivé, lorsque la signature de paramètre de la méthode dérivée diffère uniquement par les types qui sont dérivés plus faiblement que les types correspondants dans la signature de paramètre de la méthode de base.
CA1062 : Valider les arguments de méthodes publiques	Tous les arguments de référence passés aux méthodes visibles de l'extérieur doivent être vérifiés pour voir s'ils ont la valeur null.
CA1063 : Implémenter IDisposable correctement	Tous les types IDisposable doivent implémenter le modèle Dispose correctement.
CA1064 : Les exceptions doivent être publiques	Une exception interne est uniquement visible à l'intérieur de sa propre portée interne. Lorsque l'exception se situe en dehors de la portée interne, seule l'exception de base peut être utilisée pour intercepter l'exception. Si l’exception interne est héritée de Exception, SystemException, ou ApplicationException, le code externe n’a pas d’informations suffisantes pour savoir que faire avec l’exception.
CA1065 : Ne pas lever d'exceptions dans les emplacements inattendus	Une méthode dont l'objet n'est pas de lever des exceptions lève une exception.
CA1066 : Implémenter IEquatable au moment de remplacer Equals	Un type valeur remplace la méthode Equals, mais n’implémente pas IEquatable<T>.
CA1067: Remplacer Equals lors de l’implémentation d’IEquatable	Un type implémente IEquatable<T>, mais ne remplace pas la méthode Equals.
CA1068 : Les paramètres CancellationToken doivent venir en dernier	Une méthode a un paramètre CancellationToken qui n’est pas le dernier paramètre.
CA1069 : Les enums ne doivent pas avoir de valeurs en double	Une énumération a plusieurs membres qui sont explicitement affectés à la même valeur constante.
CA1070 : Ne pas déclarer de champs d’événement comme virtuels	Un événement de type champ a été déclaré comme virtuel.
CA1200 : Éviter d’utiliser des balises cref avec un préfixe	L’attribut cref dans une balise de documentation XML signifie « référence de code ». Il indique que le texte interne de la balise est un élément de code tel qu’un type, une méthode ou une propriété. Évitez d’utiliser les balises cref avec des préfixes, car cela empêche le compilateur de vérifier les références. Cela empêche également l’environnement de développement intégré (IDE) de Visual Studio de rechercher et de mettre à jour ces références de symboles pendant les refactorisations.
CA1303 : Ne pas passer de littéraux en paramètres localisés	Une méthode visible de l’extérieur passe un littéral de chaîne en tant que paramètre à un constructeur .NET ou une méthode et cette chaîne doit être localisable.
CA1304 : Spécifier CultureInfo	Une méthode ou un constructeur appelle un membre présentant une surcharge qui accepte un paramètre System.Globalization.CultureInfo, et la méthode ou le constructeur n'appelle pas la surcharge qui prend le paramètre CultureInfo. Lorsqu'un objet CultureInfo ou System.IFormatProvider n'est pas fourni, la valeur par défaut fournie par le membre surchargé peut ne pas avoir l'effet escompté selon les différents paramètres régionaux.
CA1305 : Spécifier IFormatProvider	Une méthode ou un constructeur appelle un ou plusieurs membres présentant des surcharges qui acceptent un paramètre System.IFormatProvider, et la méthode ou le constructeur n'appelle pas la surcharge qui prend le paramètre IFormatProvider. Lorsqu'un objet System.Globalization.CultureInfo ou IFormatProvider n'est pas fourni, la valeur par défaut fournie par le membre surchargé peut ne pas avoir l'effet escompté selon les différents paramètres régionaux.
CA1307 : Spécifier StringComparison pour clarifier	Une opération de comparaison de chaînes utilise une surcharge de méthode qui ne définit pas de paramètre StringComparison.
CA1308 : Normaliser les chaînes en majuscules	Les chaînes doivent être normalisées en majuscules. En cas de conversion en minuscules, un petit groupe de caractères ne peut pas faire un aller-retour.
CA1309 : Utiliser StringComparison avec la valeur Ordinal	Opération de comparaison de chaînes non linguistique qui n'affecte pas la valeur Ordinal ou OrdinalIgnoreCase au paramètre StringComparison. En affectant explicitement au paramètre la valeur StringComparison.Ordinal ou StringComparison.OrdinalIgnoreCase, votre code gagne souvent en rapidité, tout en devenant plus correct et plus fiable.
CA1310 : Spécifier StringComparison pour corriger	Une opération de comparaison de chaînes utilise une surcharge de méthode qui ne définit pas de paramètre StringComparison et utilise la comparaison de chaînes spécifique à la culture par défaut.
CA1311 : Spécifier une culture ou utiliser une version invariante	Spécifiez une culture ou utilisez une culture invariante pour éviter toute dépendance implicite vis-à-vis de la culture actuelle lors de l’appel de ToUpper ou ToLower.
CA1401 : Les P/Invoke ne doivent pas être visibles	Une méthode publique ou protégée dans un type public a l’attribut System.Runtime.InteropServices.DllImportAttribute (également implémenté par le mot clé Declare en Visual Basic). De telles méthodes ne doivent pas être exposées.
CA1416 : Valider la compatibilité de la plateforme	L’utilisation d’API dépendantes de la plateforme sur un composant fait que le code ne fonctionne plus sur toutes les plateformes.
CA1417 : n’utilisez pas OutAttribute sur les paramètres de chaîne pour les P/Invoke	Les paramètres de chaînes transmis en valeur avec OutAttribute risquent de déstabiliser le runtime s’il s’agit de chaînes centralisées.
CA1418 : utilisez une chaîne de plateforme valide	L’analyseur de compatibilité de plateforme nécessite un nom et une version de plateforme valides.
CA1419 : Fournissez un constructeur sans paramètre aussi visible que le type conteneur pour les types concrets dérivés de « System.Runtime.InteropServices.SafeHandle »	Fournir un constructeur sans paramètre qui est aussi visible que le type conteneur pour un type dérivé de System.Runtime.InteropServices.SafeHandle permet de meilleures performances et utilisation avec les solutions d’interopérabilité générées par la source.
CA1420 : La propriété, le type ou l’attribut nécessite un marshaling au moment de l’exécution	L’utilisation de fonctionnalités qui nécessitent le marshaling du runtime lorsque le marshaling du runtime est désactivé entraîne des exceptions d’exécution.
CA1421 : La méthode utilise le marshaling du runtime lorsque DisableRuntimeMarshallingAttribute est appliqué	Une méthode utilise le marshaling du runtime, et le marshaling du runtime est explicitement désactivé.
CA1422 : Valider la compatibilité de la plateforme	L’appel d’une API obsolète dans un système d’exploitation (version) donné à partir d’un site d’appel accessible sur ce système d’exploitation (version) n’est pas recommandé.
CA1501 : Éviter l'excès d'héritage	Un type est imbriqué de plus de quatre niveaux dans sa hiérarchie d'héritage. Les hiérarchies de type profondément imbriquées peuvent être difficiles à suivre, comprendre et gérer.
CA1502 : Éviter l'excès de complexité	Cette règle évalue le nombre de chemins linéairement indépendants dans la méthode, déterminé par le nombre et la complexité des branches conditionnelles.
CA1505 : Éviter le code impossible à maintenir	Un type ou une méthode a une faible valeur d'indice de maintenabilité. Un faible indice de maintenabilité indique qu'un type ou qu'une méthode est probablement difficile à maintenir et qu'il/elle se prête bien à une nouvelle conception.
CA1506 : Éviter les couplages de classe excessifs	Cette règle mesure l'accouplement de classes en comptant le nombre de références de type uniques contenues dans un type ou une méthode.
CA1507 : Utiliser nameof à la place de string	Un littéral de chaîne est utilisé comme argument où une expression nameof peut être utilisée.
CA1508 : Éviter le code conditionnel mort	Une méthode a du code conditionnel qui s’évalue toujours à true ou false au moment de l’exécution. Cela conduit à du code mort dans la branche false de la condition.
CA1509 : Entrée non valide dans le fichier de configuration des métriques de code	Les règles de métriques de code, telles que CA1501, CA1502, CA1505 et CA1506, ont fourni un fichier de configuration nommé CodeMetricsConfig.txt qui a une entrée non valide.
CA1510 : Utiliser l’assistance de levée ArgumentNullException	Les assistants de levée sont plus simples et plus efficaces que les blocs if qui construisent une nouvelle instance d’exception.
CA1511 : Utiliser l’assistance de levée ArgumentException	Les assistants de levée sont plus simples et plus efficaces que les blocs if qui construisent une nouvelle instance d’exception.
CA1512 : Utiliser l’assistance de levée ArgumentOutOfRangeException	Les assistants de levée sont plus simples et plus efficaces que les blocs if qui construisent une nouvelle instance d’exception.
CA1513 : Utiliser l’assistance de levée ObjectDisposedException	Les assistants de levée sont plus simples et plus efficaces que les blocs if qui construisent une nouvelle instance d’exception.
CA1514 : Éviter l’argument de longueur redondante	Un argument de longueur redondant est utilisé lors du découpage jusqu’à la fin d’une chaîne ou d’un tampon. Une longueur calculée peut être sujette à des erreurs et est également inutile.
CA1515 : envisager de rendre les types publics internes	Contrairement à une bibliothèque de classes, l’API d’une application n’est généralement pas référencée publiquement. Il est donc possible de marquer les types comme internes.
CA1700 : Ne nommez pas les valeurs enum 'Reserved'	Cette règle suppose qu'un membre de l'énumération dont le nom contient le terme "reserved" n'est pas utilisé actuellement, mais constitue un espace réservé à renommer ou à supprimer dans une version ultérieure. Renommer ou supprimer un membre constitue une modification avec rupture.
CA1707 : Les identificateurs ne doivent pas contenir de traits de soulignement	Par convention, les noms d'identificateurs ne contiennent pas de trait de soulignement (_). Cette règle vérifie les espaces de noms, types, membres et paramètres.
CA1708 : Les identificateurs ne doivent pas différer uniquement par leur casse	Les identificateurs des espaces de noms, types, membres et paramètres ne peuvent pas différer uniquement par la casse car les langages qui ciblent le Common Language Runtime ne sont pas tenus de respecter celle-ci.
CA1710 : Les identificateurs doivent être dotés d'un suffixe correct	Par convention, les noms des types qui étendent certains types de base ou qui implémentent certaines interfaces, ou encore des types dérivés de ces types, présentent un suffixe associé au type de base ou à l'interface.
CA1711 : Les identificateurs ne doivent pas porter un suffixe incorrect	Par convention, seuls les noms des types qui étendent certains types de base ou qui implémentent certaines interfaces, ou les types dérivés de ces types, doivent se terminer par des suffixes réservés spécifiques. Les autres noms de types ne doivent pas utiliser ces suffixes réservés.
CA1712 : N'ajoutez pas le nom de type en guise de préfixe à des valeurs enum	Les noms des membres de l'énumération n'ont pas pour préfixe le nom de type, car les outils de développement sont censés fournir les informations de type.
CA1713 : Les événements ne doivent pas être munis d'un préfixe Before ou After	Le nom d'un événement commence par « Before » ou « After ». Pour nommer des événements associés déclenchés dans une séquence spécifique, utilisez le présent ou le passé pour indiquer la position relative dans la séquence d'actions.
CA1714 : Les noms des enums Flags doivent être au pluriel	Une énumération publique comporte l'attribut System.FlagsAttribute et son nom ne se termine pas par « s ». Les types marqués avec FlagsAttribute ont des noms au pluriel, car l'attribut indique que plusieurs valeurs peuvent être spécifiées.
CA1715 : Les identificateurs doivent être dotés d'un préfixe correct	Le nom d'une interface extérieurement visible ne commence pas par un « I » majuscule. Le nom d'un paramètre de type générique sur un type ou une méthode extérieurement visible ne commence pas par un « T » majuscule.
CA1716 : Les identificateurs ne doivent pas correspondre à des mots clés	Un nom d'espace de noms ou un nom de type correspond à un mot clé réservé dans un langage de programmation. Les identificateurs des espaces de noms et des types ne doivent pas correspondre aux mots clés définis par les langages qui ciblent le Common Language Runtime.
CA1717 : Seuls les noms des enums FlagsAttribute doivent être au pluriel	Selon les conventions d'attribution de nom, un nom au pluriel pour une énumération indique que plusieurs valeurs de l'énumération peuvent être spécifiées simultanément.
CA1720 : Les identificateurs ne doivent pas contenir de noms de types	Le nom d'un paramètre dans un membre extérieurement visible contient un nom de type de données, ou le nom d'un membre extérieurement visible contient un nom de type de données spécifique à une langue.
CA1721 : Les noms des propriétés ne doivent pas être identiques à ceux des méthodes Get	Le nom d'un membre public ou protégé commence par « Get ». Sinon, il correspond au nom d'une propriété publique ou protégée. Les méthodes et propriétés « Get » doivent porter des noms distinguant clairement leur fonction.
CA1724 : Les noms de types ne doivent pas être identiques aux espaces de noms	Les noms de type ne doivent pas correspondre aux noms des espaces de noms .NET. Enfreindre cette règle peut réduire la facilité d'utilisation de la bibliothèque.
CA1725 : Les noms des paramètres doivent correspondre à la déclaration de base	La désignation cohérente des paramètres dans une hiérarchie de substitution augmente la facilité d'utilisation des substitutions de méthode. Un nom de paramètre dans une méthode dérivée qui diffère du nom dans la déclaration de base peut créer une confusion pour déterminer si la méthode est une substitution de la méthode de base ou une nouvelle surcharge de la méthode.
CA1727 : utilisez PascalCase pour les espaces réservés nommés	Utilisez PascalCase pour les espaces réservés nommés dans le modèle de message de journalisation.
CA1801 : Passez en revue les paramètres inutilisés	Une signature de méthode inclut un paramètre qui n'est pas utilisé dans le corps de la méthode.
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 ) afin que la valeur soit calculée à la compilation plutôt qu’au runtime.
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 taille d’assembly accrue).
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 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 conduit à 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.
CA1816 : Appeler GC.SuppressFinalize correctement	Une méthode qui est une implémentation de Dispose n'appelle pas GC.SuppressFinalize ; ou une méthode qui n'est pas une implémentation de Dispose appelle GC.SuppressFinalize ; ou une méthode appelle GC.SuppressFinalize et passe un élément autre que celui-ci (Me en Visual Basic).
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 charge 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 des 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 String. Si possible, préférez les surcharges fortement typées plutôt que l’utilisation de 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é	Lors de l’utilisation d’un indexeur de plage sur une chaîne et de l’affectation implicite de la valeur au type <char>ReadOnlySpan, la méthode Substring sera utilisée à la place 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. Préférez appeler la surcharge char pour des raisons de 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 ou Values la Keys collection peut souvent être plus coûteux que d’appeler ContainsKey ou ContainsValue sur le dictionnaire lui-même.
CA1842 : n’utilisez pas « WhenAll » avec une seule tâche	L’utilisation WhenAll d’une tâche unique 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 WaitAll d’une tâche unique 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.
CA2000 : Supprimer les objets avant la mise hors de portée	Sachant qu'un événement exceptionnel peut se produire et empêcher l'exécution du finaliseur d'un objet, ce dernier doit plutôt être supprimé explicitement avant que toutes les références à lui soient hors de portée.
CA2002 : Ne définissez pas un verrou sur des objets à identité faible	Un objet est dit d'identité faible lorsqu'il est accessible directement au-delà des limites d'un domaine d'application. Un thread qui essaie d'acquérir un verrou sur un objet qui affiche une identité faible peut être bloqué par un deuxième thread dans un domaine d'application différent qui dispose d'un verrou sur le même objet.
CA2007 : N’attendez pas directement une Tâche	Une méthode asynchrone attend directement un Task. Lorsqu’une méthode asynchrone attend directement un Task , la continuation se produit dans le thread qui a créé la tâche. Ce comportement peut être coûteux en termes de performances et peut entraîner un blocage sur le thread d’interface utilisateur. Envisagez d’appeler Task.ConfigureAwait(Boolean) pour signaler votre intention de continuer.
CA2008 : Ne pas créer de tâches sans passer TaskScheduler	Une opération de création ou de continuation de tâche utilise une surcharge de méthode qui ne spécifie pas de paramètre TaskScheduler.
CA2009 : N’appelez pas ToImmutableCollection sur une valeur ImmutableCollection	La méthode ToImmutable a été inutilement appelée sur une collection immuable à partir de l’espace de noms System.Collections.Immutable.
CA2011 : Ne pas assigner la propriété dans son setter	Une propriété a été affectée accidentellement à une valeur au sein de son propre accesseur set.
CA2012 : Utiliser correctement ValueTasks	Les valueTasks retournés par les appels de membres sont destinés à être directement attendus. Les tentatives d’utilisation d’une ValeurTask plusieurs fois ou d’accéder directement au résultat d’un utilisateur avant qu’il soit connu pour être terminé peuvent entraîner une exception ou une altération. Ignorer une telle ValeurTask est probablement une indication d’un bogue fonctionnel et peut dégrader les performances.
CA2013 : Ne pas utiliser ReferenceEquals avec des types valeur	Lors de la comparaison des valeurs à l’aide de System.Object.ReferenceEquals, si objA et objB sont des types valeur, ils sont boxés avant qu’ils ne soient passés à la méthode ReferenceEquals. Cela signifie que même si objA et objB représentent la même instance d’un type valeur, la méthode ReferenceEquals retourne néanmoins false.
CA2014 : Ne pas utiliser stackalloc dans les boucles.	L’espace de pile alloué par un stackalloc est libéré uniquement à la fin de l’appel de la méthode actuelle. L’utilisation de celle-ci dans une boucle peut entraîner une croissance de pile illimitée et des conditions de dépassement de capacité de pile éventuelles.
CA2015 : Ne pas définir de finaliseurs pour les types dérivés de MemoryManager<T>	L’ajout d’un finaliseur à un type dérivé de MemoryManager<T> peut permettre à la mémoire d’être libérée alors qu’elle est toujours utilisée par un Span<T>.
CA2016 : Transférer le paramètre CancellationToken aux méthodes qui l’acceptent	Transférez le paramètre CancellationToken aux méthodes qui en prennent un pour vous assurer que les notifications d’annulation d’opération sont correctement propagées, ou transmettez CancellationToken.None explicitement pour indiquer intentionnellement ne pas propager le jeton.
CA2017 : Incompatibilité du nombre de paramètres	Le nombre de paramètres fournis dans le modèle de message de journalisation ne correspond pas au nombre d’espaces réservés nommés.
CA2018 : l’argument count à Buffer.BlockCopy doit spécifier le nombre d’octets à copier	Lors de l’utilisation de Buffer.BlockCopy, l’argument count spécifie le nombre d’octets à copier. Vous devez uniquement utiliser Array.Length pour l’argument count sur les tableaux dont les éléments sont exactement un octet de taille. Les tableaux byte, sbyteet bool ont des éléments d’une taille d’un octet.
CA2019: Les champs ThreadStatic ne doivent pas utiliser l’initialisation inline	Un champ annoté avec ThreadStaticAttribute est initialisé inline ou explicitement dans un constructeur static (Shared en Visual Basic).
CA2020 : Empêcher les changements de comportement causés par les opérateurs intégrés d’IntPtr/UIntPtr	Certains opérateurs intégrés ajoutés dans .NET 7 se comportent différemment des opérateurs définis par l’utilisateur dans .NET 6 et versions antérieures. Certains opérateurs utilisés pour lever dans un contexte non vérifié lors du dépassement de capacité ne lèvent plus, sauf s’ils sont encapsulés dans le contexte vérifié. Certains opérateurs qui ne lèvent pas précédemment dans le contexte archivé lèvent maintenant, sauf si le contexte est encapsulé.
CA2021 : N’appelez pas Enumerable.Cast<T> ou Enumerable.OfType<T> avec des types incompatibles	Un appel à Enumerable.Cast<TResult>(IEnumerable) ou Enumerable.OfType<TResult>(IEnumerable) spécifie un paramètre de type incompatible avec le type de la collection d’entrée.
CA2022 : Éviter une lecture inexacte avec Stream.Read	Un appel à renvoyer Stream.Read peut retourner moins d’octets que demandés, ce qui entraîne un code non fiable si la valeur de retour n’est pas cochée.
CA2100 : Vérifier si les requêtes SQL présentent des failles de sécurité	Une méthode définit la propriété System.Data.IDbCommand.CommandText à l’aide d’une chaîne générée à partir d’un argument de chaîne à la méthode. Cette règle suppose que l’argument de chaîne contient des entrées d’utilisateur. Une chaîne de commande SQL générée par une entrée d'utilisateur est vulnérable aux attaques par injection de code SQL.
CA2101 : spécifiez le marshaling pour les arguments de chaîne P/Invoke	Un membre d’appel de code non managé autorise les appelants dotés d’un niveau de confiance partielle, présente un paramètre de chaîne et ne marshale pas explicitement la chaîne. Cela peut provoquer une faille de sécurité potentielle.
CA2109 : Passez en revue les gestionnaires d'événements visibles	Une méthode de gestion d’événements publique ou protégée a été détectée. Les méthodes de gestion d’événements ne doivent pas être exposées sauf nécessité absolue.
CA2119 : Scellez les méthodes qui satisfont les interfaces privées	Un type public pouvant être hérité fournit une implémentation de méthode substituable d’une interface interne (Friend en Visual Basic). Pour corriger une violation de cette règle, empêchez la méthode d’être substituée en dehors de l’assembly.
CA2153 : éviter la gestion des exceptions état altéré	Les exceptions état altéré indiquent une altération de la mémoire dans votre processus. Le fait d’intercepter ces exceptions au lieu d’autoriser le processus à se bloquer peut engendrer des failles de sécurité si une personne malveillante réussit à placer une attaque dans la région de la mémoire endommagée.
CA2200 : Levez à nouveau une exception pour conserver les détails de la pile	Une exception est à nouveau levée et est spécifiée explicitement dans l'instruction throw. Si une exception est à nouveau levée par sa spécification dans l'instruction throw, la liste des appels de méthode présents entre la méthode d'origine qui a levé l'exception et la méthode actuelle est perdue.
CA2201 : Ne levez pas des types d'exceptions réservés	Cela rend l'erreur d'origine difficile à détecter et à déboguer.
CA2207 : Initialisez les champs statiques des types valeur en ligne	Un type valeur déclare un constructeur statique explicite. Pour corriger une violation de cette règle, initialisez toutes les données statiques lorsqu’elles sont déclarées et supprimez le constructeur statique.
CA2208 : Instanciez les exceptions d'argument comme il se doit	Un appel est effectué au constructeur par défaut (sans paramètre) d’un type d’exception qui est ou dérive de ArgumentException, ou un argument de chaîne incorrect est passé à un constructeur paramétrable d’un type d’exception qui est ou dérive de ArgumentException.
CA2211 : Les champs non constants ne doivent pas être visibles	Les champs statiques qui ne sont ni constants ni en lecture seule ne sont pas thread-safe. L'accès à un tel champ doit être scrupuleusement contrôlé et requiert des techniques de programmation évoluées pour synchroniser l'accès à l'objet de classe.
CA2213 : Les champs pouvant être supprimés doivent l’être	Un type qui implémente System.IDisposable déclare des champs de types qui implémentent également IDisposable. La méthode Dispose du champ n'est pas appelée par la méthode Dispose du type déclarant.
CA2214 : N'appelez pas de méthodes substituables dans les constructeurs	Lorsqu’un constructeur appelle une méthode virtuelle, le constructeur de l’instance qui appelle la méthode n’a peut-être pas été exécuté.
CA2215 : Les méthodes Dispose doivent appeler la méthode Dispose de la classe de base	Si un type hérite d'un type pouvant être supprimé, il doit appeler la méthode Dispose du type de base issu de sa propre méthode Dispose.
CA2216 : Les types pouvant être supprimés doivent déclarer un finaliseur	Un type qui implémente System.IDisposable et présente des champs qui laissent entendre l'utilisation de ressources non managées n'implémente pas de finaliseur conforme à la description de Object.Finalize.
CA2217 : Ne marquez pas les enums avec l'attribut FlagsAttribute	Une énumération extérieurement visible est marquée par FlagsAttribute et possède une ou plusieurs valeurs qui ne sont pas des puissances de deux ou une combinaison des autres valeurs définies dans l'énumération.
CA2218 : Remplacez GetHashCode au moment de remplacer Equals	Un type public se substitue à System.Object.Equals, mais pas à System.Object.GetHashCode.
CA2219 : Ne pas lever d'exceptions dans les clauses d'exception	Lorsqu'une exception est levée dans une clause finally ou fault, la nouvelle exception masque l'exception active. Lorsqu’une exception est levée dans une clause filter, le runtime l’intercepte en silence. Cela rend l'erreur d'origine difficile à détecter et à déboguer.
CA2224 : Remplacez Equals au moment de surcharger l'opérateur égal	Un type public implémente l’opérateur d’égalité, mais ne se substitue pas à System.Object.Equals.
CA2225 : Les surcharges d'opérateur offrent d'autres méthodes nommées	Une surcharge d'opérateur a été détectée, et la méthode de substitution nommée attendue n'a pas été trouvée. Le membre de substitution nommé donne accès aux mêmes fonctionnalités que l'opérateur. Il est fourni aux développeurs qui programment dans les langages qui ne prennent pas en charge les opérateurs surchargés.
CA2226 : Les opérateurs doivent contenir des surcharges symétriques	Un type implémente l'opérateur d'égalité ou d'inégalité et n'implémente pas l'opérateur opposé.
CA2227 : Les propriétés de collection doivent être en lecture seule	Une propriété de collection accessible en écriture permet à un utilisateur de remplacer la collection par une collection différente. Une propriété en lecture seule empêche le remplacement de la collection, mais permet quand même aux membres individuels d’être définis.
CA2229 : Implémentez des constructeurs de sérialisation	Pour corriger une violation de cette règle, implémentez le constructeur de sérialisation. Dans le cas d'une classe sealed, rendez le constructeur privé ; sinon, attribuez-lui l'état protégé.
CA2231 : Surchargez l’opérateur égal (equals) en remplaçant ValueType.Equals	Un type valeur se substitue à Object.Equals mais n'implémente pas l'opérateur d'égalité.
CA2234 : Passez des objets System.Uri à la place de chaînes	Un appel est passé à une méthode qui a un paramètre de chaîne dont le nom contient « uri », « URI », « urn », « URN », « url » ou « URL ». Le type déclarant de la méthode contient une surcharge de méthode correspondante qui a un paramètre System.Uri.
CA2235 : Marquez tous les champs non sérialisés	Un champ d'instance d'un type non sérialisable est déclaré dans un type sérialisable.
CA2237 : Marquer les types ISerializable avec SerializableAttribute	Pour être reconnus par le Common Language Runtime comme sérialisables, les types doivent être marqués avec l'attribut SerializableAttribute même s'ils utilisent une routine de sérialisation personnalisée par le biais de l'implémentation de l'interface ISerializable.
CA2241 : Indiquer le nombre correct d'arguments dans les méthodes de mise en forme	L’argument de format passé à System.String.Format ne contient aucun élément de mise en forme pour chaque argument objet correspondant, ou vice versa.
CA2242 : Effectuez correctement des tests NaN	Cette expression teste une valeur par rapport à Single.Nan ou Double.Nan. Utilisez Single.IsNan(Single) ou Double.IsNan(Double) pour tester la valeur.
CA2243 : Les littéraux de chaîne d'attribut doivent être analysés correctement	Le paramètre de littéral de chaîne d'un attribut n'effectue pas une analyse correcte pour une URL, un GUID ou une version.
CA2244 : Ne pas dupliquer les initialisations d’éléments indexés	Un initialiseur d’objet a plusieurs initialiseurs d’éléments indexés avec le même index constant. Tous les initialiseurs, à l’exception du dernier sont redondants.
CA2245 : Ne pas attribuer une propriété à elle-même	Une propriété a été attribuée accidentellement à elle-même.
CA2246 : Ne pas attribuer un symbole et son membre dans la même instruction	L’affectation d’un symbole et de son membre, soit un champ ou une propriété, dans la même instruction n’est pas recommandée. Il est difficile de déterminer si l’accès du membre était destiné à utiliser l’ancienne valeur du symbole avant l’assignation ou la nouvelle valeur de l’assignation dans cette instruction.
CA2247 : L’argument passé au constructeur TaskCompletionSource doit être l’énumération TaskCreationOptions au lieu de l’énumération TaskContinuationOptions.	TaskCompletionSource a des constructeurs qui prennent les TaskCreationOptions qui contrôlent la tâche sous-jacente et les constructeurs qui prennent l’état d’objet stocké dans la tâche. Si vous passez accidentellement une énumération TaskContinuationOptions au lieu d’une énumération TaskCreationOptions, l’appel traite les options comme un état.
CA2248 : Fournir le bon argument enum à Enum.HasFlag	Le type d’énumération passé en tant qu’argument à l’appel de méthode HasFlag est différent du type d’énumération appelant.
CA2249 : Utiliser de préférence String.Contains à la place de String.IndexOf	Les appels à string.IndexOf où le résultat est utilisé pour vérifier la présence ou l’absence d’une substring peuvent être remplacés par string.Contains.
CA2250 : utilisez ThrowIfCancellationRequested	ThrowIfCancellationRequested vérifie automatiquement si le jeton a été annulé et lève une OperationCanceledException si c’est le cas.
CA2251 : utilisez String.Equals plutôt que String.Compare	Il est plus clair et probablement plus rapide d’utiliser String.Equals au lieu de comparer le résultat de String.Compare à zéro.
CA2252 : accepter les fonctionnalités en préversion	Acceptez les fonctionnalités en préversion avant d’utiliser des API en préversion.
CA2253 : les espaces réservés nommés ne doivent pas être des valeurs numériques	Les espaces réservés nommés dans le modèle de message de journalisation ne doivent pas être composés uniquement de caractères numériques.
CA2254 : le modèle doit être une expression statique	Le modèle de message de journalisation ne doit pas varier entre les appels.
CA2255 : l’attribut ModuleInitializer ne doit pas être utilisé dans les bibliothèques	Les initialiseurs de module sont destinés à être utilisés par le code d’application pour s’assurer que les composants d’une application sont initialisés avant le début de l’exécution du code de l’application.
CA2256 : tous les membres déclarés dans les interfaces parentes doivent avoir une implémentation dans une interface possédant l’attribut DynamicInterfaceCastableImplementation	Les types attribués par DynamicInterfaceCastableImplementationAttribute agissent comme une implémentation d’interface pour un type qui implémente le type IDynamicInterfaceCastable. Par conséquent, ils doivent fournir une implémentation de tous les membres définis dans les interfaces héritées, car le type qui implémente IDynamicInterfaceCastable ne les fournira pas autrement.
CA2257 : les membres définis sur une interface avec « DynamicInterfaceCastableImplementationAttribute » doivent être « static »	Étant donné qu’un type qui implémente peut ne pas implémenter une interface dynamique dans les IDynamicInterfaceCastable métadonnées, les appels à un membre d’interface d’instance qui n’est pas une implémentation explicite définie sur ce type sont susceptibles d’échouer au moment de l’exécution. Marquez les nouveaux membres de l’interface static pour éviter les erreurs d’exécution.
CA2258 : la fourniture d’une interface « DynamicInterfaceCastableImplementation » en Visual Basic n’est pas prise en charge	La fourniture d’une interface fonctionnelle possédant l’attribut DynamicInterfaceCastableImplementationAttribute nécessite la fonctionnalité Membres de l’interface par défaut, qui n’est pas prise en charge dans Visual Basic.
CA2259 : Vérifiez que ThreadStatic est utilisé uniquement avec des champs statiques	ThreadStaticAttribute affecte static uniquement les champs (Shared en Visual Basic). Quand il est appliqué aux champs d’instance, l’attribut n’a aucun impact sur le comportement.
CA2260 : Implémenter correctement des interfaces mathématiques génériques	Les interfaces mathématiques génériques nécessitent que le type dérivé lui-même soit utilisé pour le paramètre de type auto-récurrent.
CA2261 : Ne pas utiliser ConfigureAwaitOptions.SuppressThrowing avec Task<TResult>	L’option ConfigureAwaitOptions.SuppressThrowing n’est pas prise en charge par le Task<TResult> générique, car cela peut entraîner le renvoi d’un TResult non valide.
CA2262 : définir MaxResponseHeadersLength correctement	Vérifiez que la valeur MaxResponseHeadersLength est fournie correctement. Cette valeur est mesurée en kilo-octets.
CA2263 : préférer la surcharge générique lorsque le type est connu	L’utilisation d’une surcharge générique est préférable à la transmission d’un System.Type argument lorsque le type est connu, car ils favorisent un code plus propre et plus sécurisé avec des vérifications améliorées au moment de la compilation.
CA2264 : Ne passez pas de valeur non nullable à « ArgumentNullException.ThrowIfNull ».	'ArgumentNullException.ThrowIfNull' lève lorsque l’argument passé est 'null'. Certaines constructions telles que les structs non nullables, et « nameof() » et « new » sont connues pour ne jamais être null. Par conséquent, « ArgumentNullException.ThrowIfNull » ne lève jamais.
CA2265 : Ne pas comparer Span<T> ou nulldefault	Comparaison d’une étendue ou null default peut ne pas faire ce que vous avez prévu. default et le null littéral sont implicitement convertis en Span<T>.Empty.
CA2300 : N’utilisez pas le désérialiseur non sécurisé BinaryFormatter	Les désérialiseurs non sécurisés sont vulnérables lors de la désérialisation de données non approuvées. Un attaquant peut modifier les données sérialisées pour y inclure des types inattendus afin d’injecter des objets avec des effets secondaires malveillants.
CA2301 : N’appelez pas BinaryFormatter.Deserialize sans définir BinaryFormatter.Binder au préalable	Les désérialiseurs non sécurisés sont vulnérables lors de la désérialisation de données non approuvées. Un attaquant peut modifier les données sérialisées pour y inclure des types inattendus afin d’injecter des objets avec des effets secondaires malveillants.
CA2302 : Vérifiez que BinaryFormatter.Binder est défini avant d’appeler BinaryFormatter.Deserialize	Les désérialiseurs non sécurisés sont vulnérables lors de la désérialisation de données non approuvées. Un attaquant peut modifier les données sérialisées pour y inclure des types inattendus afin d’injecter des objets avec des effets secondaires malveillants.
CA2305 : N’utilisez pas le désérialiseur non sécurisé LosFormatter	Les désérialiseurs non sécurisés sont vulnérables lors de la désérialisation de données non approuvées. Un attaquant peut modifier les données sérialisées pour y inclure des types inattendus afin d’injecter des objets avec des effets secondaires malveillants.
CA2310 : N’utilisez pas le désérialiseur non sécurisé NetDataContractSerializer	Les désérialiseurs non sécurisés sont vulnérables lors de la désérialisation de données non approuvées. Un attaquant peut modifier les données sérialisées pour y inclure des types inattendus afin d’injecter des objets avec des effets secondaires malveillants.
CA2311 : Ne désérialisez pas sans définir d’abord NetDataContractSerializer.Binder	Les désérialiseurs non sécurisés sont vulnérables lors de la désérialisation de données non approuvées. Un attaquant peut modifier les données sérialisées pour y inclure des types inattendus afin d’injecter des objets avec des effets secondaires malveillants.
CA2312 : Vérifiez que NetDataContractSerializer.Binder est défini avant la désérialisation	Les désérialiseurs non sécurisés sont vulnérables lors de la désérialisation de données non approuvées. Un attaquant peut modifier les données sérialisées pour y inclure des types inattendus afin d’injecter des objets avec des effets secondaires malveillants.
CA2315 : N’utilisez pas le désérialiseur non sécurisé ObjectStateFormatter	Les désérialiseurs non sécurisés sont vulnérables lors de la désérialisation de données non approuvées. Un attaquant peut modifier les données sérialisées pour y inclure des types inattendus afin d’injecter des objets avec des effets secondaires malveillants.
CA2321 : Ne désérialisez avec JavaScriptSerializer à l’aide de SimpleTypeResolver	Les désérialiseurs non sécurisés sont vulnérables lors de la désérialisation de données non approuvées. Un attaquant peut modifier les données sérialisées pour y inclure des types inattendus afin d’injecter des objets avec des effets secondaires malveillants.
CA2322 : Assurez-vous que JavaScriptSerializer n’est pas initialisé avec SimpleTypeResolver avant la désérialisation	Les désérialiseurs non sécurisés sont vulnérables lors de la désérialisation de données non approuvées. Un attaquant peut modifier les données sérialisées pour y inclure des types inattendus afin d’injecter des objets avec des effets secondaires malveillants.
CA2326 : N’utilisez pas de valeurs TypeNameHandling autres que None	Les désérialiseurs non sécurisés sont vulnérables lors de la désérialisation de données non approuvées. Un attaquant peut modifier les données sérialisées pour y inclure des types inattendus afin d’injecter des objets avec des effets secondaires malveillants.
CA2327 : N’utilisez pas de JsonSerializerSettings non sécurisés	Les désérialiseurs non sécurisés sont vulnérables lors de la désérialisation de données non approuvées. Un attaquant peut modifier les données sérialisées pour y inclure des types inattendus afin d’injecter des objets avec des effets secondaires malveillants.
CA2328 : Vérifiez que les JsonSerializerSettings sont sécurisés	Les désérialiseurs non sécurisés sont vulnérables lors de la désérialisation de données non approuvées. Un attaquant peut modifier les données sérialisées pour y inclure des types inattendus afin d’injecter des objets avec des effets secondaires malveillants.
CA2329 : Ne désérialisez pas avec JsonSerializer à l’aide d’une configuration non sécurisée	Les désérialiseurs non sécurisés sont vulnérables lors de la désérialisation de données non approuvées. Un attaquant peut modifier les données sérialisées pour y inclure des types inattendus afin d’injecter des objets avec des effets secondaires malveillants.
CA2330 : Vérifiez que JsonSerializer a une configuration sécurisée lors de la désérialisation.	Les désérialiseurs non sécurisés sont vulnérables lors de la désérialisation de données non approuvées. Un attaquant peut modifier les données sérialisées pour y inclure des types inattendus afin d’injecter des objets avec des effets secondaires malveillants.
CA2350 : Vérifier que l’entrée de DataTable.ReadXml() est approuvée	Lors de la désérialisation d’un DataTable avec une entrée non approuvée, un attaquant peut créer une entrée malveillante pour effectuer une attaque par déni de service. Il peut y avoir des vulnérabilités inconnues d’exécution de code distant.
CA2351 : Vérifier que l’entrée de DataSet.ReadXml() est approuvée	Lors de la désérialisation d’un DataSet avec une entrée non approuvée, un attaquant peut créer une entrée malveillante pour effectuer une attaque par déni de service. Il peut y avoir des vulnérabilités inconnues d’exécution de code distant.
CA2352 : jeu de données ou table de données non sécurisé(e) dans un type sérialisable peut être vulnérable aux attaques par exécution de code à distance	Une classe ou un struct marqué avec SerializableAttribute contient un champ ou une propriété DataSet ou DataTable et n’a pas de GeneratedCodeAttribute.
CA2353 : jeu de données ou table de données non sécurisé(e) dans un type sérialisable	Une classe ou un struct marqué avec un attribut de sérialisation XML ou un attribut de contrat de données contient un champ ou une propriété DataSet ou DataTable.
CA2354 : Un jeu de données ou une table de données non sécurisé(e) dans un graphe d’objets désérialisé peut être vulnérable à une attaque par exécution de code à distance	La désérialisation avec un System.Runtime.Serialization.IFormatter sérialisé, et le graphique d’objet du type casté peut inclure un DataSet ou DataTable.
CA2355 : Jeu de données ou table de données non sécurisé(e) dans un graphe d’objets désérialisé	Désérialisation lorsque le graphique d’objet du type casté ou spécifié peut inclure un DataSet ou DataTable.
CA2356 : jeu de données ou table de données non sécurisé(e) dans un graphe d’objets désérialisé web	Une méthode avec un System.Web.Services.WebMethodAttribute ou System.ServiceModel.OperationContractAttribute a un paramètre qui peut référencer un DataSet ou DataTable.
CA2361 : vérifiez que la classe générée automatiquement contenant DataSet.ReadXml() n’est pas utilisée avec des données non fiables	Lors de la désérialisation d’un DataSet avec une entrée non approuvée, un attaquant peut créer une entrée malveillante pour effectuer une attaque par déni de service. Il peut y avoir des vulnérabilités inconnues d’exécution de code distant.
CA2362 : Un jeu de données ou une table de données non sécurisé dans un type sérialisable généré automatiquement peut être vulnérable aux attaques par exécution de code à distance	Lors de la désérialisation d’une entrée non approuvée avec BinaryFormatter et le graphe d’objets désérialisés contenant un DataSet ou DataTable, un attaquant peut créer une charge utile malveillante pour effectuer une attaque d’exécution de code à distance.
CA3001 : Passez en revue le code pour détecter les vulnérabilités de l’injection SQL	Lorsque vous travaillez avec des entrées non approuvées et des commandes SQL, gardez à l’esprit les attaques par injection de code SQL. Une attaque par injection de code SQL peut exécuter des commandes SQL malveillantes, ce qui compromet la sécurité et l’intégrité de votre application.
CA3002 : Passez en revue le code pour détecter les vulnérabilités des scripts XSS	Lorsque vous travaillez avec des entrées non approuvées provenant de requêtes web, tenez compte des attaques de scripting inter-site (XSS). Une attaque XSS injecte une entrée non approuvée dans une sortie HTML brute, ce qui permet à l’attaquant d’exécuter des scripts malveillants ou de modifier de manière malveillante le contenu de votre page web.
CA3003 : Passez en revue le code pour détecter les vulnérabilités de l’injection de chemin de fichier	Lorsque vous travaillez avec des entrées non approuvées provenant de requêtes web, veillez à utiliser une entrée contrôlée par l’utilisateur lors de la spécification des chemins d’accès aux fichiers.
CA3004 : Passez en revue le code pour détecter les vulnérabilités sur la divulgation d’informations	La divulgation d’informations sur les exceptions donne aux attaquants un aperçu des éléments internes de votre application, ce qui peut aider les attaquants à trouver d’autres vulnérabilités à exploiter.
CA3005 : Passez en revue le code pour les vulnérabilités d’injection LDAP	Lorsque vous utilisez une entrée non approuvée, tenez compte des attaques par injection LDAP (Lightweight Directory Access Protocol). Un attaquant peut exécuter des instructions LDAP malveillantes sur des répertoires d’informations. Les applications qui utilisent l’entrée utilisateur pour construire des instructions LDAP dynamiques pour accéder aux services d’annuaire sont particulièrement vulnérables.
CA3006 : Passez en revue le code pour détecter les vulnérabilités de l’injection de commande de processus	Lorsque vous travaillez avec des entrées non approuvées, gardez à l’esprit les attaques par injection de commandes. Une attaque par injection de commandes peut exécuter des commandes malveillantes sur le système d’exploitation sous-jacent, ce qui compromet la sécurité et l’intégrité de votre serveur.
CA3007 : Passez en revue le code pour détecter les vulnérabilités de la redirection ouverte	Lorsque vous travaillez avec une entrée non approuvée, gardez à l’esprit les vulnérabilités de redirection ouverte. Un attaquant peut exploiter une vulnérabilité de redirection ouverte pour utiliser votre site web afin de donner l’apparence d’une URL légitime, mais rediriger un visiteur qui n’est pas méfiant vers un hameçonnage ou une autre page web malveillante.
CA3008 : Passez en revue le code pour détecter les vulnérabilités de l’injection XPath	Lorsque vous travaillez avec une entrée non approuvée, n’oubliez pas les attaques par injection XPath. La construction de requêtes XPath à l’aide d’une entrée non approuvée peut permettre à un attaquant de manipuler malveillantment la requête pour retourner un résultat inattendu, et éventuellement de divulguer le contenu du code XML interrogé.
CA3009 : Passez en revue le code pour détecter les vulnérabilités de l’injection XML	Lorsque vous travaillez avec une entrée non approuvée, n’oubliez pas les attaques par injection XPath.
CA3010 : Passez en revue le code pour détecter les vulnérabilités de l’injection XAML	Lorsque vous travaillez avec une entrée non approuvée, n’oubliez pas les attaques par injection XAML. Le XAML est un langage de balisage qui représente directement l’instanciation d’objets et leur exécution. Cela signifie que les éléments créés en XAML peuvent interagir avec les ressources système (par exemple, l’accès réseau et les e/s de système de fichiers).
CA3011 : Passez en revue le code pour détecter les vulnérabilités de l’injection de DLL	Lorsque vous travaillez avec une entrée non approuvée, veillez à charger du code non approuvé. Si votre application web charge du code non approuvé, un attaquant peut être en mesure d’injecter des DLL malveillantes dans votre processus et d’exécuter du code malveillant.
CA3012 : Passez en revue le code pour détecter les vulnérabilités de l’injection regex	Lorsque vous travaillez avec une entrée non approuvée, n’oubliez pas les attaques par injection de regex. Un attaquant peut utiliser l’injection de regex pour modifier une expression régulière de manière malveillante, pour faire en sorte que le regex corresponde à des résultats inattendus, ou pour faire en sorte que le regex consomme un processeur excessif, ce qui entraîne une attaque par déni de service.
CA3061 : Ne pas ajouter de schéma par URL	N’utilisez pas la surcharge non sécurisée de la méthode Add, car cela peut entraîner des références externes dangereuses.
CA3075 : Traitement DTD non sécurisé	Si vous utilisez des instances DTDProcessing non sécurisées ou référencez des sources d’entités externes, l’analyseur peut accepter une entrée non approuvée et divulguer des informations sensibles aux attaquants.
CA3076 : Exécution non sécurisée de script XSLT	Si vous exécutez des transformations XSLT (Extensible Stylesheet Language Transformations) dans des applications .NET de manière non sécurisée, le processeur peut résoudre des références d’URI non approuvées qui pourraient divulguer des informations sensibles aux attaquants, ce qui entraîne des attaques par déni de service et intersite.
CA3077 : Traitement non sécurisé dans la conception d’API, le document XML et le lecteur de texte XML	Lors de la conception d’une API dérivée de XMLDocument et XMLTextReader, tenez compte de DtdProcessing. L’utilisation d’instances DTDProcessing non sécurisées lors du référencement ou de la résolution de sources d’entités externes ou de la définition de valeurs non sécurisées dans le code XML peut entraîner une divulgation d’informations.
CA3147 : Marquer les gestionnaires de verbe avec ValidateAntiForgeryToken	Lors de la conception d’un contrôleur MVC ASP.NET, tenez compte des attaques de falsification de requête inter-site. Une attaque de falsification de requête inter-site peut envoyer des requêtes malveillantes d’un utilisateur authentifié à votre contrôleur MVC ASP.NET.
CA5350 : N’utilisez pas d’algorithmes de chiffrement faibles	Des algorithmes de chiffrement et des fonctions de hachage faibles sont utilisés aujourd’hui pour plusieurs raisons, mais ils ne doivent pas servir à garantir la confidentialité ou l’intégrité des données qu’ils protègent. Cette règle se déclenche lorsqu’elle détecte des algorithmes TripleDES, SHA1 ou RIPEMD160 dans le code.
CA5351 : N’utilisez pas les algorithmes de chiffrement cassés	Les algorithmes de chiffrement cassés ne sont pas considérés comme sécurisés, et leur utilisation doit être fortement déconseillée. Cette règle se déclenche lorsqu’elle détecte l’algorithme de hachage MD5 ou les algorithmes de chiffrement RC2 ou DES dans le code.
CA5358 : Ne pas utiliser de modes de chiffrement non sécurisés	Ne pas utiliser de modes de chiffrement non sécurisés
CA5359 : Ne désactivez pas la validation de certificat	Un certificat peut vous aider à authentifier l’identité du serveur. Les clients doivent valider le certificat de serveur pour s’assurer que les demandes sont envoyées au serveur prévu. Si ServerCertificateValidationCallback retourne toujours true, tout certificat passera la validation.
CA5360 : N’appelez pas de méthodes dangereuses dans la désérialisation	La désérialisation non sécurisée est une vulnérabilité qui se produit lorsque des données non approuvées sont utilisées pour abuser de la logique d’une application, infliger une attaque par déni de service (DoS) ou même exécuter du code arbitraire lors de leur désérialisation. Il est souvent possible pour les utilisateurs malveillants d’abuser de ces fonctionnalités de désérialisation lorsque l’application désérialise des données non approuvées qui sont sous leur contrôle. Plus précisément, appelez des méthodes dangereuses dans le processus de désérialisation. Les attaques de désérialisation non sécurisée réussies pourraient permettre à un attaquant d’effectuer des attaques telles que les attaques par déni de service, les contournements d’authentification et l’exécution de code à distance.
CA5361 : Ne pas désactiver l’utilisation du chiffrement fort par Schannel	Régler Switch.System.Net.DontEnableSchUseStrongCrypto sur true affaiblit le chiffrement utilisé dans les connexions TLS (Transport Layer Security) sortantes. Un chiffrement plus faible peut compromettre la confidentialité de la communication entre votre application et le serveur, ce qui permet aux attaquants d’espionner plus facilement des données sensibles.
CA5362 : Cycle de référence potentiel dans le graphe d’objets désérialisé	Si vous désérialisez des données non approuvées, tout code traitant le graphe d’objets désérialisé doit gérer des cycles de référence sans passer par des boucles infinies. Cela inclut à la fois le code qui fait partie d’un rappel de désérialisation et le code qui traite le graphe d’objets une fois la désérialisation terminée. Sinon, un attaquant pourrait effectuer une attaque par déni de service avec des données malveillantes contenant un cycle de référence.
CA5363 : Ne pas désactiver la validation de demandes	La validation des demandes est une fonctionnalité de ASP.NET qui examine les requêtes HTTP et détermine si elles contiennent du contenu potentiellement dangereux qui peut entraîner des attaques par injection, y compris des scripting inter-site.
CA5364 : Ne pas utiliser de protocoles de sécurité dépréciés	TLS (Transport Layer Security) sécurise la communication entre les ordinateurs, le plus souvent avec HTTPS (Hypertext Transfer Protocol Secure). Les versions de protocole plus anciennes de TLS sont moins sécurisées que TLS 1.2 et TLS 1.3 et sont plus susceptibles d’avoir de nouvelles vulnérabilités. Évitez les anciennes versions de protocole pour réduire les risques.
CA5365 : Ne désactivez pas la vérification des en-têtes HTTP	La vérification de l’en-tête HTTP permet l’encodage des caractères de retour chariot et de nouvelle ligne, \r et \n, qui se trouvent dans les en-têtes de réponse. Cet encodage peut aider à éviter les attaques par injection qui exploitent une application qui renvoie des données non approuvées contenues dans l’en-tête.
CA5366 : Utilisez XmlReader pour lire les données XML d’un jeu de données	L’utilisation d’un DataSet code XML avec des données non approuvées peut charger des références externes dangereuses, qui doivent être limitées à l’aide d’un XmlReader programme de résolution sécurisé ou avec un traitement DTD désactivé.
CA5367 : Ne sérialisez pas les types avec des champs de pointeur	Cette règle vérifie s’il existe une classe sérialisable avec un champ ou une propriété de pointeur. Les membres qui ne peuvent pas être sérialisés peuvent être un pointeur, comme des membres statiques ou des champs marqués avec NonSerializedAttribute.
CA5368 : Définissez ViewStateUserKey pour les classes dérivées de Page	La définition de la propriété ViewStateUserKey peut vous aider à empêcher les attaques sur votre application en vous permettant d’affecter un identificateur à la variable d’état d’affichage pour des utilisateurs individuels afin que les attaquants ne puissent pas utiliser la variable pour générer une attaque. Dans le cas contraire, il y aura des vulnérabilités à la falsification des requêtes inter-site.
CA5369 : Utiliser XmlReader pour la désérialisation	Le traitement des schémas DTD et XML non approuvés peut permettre de charger des références externes dangereuses, qui doivent être restreintes à l’aide d’un xmlReader avec un programme de résolution sécurisé ou avec le traitement de schéma inline DTD et XML désactivé.
CA5370 : Utiliser XmlReader pour la validation du lecteur	Le traitement des schémas DTD et XML non approuvés peut permettre de charger des références externes dangereuses. Ce chargement dangereux peut être limité à l’aide d’un XmlReader avec un programme de résolution sécurisé ou avec le traitement de schéma inclus DTD et XML désactivé.
CA5371 : Utiliser XmlReader pour la lecture de schéma	Le traitement des schémas DTD et XML non approuvés peut permettre de charger des références externes dangereuses. L’utilisation d’un XmlReader avec un programme de résolution sécurisé ou avec le traitement de schéma inclus DTD et XML désactivé limite cela.
CA5372 : Utiliser XmlReader pour XPathDocument	Le traitement xml à partir de données non approuvées peut charger des références externes dangereuses, qui peuvent être restreintes à l’aide d’un xmlReader avec un programme de résolution sécurisé ou avec le traitement DTD désactivé.
CA5373 : Ne pas utiliser la fonction de dérivation de clé obsolète	Cette règle détecte l’appel des méthodes System.Security.Cryptography.PasswordDeriveBytes et Rfc2898DeriveBytes.CryptDeriveKey de dérivation de clé faible. System.Security.Cryptography.PasswordDeriveBytes a utilisé un algorithme faible PBKDF1.
CA5374 : N’utilisez pas XslTransform	Cette règle vérifie si System.Xml.Xsl.XslTransform est instancié dans le code. System.Xml.Xsl.XslTransform est désormais obsolète et ne doit pas être utilisé.
CA5375 : N’utilisez pas de signature d’accès partagé au compte	Un compte SAP peut déléguer l’accès aux opérations de lecture, d’écriture et de suppression sur les conteneurs d’objets blob, les tables, les files d’attente et les partages de fichiers qui ne sont pas autorisées avec une SAP de service. Toutefois, il ne prend pas en charge les stratégies au niveau du conteneur et offre moins de flexibilité et de contrôle sur les autorisations accordées. Une fois que les utilisateurs malveillants l’obtiennent, votre compte de stockage est facilement compromis.
CA5376 : Utilisez SharedAccessProtocol HttpsOnly	La SAP est une données sensible qui ne peut pas être transportée en texte brut sur HTTP.
CA5377 : Utilisez une stratégie d’accès au niveau du conteneur	Une stratégie d’accès au niveau du conteneur peut être modifiée ou révoquée à tout moment. Cela offre plus de flexibilité et de contrôle sur les autorisations accordées.
CA5378 : Ne pas désactiver ServicePointManagerSecurityProtocols	Régler Switch.System.ServiceModel.DisableUsingServicePointManagerSecurityProtocols sur true limite les connexions TLS (Transport Layer Security) de WCF (Windows Communication Framework) à l’utilisation de TLS 1.0. Cette version de TLS sera déconseillée.
CA5379 : N’utilisez pas l’algorithme de fonction de dérivation de clé faible	La classe Rfc2898DeriveBytes utilise par défaut l’algorithme SHA1. Vous devez spécifier l’algorithme de hachage à utiliser dans certaines surcharges du constructeur avec SHA256 ou une version ultérieure. Notez que la propriété HashAlgorithm a uniquement un accesseur get et n’a pas de modificateur overridden.
CA5380 : Ne pas ajouter de certificats au magasin racine	Cette règle détecte le code qui ajoute un certificat dans le magasin de certificats Autorités de certification racines de confiance. Par défaut, le magasin de certificats Autorités de certification racines de confiance est configuré avec un ensemble d’autorités de certification publiques qui ont satisfait aux exigences du programme de certificats racines Microsoft.
CA5381 : S’assurer que les certificats ne sont pas ajoutés au magasin racine	Cette règle détecte le code qui ajoute un certificat dans le magasin de certificats Autorités de certification racines de confiance. Par défaut, le magasin de certificats Autorités de certification racines de confiance est configuré avec un ensemble d’autorités de certification publiques qui ont satisfait aux exigences du programme de certificats racines Microsoft.
CA5382 : Utilisez des cookies sécurisés dans ASP.NET Core	Les applications disponibles via HTTPS doivent utiliser des cookies sécurisés, qui indiquent au navigateur que le cookie doit être transmis uniquement à l’aide de SSL (Secure Sockets Layer).
CA5383 : Vérifiez l’utilisation de cookies sécurisés dans ASP.Net Core	Les applications disponibles via HTTPS doivent utiliser des cookies sécurisés, qui indiquent au navigateur que le cookie doit être transmis uniquement à l’aide de SSL (Secure Sockets Layer).
CA5384 : N’utilisez pas DSA (Digital Signature Algorithm)	DSA est un algorithme de chiffrement asymétrique faible.
CA5385 : Utilisez l’algorithme RSA (Rivest–Shamir–Adleman) avec une taille de clé suffisante	Une clé RSA inférieure à 2 048 bits est plus vulnérable aux attaques par force brute.
CA5386 : Éviter tout codage en dur de la valeur de SecurityProtocolType	TLS (Transport Layer Security) sécurise la communication entre les ordinateurs, le plus souvent avec HTTPS (Hypertext Transfer Protocol Secure). Les versions de protocole TLS 1.0 et TLS 1.1 sont déconseillées, tandis que TLS 1.2 et TLS 1.3 sont à jour. À l’avenir, TLS 1.2 et TLS 1.3 peuvent être déconseillés. Pour vous assurer que votre application reste sécurisée, évitez de coder en dur une version de protocole et ciblez au moins .NET Framework v4.7.1.
CA5387 : N’utilisez pas la fonction de dérivation de clés faibles avec un nombre insuffisant d’itérations	Cette règle vérifie si une clé de chiffrement a été générée par Rfc2898DeriveBytes avec un nombre d’itérations inférieur à 100 000. Un nombre d’itérations plus élevé peut aider à atténuer les attaques de dictionnaire qui tentent de deviner la clé de chiffrement générée.
CA5388 : Vérifiez que le nombre d’itérations est suffisant lors de l’utilisation de la fonction de dérivation de clés faibles	Cette règle vérifie si une clé de chiffrement a été générée avec Rfc2898DeriveBytes un nombre d’itérations qui peut être inférieur à 100 000. Un nombre d’itérations plus élevé peut aider à atténuer les attaques de dictionnaire qui tentent de deviner la clé de chiffrement générée.
CA5389 : Ne pas ajouter le chemin de l’élément d’archive au chemin du système de fichiers cible	Le chemin d’accès au fichier peut être relatif et peut conduire à un accès au système de fichiers en dehors du chemin cible du système de fichiers attendu, ce qui entraîne des modifications de configuration malveillantes et l’exécution de code à distance via la technique de mise en place et d’attente.
CA5390 : Ne codez pas en dur la clé de chiffrement	Pour qu’un algorithme symétrique réussisse, la clé secrète doit être connue uniquement de l’expéditeur et du récepteur. Lorsqu’une clé est codée en dur, elle est facilement découverte. Même avec des fichiers binaires compilés, il est facile pour les utilisateurs malveillants de les extraire. Une fois la clé privée compromise, le texte de chiffrement peut être déchiffré directement et n’est plus protégé.
CA5391 : Utilisez des jetons antifalsification dans les contrôleurs ASP.NET Core MVC	La gestion d’un POSTjeton antiforforateur ou PUTPATCHDELETE d’une requête sans validation d’un jeton antiforgery peut être vulnérable aux attaques de falsification de requête intersite. Une attaque par falsification de requête inter-site peut envoyer des demandes malveillantes d’un utilisateur authentifié à votre contrôleur ASP.NET Core MVC.
CA5392 : Utilisez l’attribut DefaultDllImportSearchPaths pour les P/Invokes	Par défaut, les fonctions P/Invoke à l’aide de DllImportAttribute sondent un certain nombre de répertoires, y compris le répertoire de travail actuel que la bibliothèque doit charger. Il peut s’agir d’un problème de sécurité pour certaines applications, entraînant un détournement de DLL.
CA5393 : N’utilisez pas de valeur DllImportSearchPath non sécurisée	Il peut y avoir une DLL malveillante dans les répertoires de recherche de DLL par défaut et les répertoires d’assembly. Ou, selon l’emplacement d’exécution de votre application, il peut y avoir une DLL malveillante dans le répertoire de l’application.
CA5394 : N’utilisez pas de sélection aléatoire non sécurisée	L’utilisation d’un générateur de nombres pseudo-aléatoires faible par chiffrement peut permettre à un attaquant de prédire la valeur sensible à la sécurité qui sera générée.
CA5395 : Attribut HttpVerb manquant pour les méthodes d’action	Toutes les méthodes d’action qui créent, modifient, suppriment ou modifient des données doivent être protégées par l’attribut antifalsification contre les attaques par falsification de requête inter-site. Une opération GET doit être sûre, ne doit avoir aucun effet secondaire et ne doit pas modifier vos données persistantes.
CA5396 : Affectez la valeur true à HttpOnly pour HttpCookie	En guise de mesure de défense en profondeur, assurez-vous que les cookies HTTP sensibles pour la sécurité sont marqués comme HttpOnly. Cela indique que les navigateurs web doivent interdire aux scripts d’accéder aux cookies. Les scripts malveillants injectés sont un moyen courant de voler des cookies.
CA5397 : Ne pas utiliser de valeurs SslProtocols dépréciées	TLS (Transport Layer Security) sécurise la communication entre les ordinateurs, le plus souvent avec HTTPS (Hypertext Transfer Protocol Secure). Les versions de protocole plus anciennes de TLS sont moins sécurisées que TLS 1.2 et TLS 1.3 et sont plus susceptibles d’avoir de nouvelles vulnérabilités. Évitez les anciennes versions de protocole pour réduire les risques.
CA5398 : Éviter les valeurs SslProtocols codées en dur	TLS (Transport Layer Security) sécurise la communication entre les ordinateurs, le plus souvent avec HTTPS (Hypertext Transfer Protocol Secure). Les versions de protocole TLS 1.0 et TLS 1.1 sont déconseillées, tandis que TLS 1.2 et TLS 1.3 sont à jour. À l’avenir, TLS 1.2 et TLS 1.3 peuvent être déconseillés. Pour garantir la sécurité de votre application, évitez de coder en dur une version de protocole.
CA5399 : Désactivez définitivement la vérification de la liste de révocation de certificats HttpClient	Un certificat révoqué n’est plus approuvé. Il peut être utilisé par des attaquants qui transmettent des données malveillantes ou volent des données sensibles dans les communications HTTPS.
CA5400 : Contrôlez si la vérification de la liste de révocation de certificats HttpClient est bien activée	Un certificat révoqué n’est plus approuvé. Il peut être utilisé par des attaquants qui transmettent des données malveillantes ou volent des données sensibles dans les communications HTTPS.
CA5401 : N’utilisez pas CreateEncryptor avec une valeur IV non définie par défaut	Le chiffrement symétrique doit toujours utiliser un vecteur d’initialisation non répétable pour empêcher les attaques par dictionnaire.
CA5402 : Utilisez CreateEncryptor avec la valeur IV par défaut	Le chiffrement symétrique doit toujours utiliser un vecteur d’initialisation non répétable pour empêcher les attaques par dictionnaire.
CA5403 : Ne pas coder en dur le certificat	Le paramètre data ou rawData d’un constructeur X509Certificate ou X509Certificate2 est codé en dur.
CA5404 : ne désactivez pas les vérifications de validation de jeton	Les propriétés TokenValidationParameters qui contrôlent la validation des jetons ne doivent pas être définies sur false.
CA5405 : n’ignorez pas toujours la validation des jetons dans les délégués	Le rappel affecté à AudienceValidator ou LifetimeValidator retourne toujours true.
IL3000 : Évitez d’accéder au chemin d’accès du fichier Assembly lors de la publication en tant que fichier unique	Évitez d’accéder au chemin du fichier Assembly lors de la publication en tant que fichier unique.
IL3001 : Éviter d’accéder au chemin d’accès au fichier Assembly lors de la publication en tant que fichier unique	Évitez d’accéder au chemin du fichier Assembly lors de la publication en tant que fichier unique.
IL3002 : Évitez d’appeler des membres annotés avec « RequiresAssemblyFilesAttribute » lors de la publication en tant que fichier unique	Évitez d’appeler des membres annotés avec « RequiresAssemblyFilesAttribute » lors de la publication en tant que fichier unique
IL3003 : les annotations « RequiresAssemblyFilesAttribute » doivent correspondre à toutes les implémentations ou substitutions d’interface.	Les annotations « RequiresAssemblyFilesAttribute » doivent correspondre à toutes les implémentations ou substitutions d’interface.

Légende

Le tableau suivant indique le type d’informations fourni pour chaque règle dans la documentation de référence.

Élément	Description
Type	TypeName de la règle.
Identificateur de la règle	Identificateur unique de la règle. Ruleld et Category sont utilisés pour la suppression à la source d’un avertissement.
Catégorie	Catégorie de la règle, par exemple, sécurité.
Le correctif est cassant ou non cassant	Indique si la correction d’une violation de la règle constitue une modification avec rupture. Une modification avec rupture signifie qu’un assembly qui présente une dépendance à la cible ayant provoqué la violation ne se recompile pas avec la nouvelle version corrigée ou peut échouer au moment de l’exécution en raison de la modification. Quand plusieurs corrections sont possibles et qu’au moins l’une d’elles est une modification avec rupture et qu’une autre ne l’est pas, les caractéristiques « Avec rupture » et « Sans rupture » sont toutes deux spécifiées.
Cause	Code managé spécifique qui contraint la règle à générer un avertissement.
Description	Décrit les problèmes sous-jacents à l’avertissement.
Comment corriger les violations	Explique comment modifier le code source pour satisfaire la règle et l’empêcher de générer un avertissement.
Quand supprimer les avertissements	Décrit les circonstances dans lesquelles il est possible de supprimer un avertissement de la règle en toute sécurité.
Exemple de code	Exemples qui violent la règle et exemples corrigés qui satisfont la règle.
Règles associées	Règles associées.