Remarque
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de vous connecter ou de modifier des répertoires.
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de modifier des répertoires.
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 des 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 de type IDisposable doivent être jetables | 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 des instances de 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 énumérations doivent avoir une 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 abstraits 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 des 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 de sortie | 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 le cas échéant | 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 des énumérations 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 : Le stockage enum 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 le cas échéant | 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 les types d’exceptions généraux | 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’exceptions standard | Ne pas fournir le jeu complet de constructeurs peut rendre difficile une gestion des exceptions correcte. |
| CA1033 : Les méthodes d’interface doivent ê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 : Redéfinir les méthodes sur des types comparables | 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 type entier ou chaîne 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 surchargez pas 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 de membres protégés dans des types scellés | 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 des 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’instance 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 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 conteneurs statiques ne doivent pas avoir de constructeurs | 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 d’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 d’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 d’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 P/Invokes vers la 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 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 des 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 déclencher d’exceptions dans des emplacements inattendus | Une méthode dont l'objet n'est pas de lever des exceptions lève une exception. |
| CA1066 : Implémenter IEquatable lors de la redéfinition de Equals | Un type valeur remplace la méthode Equals, mais n’implémente pas IEquatable<T>. |
| CA1067: Redéfinir 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 énumérations 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 les champs d’événements en tant que 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 tant que 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 plus de clarté | 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 la valeur ordinale de StringComparison | 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 garantir l’exactitude | 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/Invokes 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 : Ne pas utiliser OutAttribute sur les paramètres de chaîne pour les P/Invokes |
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 : Utiliser 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 contenant 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 : Propriété, type ou attribut nécessite le marshaling d’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’héritage excessif | 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 une complexité excessive | 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 non maintenable | 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 un couplage de classe excessif | 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 contient du code conditionnel qui s’évalue toujours à true ou false à 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 la méthode d’assistance de levée ArgumentNullException | Les assistants de levée sont plus simples et plus efficaces que les blocs if qui créent une nouvelle instance d’exception. |
| CA1511 : Utiliser la méthode d’assistance de levée ArgumentException | Les assistants de levée sont plus simples et plus efficaces que les blocs if qui créent une nouvelle instance d’exception. |
| CA1512 : Utiliser la méthode d’assistance de levée ArgumentOutOfRangeException | Les assistants de levée sont plus simples et plus efficaces que les blocs if qui créent une nouvelle instance d’exception. |
| CA1513 : Utiliser la méthode d’assistance de levée ObjectDisposedException | Les assistants de levée sont plus simples et plus efficaces que les blocs if qui créent 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. Elle est également inutile. |
| CA1515 : Envisagez de rendre internes les types publics | 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. |
| CA1516 : Utiliser des intrinsèques multiplateformes | Cette règle détecte l’utilisation d’intrinsèques spécifiques à la plateforme qui peuvent être remplacées par une intrinsèque multiplateforme équivalente à la place. |
CA1517 : Utiliser ReadOnlySpan<T> ou Span<T> au lieu de ReadOnlyMemory<T> ou Memory<T> |
Un paramètre de méthode utilise Span<T> ou Memory<T> même si la méthode ne modifie pas les données. Utilisez son équivalent en lecture seule pour clarifier l’intention. |
| CA1700 : Ne nommez pas les membres d’énumération « Réservé » | 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 caractères 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 doivent différer par autre chose que la 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 avoir 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 avoir de 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 : Ne pas préfixer les valeurs d’énumération avec le nom du type | 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 avoir le 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 énumérations d’indicateurs doivent avoir des noms pluriels | 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 avoir 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 aux 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 : Seules les énumérations FlagsAttribute doivent avoir des noms pluriels | 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 type | 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 de propriétés ne doivent pas correspondre aux 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 correspondre 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 de 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 : Utiliser PascalCase pour les espaces réservés avec nom | Utilisez PascalCase pour les espaces réservés nommés dans le modèle de message de journalisation. |
| CA1801 : Passer 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 : Utiliser des littéraux le cas échéant | Un champ est déclaré statique et en lecture seule (Shared et ReadOnly en Visual Basic) et est initialisé avec une valeur qui est calculable à la compilation. Étant donné que la valeur affectée au champ ciblé est computable au moment de la compilation, remplacez la déclaration par un champ const (Const en Visual Basic) afin que la valeur soit calculée au moment de la compilation au lieu de l’exécution. |
| CA1805 : Ne pas initialiser inutilement | Le runtime .NET initialise tous les champs de types de référence à leurs valeurs par défaut avant d’exécuter le constructeur. Dans la plupart des cas, l’initialisation explicite d’un champ à sa valeur par défaut est redondante, ce qui ajoute aux coûts de maintenance et peut dégrader les performances (par exemple, avec une augmentation de la taille de l’assembly). |
| CA1806 : Ne pas ignorer les résultats de la méthode | 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 : Initialiser des champs statiques de type référence inline | 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 : Éviter 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 : Éviter les attributs non scellés | .NET fournit des méthodes pour récupérer des attributs personnalisés. Par défaut, ces méthodes recherchent la hiérarchie d'héritage des attributs. Le fait de sceller l'attribut élimine la recherche dans la hiérarchie d'héritage et peut améliorer les performances. |
| CA1814: Préférer les tableaux en dents de scie aux 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 : Redéfinir Equals et l’opérateur d’égalité pour les types valeur | Pour les types valeur, l'implémentation héritée de Equals utilise la bibliothèque Reflection et compare le contenu de tous les champs. Le processus de réflexion sollicite fortement les ressources informatiques et la comparaison de chaque champ à la recherche d'une égalité peut s'avérer inutile. Si des utilisateurs sont susceptibles de comparer ou de trier des instances, ou de les utiliser en tant que clés de table de hachage, votre type valeur doit implémenter Equals. |
| CA1816 : Appelez 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 de 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 : Tester les chaînes vides en utilisant la longueur de la 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 : Supprimer 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 : Marquer les membres comme statiques | Les membres qui n’accèdent pas aux données d’instance ou n’appellent pas de méthodes d’instance peuvent être marquées 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 : Éviter 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 tableaux 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 la propriété au lieu de la méthode Linq Enumerable | Enumerable La méthode LINQ a été utilisée sur un type qui prend en charge une propriété équivalente et plus efficace. |
| CA1827 : N’utilisez pas Count/LongCount quand Any peut être utilisé | la méthode Count ou LongCount a été utilisée alors que la méthode Any serait plus efficace. |
| CA1828 : N’utilisez pas CountAsync/LongCountAsync lorsque AnyAsync peut être utilisé | La méthode CountAsync ou LongCountAsync a été utilisée alors que la méthode AnyAsync serait plus efficace. |
| CA1829 : Utiliser la propriété Length/Count au lieu de la méthode Enumerable.Count |
Count La méthode LINQ a été utilisée sur un type qui prend en charge une propriété Length ou Count équivalente et 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 qui utilisent ToString() et la surcharge basée sur des chaînes. |
| CA1831 : Utiliser AsSpan au lieu des indexeurs basés sur la plage pour la chaîne, le cas échéant | 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 au lieu des indexeurs basés sur la plage pour obtenir une 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 au lieu des indexeurs basés sur la plage pour obtenir une 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 d’un seul caractère |
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érer les Memorysurcharges basées sur ReadAsync et WriteAsync |
Stream a une surcharge ReadAsync qui prend un/une Memory<Byte> comme premier argument, et une surcharge WriteAsync qui prend un/une ReadOnlyMemory<Byte> comme premier argument. Préférez appeler les surcharges basées sur la mémoire, qui sont plus efficaces. |
CA1836 : Préférer IsEmpty à Count quand il est disponible |
Préférez la propriété IsEmpty plus efficace que Count, Length, Count<TSource>(IEnumerable<TSource>) ou LongCount<TSource>(IEnumerable<TSource>) pour déterminer si l’objet contient ou non des éléments. |
CA1837 : Utiliser Environment.ProcessId au lieu de Process.GetCurrentProcess().Id |
Environment.ProcessId est plus simple et plus rapide que Process.GetCurrentProcess().Id. |
CA1838 : Éviter les paramètres StringBuilder pour les appels P/Invoke |
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 : Utiliser Environment.CurrentManagedThreadId au lieu de Thread.CurrentThread.ManagedThreadId |
Environment.CurrentManagedThreadId est plus compact et plus efficace que Thread.CurrentThread.ManagedThreadId. |
| CA1841 : Préférer les méthodes Contains de Dictionary | L’appel Contains sur la collection Keys ou Values peut souvent être plus coûteux que l’appel de ContainsKey ou ContainsValue sur le dictionnaire lui-même. |
CA1842 : Ne pas utiliser WhenAll avec une seule tâche |
L’utilisation de WhenAll avec une seule tâche peut entraîner une perte de performances. Attendez ou retournez la tâche à la place. |
CA1843 : Ne pas utiliser WaitAll avec une seule tâche |
L’utilisation de WaitAll avec une seule tâche peut entraîner une perte de performances. Attendez ou retournez la tâche à la place. |
CA1844 : Fournir des remplacements basés sur la mémoire des méthodes asynchrones lors de la création d’une sous-classe 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 : Utiliser string.Concat basé sur span |
Il est plus efficace d’utiliser AsSpan et string.Concat, au lieu de Substring et un opérateur de concaténation. |
CA1846 : Préférer AsSpan à Substring |
AsSpan est plus efficace que Substring.
Substring effectue une copie de chaîne de caractères en O(n), tandis que AsSpan ne le fait pas et a un coût constant.
AsSpan n’effectue pas non plus d’allocations de tas. |
| CA1847 : Utiliser le littéral char pour une recherche d’un seul caractère | Utilisez String.Contains(char) plutôt que String.Contains(string) lors de la recherche d’un caractère unique. |
| CA1848 : Utiliser les délégués LoggerMessage | Pour améliorer les performances, utilisez les délégués LoggerMessage. |
| CA1849 : Appelez les méthodes asynchrones lorsque vous êtes 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érer la méthode statique HashData par rapport à ComputeHash |
Il est plus efficace d’utiliser la méthode HashData statique que de créer et gérer une instance HashAlgorithm pour appeler ComputeHash. |
CA1851 : Énumérations multiples possibles de la collection IEnumerable |
Plusieurs énumérations possibles de la collection IEnumerable. Envisagez d’utiliser une implémentation qui évite plusieurs énumérations. |
| CA1852 : Sceller les types internes | Un type qui n’est pas accessible en dehors de son 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 ne lève pas d’exception si elle n’existe pas. |
CA1854 : Préférer la IDictionary.TryGetValue(TKey, out TValue) méthode |
Préférez TryGetValueà un indexeur de dictionnaire protégé par une vérification ContainsKey.
ContainsKey et l’indexeur recherchent la clé, donc l’utilisation de TryGetValue évite la recherche supplémentaire. |
| CA1855 : Utiliser 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 : Utiliser 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 argument ne sont pas réutilisés, ce qui implique une surcharge de performance. Envisagez de les extraire en static readonly champs pour améliorer les performances. |
CA1862 : Utilisez les surcharges de la méthode StringComparison pour effectuer des comparaisons de chaînes sans tenir compte de la casse |
Lorsque le code appelle ToLower() ou ToUpper() pour effectuer une comparaison de chaînes insensible à la casse, une allocation inutile est effectuée. |
CA1863 : Utiliser CompositeFormat |
Pour réduire le coût de mise en forme, mettez en cache et utilisez une instance de CompositeFormat comme argument pour String.Format ou StringBuilder.AppendFormat. |
CA1864 : Préférer la Dictionary.TryAdd(TKey, TValue) méthode |
Dictionary<TKey,TValue>.ContainsKey(TKey) et Dictionary<TKey,TValue>.Add effectuent toutes deux une recherche, ce qui est redondant. Il est plus efficace d’appeler Dictionary<TKey,TValue>.TryAdd, qui retourne un bool indicateur 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 ensembles |
ISet<T>.Add(T) et ICollection<T>.Remove(T) effectuent toutes deux une recherche, ce qui rend redondant l'appel préalable à ICollection<T>.Contains(T). Il est plus efficace d'appeler directement Add(T) ou Remove(T), qui renvoie une valeur booléenne indiquant si l’élément a été ajouté ou supprimé. |
CA1869 : Mettre en cache et réutiliser des JsonSerializerOptions instances |
L'utilisation d'une instance locale de JsonSerializerOptions pour la sérialisation ou la désérialisation peut fortement dégrader les performances 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 mise en SearchValues cache |
L’utilisation d’une instance mise SearchValues<T> en cache est plus efficace que de passer des valeurs vers IndexOfAny ou ContainsAny directement. |
CA1871 : Ne passez pas de structure nullable à ArgumentNullException.ThrowIfNull |
ArgumentNullException.ThrowIfNull accepte un object, de sorte que le passage d’une structure nullable peut entraîner la mise en boîte de la valeur. |
CA1872 : Préférer Convert.ToHexString et Convert.ToHexStringLower aux chaînes d’appels basées sur BitConverter.ToString |
Utilisez Convert.ToHexString ou Convert.ToHexStringLower pour encoder des octets sous forme de chaîne hexadécimale. Ces méthodes sont plus efficaces et consomment moins de mémoire que l’utilisation de BitConverter.ToString combinée à String.Replace pour remplacer les tirets et String.ToLower. |
| CA1873 : Éviter la journalisation potentiellement coûteuse | Dans de nombreuses situations, la journalisation est désactivée ou définie sur un niveau de journalisation qui entraîne une évaluation inutile pour les arguments de journalisation. |
CA1874 : Utiliser Regex.IsMatch |
Regex.IsMatch est plus simple et plus rapide que Regex.Match(...).Success. |
CA1875 : Utiliser Regex.Count |
Regex.Count est plus simple et plus rapide que Regex.Matches(...).Count. |
| CA1876 : N’utilisez pas « AsParallel » dans « foreach » | L’appel direct à AsParallel() dans une boucle foreach ne rend pas la boucle parallèle. Utilisez Parallel.ForEach pour traiter chaque élément en parallèle. |
| CA1877 : Utiliser les surcharges « Path.Combine » ou « Path.Join » | Lorsque plusieurs opérations Path.Combine ou Path.Join sont imbriquées, elles peuvent être consolidées en une seule opération pour améliorer les performances et la lisibilité. |
| CA1878 : Préférer les propriétés ReadOnlySpan sur les champs de tableau en lecture seule | Un champ de tableau privé statique en lecture seule peut être remplacé par une propriété ReadOnlySpan<T> afin que le compilateur C# puisse éviter l’allocation d’un tableau managé. |
| CA2000 : Libérer les objets avant qu’ils ne sortent 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 pas verrouiller les objets avec une 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 créez pas de tâches sans passer un 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 de l’espace de noms System.Collections.Immutable. |
| CA2011 : Ne pas affecter de propriété dans son setter | Une propriété a été affectée accidentellement à une valeur au sein de son propre accesseur set. |
| CA2012 : Utiliser ValueTasks correctement | Les valueTasks retournés par les appels de membres sont destinés à être directement attendus. Tenter de consommer un ValueTask plusieurs fois ou d’accéder directement à son résultat avant qu’il ne soit terminé peut entraîner une exception ou une corruption. Ignorer un tel ValueTask est probablement un signe de bug fonctionnel et peut dégrader les performances. |
| CA2013 : N’utilisez pas 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 : N’utilisez pas de 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> | Ajouter un finaliseur à un type dérivé de MemoryManager<T> peut permettre de libérer la mémoire alors qu’elle est encore utilisée par un Span<T>. |
| CA2016 : Transférer le paramètre CancellationToken aux méthodes qui en prennent une | 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 de 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, sbyte et bool ont des éléments d’une taille d’un octet. |
CA2019 : ThreadStatic les champs 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 le changement comportemental provoqué 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 à 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 vérifiée. |
| CA2023 : Accolades non valides dans le modèle de message | Les accolades présentes dans le modèle de message ne sont pas valides. Vérifiez que toutes les accolades dans le modèle de message sont des accolades ouvrantes/fermantes valides ou sont échappées. |
| CA2024 : N’utilisez pas StreamReader.EndOfStream dans les méthodes asynchrones | La propriété StreamReader.EndOfStream peut provoquer un blocage synchrone imprévu lorsqu’aucune donnée n’est mise en mémoire tampon. Utilisez plutôt StreamReader.ReadLineAsync() directement, qui retourne null lorsque vous atteignez la fin du flux. |
CA2025 : Ne pas passer des instances de IDisposable à des tâches non attendues |
Les tâches non attendues qui utilisent des instances de IDisposable peuvent continuer à utiliser ces instances longtemps après leur suppression. Vérifiez que les tâches utilisant ces instances sont terminées avant la suppression des instances. |
| CA2026: Préférer JsonElement.Parse à JsonDocument.Parse().RootElement | Il est plus efficace d’appeler JsonElement.Parse directement que d’appeler JsonDocument.Parse().RootElement. |
| CA2027 : Annuler Task.Delay une fois que Task.WhenAny est terminé | Une tâche noncancelable Task.Delay continue à s’exécuter une fois qu’une autre tâche s’est terminée dans un appel à Task.WhenAny. |
| CA2028 : Évitez l’appel redondant « Regex.IsMatch » avant « Regex.Match ». | L’appel des deux méthodes avec la même entrée et le même motif évalue l’expression régulière deux fois. Appelez Regex.Match une fois et cochez Match.Success. |
| CA2100 : Examiner les requêtes SQL afin d’identifier d’éventuelles 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 utilisateur. Une chaîne de commande SQL générée par une entrée utilisateur est vulnérable aux attaques par injection de code SQL. |
| CA2101 : Spécifier le marshaling pour les arguments de type chaîne de 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 : Passer 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 : Sceller les méthodes qui implémentent des 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 de gérer les exceptions d’é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 : Lever à nouveau pour préserver les détails de la pile des appels | 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 pas lever de types d’exception réservés | Cela rend l'erreur d'origine difficile à détecter et à déboguer. |
| CA2207 : Initialiser des champs statiques de type valeur inline | 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: Instancier correctement les exceptions d’argument | Un appel est effectué au constructeur par défaut (sans paramètre) d’un type d’exception dérivé de ArgumentException, ou une chaîne incorrecte est transmise à un constructeur paramétré d’un type d’exception dérivé 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 à libérer doivent être libérés | 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 surchargeables dans les constructeurs | Lorsqu’un constructeur appelle une méthode virtuelle, le constructeur de l’instance qui appelle la méthode pourrait ne pas avoir é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 IDisposable 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 pas marquer les énumérations avec 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: Redéfinissez GetHashCode lors de la redéfinition de Equals | Un type public se substitue à System.Object.Equals, mais pas à System.Object.GetHashCode. |
| CA2219 : Ne pas déclencher 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 de filtre, l’exécution (runtime) intercepte silencieusement l’exception. Cela rend l'erreur d'origine difficile à détecter et à déboguer. |
| CA2224: Redéfinir Equals lors de la surcharge de l’opérateur d’égalité | Un type public implémente l’opérateur d’égalité, mais ne se substitue pas à System.Object.Equals. |
| CA2225: Les surcharges d’opérateur ont des alternatives 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 avoir 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émenter 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 d’égalité lors de la redéfinition de ValueType.Equals | Un type valeur se substitue à Object.Equals mais n'implémente pas l'opérateur d'égalité. |
| CA2234 : Passer des objets System.Uri au lieu 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 : Marquer tous les champs non sérialisables | Un champ d'instance d'un type non sérialisable est déclaré dans un type sérialisable. |
| CA2237 : Marquer des types ISerializables 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 : Fournir des arguments corrects aux 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 : Tester correctement 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 analyser 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 affecter une propriété à elle-même | Une propriété a été attribuée accidentellement à elle-même. |
| CA2246 : Ne pas affecter 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 enum 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 un argument d’énumération correct à 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 : Envisagez d’utiliser String.Contains au lieu 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 : Utiliser ThrowIfCancellationRequested |
ThrowIfCancellationRequested vérifie automatiquement si le jeton a été annulé et lève un OperationCanceledException si c’est le cas. |
CA2251 : Utiliser 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 : Activer 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 d’un appel à l’autre. |
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 pourvue de 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 IDynamicInterfaceCastable pourrait ne pas implémenter une interface dynamique dans les 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 à l’exécution. Marquez les nouveaux membres static de l’interface pour éviter les erreurs d’exécution. |
CA2258 : Fournir une DynamicInterfaceCastableImplementation interface dans Visual Basic n’est pas prise en charge |
La fourniture d’une interface fonctionnelle avec l’attribut DynamicInterfaceCastableImplementationAttribute nécessite la fonctionnalité Membres d’interface par défaut, qui n’est pas prise en charge en Visual Basic. |
CA2259: Vérifiez que ThreadStatic est utilisé uniquement avec des champs statiques |
ThreadStaticAttributeaffecte static uniquement les champs (Shareddans Visual Basic). Quand il est appliqué aux champs d’instance, l’attribut n’a aucun impact sur le comportement. |
| CA2260: Implémenter correctement les 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 pourrait entraîner le retour d’un TResult invalide. |
CA2262 : Définir MaxResponseHeadersLength correctement |
Vérifiez que la valeur MaxResponseHeadersLength est bien fournie. Cette valeur est mesurée en kilo-octets. |
| CA2263 : Préférer la surcharge générique lorsque le type est connu | Utiliser une surcharge générique est préférable à passer un argument System.Type lorsque le type est connu, car cela permet un code plus clair et plus sûr avec des vérifications à la compilation améliorées. |
CA2264 : Ne pas passer une valeur non nullable à ArgumentNullException.ThrowIfNull |
ArgumentNullException.ThrowIfNull lève lorsque l’argument passé est null. Certaines constructions telles que les structs non nullables et les expressions nameof() et new sont connues pour ne jamais être null, donc ArgumentNullException.ThrowIfNull ne lèvera jamais d'exception. |
CA2265 : Ne pas comparer Span<T> à null ou à default |
Comparer une étendue à null ou default pourrait ne pas donner les résultats escomptés.
default et le null littéral sont implicitement convertis en Span<T>.Empty. |
CA2266 : Le point d’entrée du programme basé sur les fichiers doit commencer par #! |
Lorsqu’un programme basé sur un fichier se compose de plusieurs fichiers, le fichier de point d’entrée doit commencer par une ligne shebang (#!) pour la distinguer clairement des autres fichiers inclus. |
| CA2267 : Mettre les espaces blancs entre guillemets dans les valeurs de directive de programme basées sur des fichiers | La valeur d’une directive #: d’un programme basé sur un fichier contient des espaces non délimités par des guillemets. Le formulaire non cité est déconseillé ; encapsulez les valeurs qui contiennent des espaces blancs entre guillemets doubles afin qu’elles soient analysées sans ambiguïté. |
| CA2300 : Ne pas utiliser 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 d’abord BinaryFormatter.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. |
| 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: Ne pas utiliser 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 : Ne pas utiliser de 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’abord définir 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 de désérialiser | 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 : Ne pas utiliser de 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 pas avec JavaScriptSerializer à l’aide d’un 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 : Vérifiez que JavaScriptSerializer n’est pas initialisé avec SimpleTypeResolver avant de désérialiser | 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 les 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 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érifiez que l’entrée de DataTable.ReadXml() est fiable | 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 à distance. |
| CA2351 : Vérifier que l’entrée de DataSet.ReadXml() est de confiance | 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 à distance. |
| CA2352 : DataSet ou DataTable non sécurisé dans un type sérialisable peut être vulnérable aux attaques d’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 : DataSet non sécurisé ou DataTable 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 : DataSet non sécurisé ou DataTable dans le graphe d’objets désérialisé peuvent être vulnérables aux attaques d’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 : DataSet non sécurisé ou DataTable dans le 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 : DataSet non sécurisé ou DataTable dans le graphe d’objets web désérialisé | 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érifier 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 à distance. |
| CA2362 : DataSet ou DataTable non sécurisé dans un type sérialisable généré automatiquement peut être vulnérable aux attaques d’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 : Passer en revue le code pour les vulnérabilités d’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 : Passer en revue le code pour les vulnérabilités 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 : Examiner le code pour détecter les vulnérabilités d’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 de 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 des données non fiables, faites attention aux attaques par injection LDAP (Lightweight Directory Access Protocol). Un attaquant peut potentiellement exécuter des instructions LDAP malveillantes sur les annuaires d’informations. Les applications qui utilisent des entrées utilisateur pour construire dynamiquement des instructions LDAP sont particulièrement vulnérables. |
| CA3006 : Passez en revue le code pour détecter les vulnérabilités d’injection de commandes | 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 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 : Passer en revue le code pour les vulnérabilités d’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 à une personne malveillante de manipuler la requête pour retourner un résultat inattendu et éventuellement divulguer le contenu du code XML interrogé. |
| CA3009 : Passer en revue le code pour les vulnérabilités d’injection XML | Lorsque vous travaillez avec une entrée non approuvée, n’oubliez pas les attaques par injection XPath. |
| CA3010 : Passer en revue le code pour les vulnérabilités d’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 : Passer en revue le code pour les vulnérabilités d’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 : Examiner le code pour les vulnérabilités d’injection de 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 : N’ajoutez pas de schéma par URL | N’utilisez pas la surcharge dangereuse de la méthode Add, car elle peut entraîner des références externes dangereuses. |
| CA3075 : traitement DTD non sécurisé | Si vous utilisez des instances de DTDProcessing non sécurisées ou référencez des sources d’entités externes, l’analyseur peut accepter une entrée non fiable et divulguer des informations sensibles à des personnes malveillantes. |
| CA3076 : Exécution de script XSLT non sécurisée | Si vous exécutez le langage XSLT (Extensible Stylesheet Language Transformations) dans les applications .NET de manière non sécurisée, le processeur peut résoudre les références URI non fiables qui pourraient divulguer des informations sensibles à des personnes malveillantes, ce qui aboutirait à des attaques par déni de service et inter-site. |
| 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 de DTDProcessing non sécurisées lors de la référence ou la résolution de sources d’entités externes ou la définition de valeurs non sécurisées dans le code XML peut aboutir à la divulgation d’informations. |
| CA3147 : Marquer les gestionnaires de verbes HTTP 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 cryptographiques 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 d’algorithmes cryptographiques défaillants | 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 : N’utilisez pas 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 des certificats | 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 désactivez pas 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 des requêtes | 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 : N’utilisez pas de protocoles de sécurité obsolètes | 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 pas désactiver la vérification d’en-tête 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 : Utiliser XmlReader pour lire le XML de DataSet | L’utilisation d’un DataSet pour lire du code XML avec des données non approuvées peut 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 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éfinir ViewStateUserKey pour les classes dérivées de la 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 désérialiser | Le traitement de schémas DTD et XML non approuvés peut permettre le chargement de 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 inclus DTD et XML désactivé. |
| CA5370 : Utiliser XmlReader pour valider le lecteur | Le traitement de schémas DTD et XML non approuvés peut permettre le chargement de 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 du schéma | Le traitement de schémas DTD et XML non approuvés peut permettre le chargement de 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 fiables peut entraîner le chargement de références externes dangereuses. Vous pouvez limiter ce risque en utilisant un XmlReader avec un programme de résolution sécurisé ou avec une désactivation du traitement DTD. |
| CA5373 : Ne pas utiliser de 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 : Ne pas utiliser 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 : Ne pas utiliser de signature d’accès partagé de 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 : Utiliser SharedAccessProtocol HttpsOnly | La SAP est une données sensible qui ne peut pas être transportée en texte brut sur HTTP. |
| CA5377 : Utiliser la 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 d’algorithme faible de dérivation de clé | 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 : N’ajoutez pas 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 : Vérifiez 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 : Utiliser 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 : Veillez à utiliser 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). |
| CA5384 : N’utilisez pas d’algorithme de signature numérique (DSA) | DSA est un algorithme de chiffrement asymétrique faible. |
| CA5385 : Utiliser l’algorithme Rivest-Shamir-Adleman (RSA) 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 de coder en dur la valeur 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éprécié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 : Ne pas utiliser de fonction de dérivation de clé faible avec un nombre d’itérations insuffisant | 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 : Assurez-vous d’utiliser un nombre d’itérations suffisant lors de l’utilisation d’une fonction faible de dérivation de clé | Cette règle vérifie si une clé de chiffrement a été générée par Rfc2898DeriveBytes avec 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 : N’ajoutez pas le chemin d’accès de l’élément d’archivage 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 pas coder 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 : Utiliser des jetons antiforgery dans les contrôleurs MVC ASP.NET Core | La gestion d’une requête POST, PUT, PATCH ou DELETE sans validation d’un jeton antifalsification peut être vulnérable aux attaques de falsification de requête inter-site. 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 : Utiliser l’attribut DefaultDllImportSearchPaths pour 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ûre | 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 : Ne pas utiliser de génération aléatoire non sécurisée | L’utilisation d’un générateur de nombres pseudo-aléatoires faible sur le plan du chiffrement peut permettre à un attaquant de prédire quelle valeur sensible à la sécurité 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 : Définir HttpOnly sur true 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: N’utilisez pas de valeurs SslProtocols obsolètes | 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épréciés. Pour garantir la sécurité de votre application, évitez de coder en dur une version de protocole. |
| CA5399 : Désactiver 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 : Vérifier que la vérification de la liste de révocation de certificats HttpClient n’est pas désactivé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 IV non 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 : Utiliser CreateEncryptor avec l’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 |
TokenValidationParameters les propriétés qui contrôlent la validation des jetons ne doivent pas être définies sur false. |
| CA5405 : Ne pas toujours ignorer 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 : Éviter 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 : RequiresAssemblyFilesAttribute les annotations doivent correspondre dans toutes les implémentations ou substitutions d’interface. |
RequiresAssemblyFilesAttribute Les annotations doivent correspondre à toutes les implémentations ou remplacements de l’interface. |
IL3005 : RequiresAssemblyFilesAttribute ne peut pas être placé directement sur le point d’entrée de l’application. |
RequiresAssemblyFilesAttribute ne peut pas être placé directement sur le point d’entrée de l’application. |
Legend
Le tableau suivant indique le type d’informations fourni pour chaque règle dans la documentation de référence.
| Item | Description |
|---|---|
| Type | TypeName de la règle. |
| ID de 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 a un effet disruptif ou non disruptif | Indique si la correction d’une violation de la règle constitue une modification avec rupture. Une modification majeure signifie qu’un assemblage ayant une dépendance à la cible qui a provoqué la violation ne pourra pas être recompilé avec la nouvelle version corrigée ou pourrait échouer lors 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 connexes. |