Partager via

Règles d’utilisation

  • Article

Les règles d’utilisation prennent en charge l’utilisation appropriée de .NET.

Contenu de cette section

Règle Description
CA1801 : Passez en revue les paramètres inutilisés Une signature de méthode inclut un paramètre qui n'est pas utilisé dans le corps de la méthode.
CA1816 : Appeler GC.SuppressFinalize correctement Une méthode qui est une implémentation de Dispose n’appelle pas GC.SuppressFinalize ; ou une méthode qui n’est pas une implémentation d’appels DisposeGC.SuppressFinalize ; ou une méthode appelle GC.SuppressFinalize et passe quelque chose d’autre que this (Me en Visual Basic).
CA2200 : Levez à nouveau une exception pour conserver les détails de la pile Une exception est à nouveau levée et est spécifiée explicitement dans l'instruction throw. Si une exception est à nouveau levée par sa spécification dans l'instruction throw, la liste des appels de méthode présents entre la méthode d'origine qui a levé l'exception et la méthode actuelle est perdue.
CA2201 : Ne levez pas des types d'exceptions réservés Cela rend l’erreur d’origine dure à détecter et à déboguer.
CA2207 : Initialisez les champs statiques des types valeur en ligne Un type valeur déclare un constructeur statique explicite. Pour corriger une violation de cette règle, initialisez toutes les données statiques lorsqu’elles sont déclarées et supprimez le constructeur statique.
CA2208 : Instanciez les exceptions d'argument comme il se doit Un appel est passé au constructeur par défaut (sans paramètre) d'un type d'exception qui est ou dérive d'ArgumentException, ou un argument string incorrect est passé à un constructeur paramétrable d'un type d'exception qui est ou dérive d'ArgumentException.
CA2211 : Les champs non constants ne doivent pas être visibles Les champs statiques qui ne sont ni constants ni en lecture seule ne sont pas thread-safe. L’accès à un tel champ doit être scrupuleusement contrôlé et requiert des techniques de programmation évoluées pour synchroniser l’accès à l’objet de classe.
CA2213 : Les champs pouvant être supprimés doivent l’être Un type qui implémente System.IDisposable déclare des champs de types qui implémentent également IDisposable. La méthode Dispose du champ n’est pas appelée par la méthode Dispose du type déclarant.
CA2214 : N'appelez pas de méthodes substituables dans les constructeurs Lorsqu’un constructeur appelle une méthode virtuelle, il est possible que le constructeur de l’instance qui appelle la méthode n’ait pas été exécuté.
CA2215 : Les méthodes Dispose doivent appeler la méthode Dispose de la classe de base Si un type hérite d’un type supprimable, il doit appeler la méthode Dispose du type de base issu de sa propre méthode Dispose.
CA2216 : Les types pouvant être supprimés doivent déclarer un finaliseur Un type qui implémente System.IDisposable et présente des champs qui suggèrent l’utilisation de ressources non managées, n’implémente pas de finaliseur conforme à la description de Object.Finalize.
CA2217 : Ne marquez pas les enums avec l'attribut FlagsAttribute Une énumération extérieurement visible est marquée par FlagsAttribute et possède une ou plusieurs valeurs qui ne sont pas des puissances de deux ou une combinaison des autres valeurs définies dans l’énumération.
CA2218 : Remplacez GetHashCode au moment de remplacer Equals Un type public se substitue à System.Object.Equals, mais pas à System.Object.GetHashCode.
CA2219 : Ne pas lever d'exceptions dans les clauses d'exception Lorsqu'une exception est levée dans une clause finally ou fault, la nouvelle exception masque l'exception active. Lorsqu’une exception est levée dans une clause filter, le runtime l’intercepte en silence. Cela rend l’erreur d’origine dure à détecter et à déboguer.
CA2224 : Remplacez Equals au moment de surcharger l'opérateur égal Un type public implémente l’opérateur d’égalité, mais ne se substitue pas à System.Object.Equals.
CA2225 : Les surcharges d'opérateur offrent d'autres méthodes nommées Une surcharge d'opérateur a été détectée, et la méthode de substitution nommée attendue n'a pas été trouvée. Le membre de substitution nommé donne accès aux mêmes fonctionnalités que l’opérateur. Il est fourni aux développeurs qui programment dans les langages qui ne prennent pas en charge les opérateurs surchargés.
CA2226 : Les opérateurs doivent contenir des surcharges symétriques Un type implémente l’opérateur d’égalité ou d’inégalité et n’implémente pas l’opérateur opposé.
CA2227 : Les propriétés de collection doivent être en lecture seule Une propriété de collection accessible en écriture permet à un utilisateur de remplacer la collection par une collection différente. Une propriété en lecture seule empêche le remplacement de la collection, mais permet quand même aux membres individuels d’être définis.
CA2229 : Implémentez des constructeurs de sérialisation Pour corriger une violation de cette règle, implémentez le constructeur de sérialisation. Dans le cas d'une classe sealed, rendez le constructeur privé ; sinon, attribuez-lui l'état protégé.
CA2231 : Surchargez l’opérateur égal (equals) en remplaçant ValueType.Equals Un type valeur se substitue à Object.Equals mais n’implémente pas l’opérateur d’égalité.
CA2234 : Passez des objets System.Uri à la place de chaînes Un appel est passé à une méthode qui a un paramètre de chaîne dont le nom contient « uri », « URI », « urn », « URN », « url » ou « URL ». Le type déclarant de la méthode contient une surcharge de méthode correspondante qui a un paramètre System.Uri.
CA2235 : Marquez tous les champs non sérialisés Un champ d'instance d'un type non sérialisable est déclaré dans un type sérialisable.
CA2237 : Marquer les types ISerializable avec SerializableAttribute Pour être reconnus par le Common Language Runtime comme sérialisables, les types doivent être marqués avec l’attribut SerializableAttribute même s’ils utilisent une routine de sérialisation personnalisée par le biais de l’implémentation de l’interface ISerializable.
CA2241 : Indiquer le nombre correct d'arguments dans les méthodes de mise en forme L’argument de format passé à String.Format ne contient aucun élément de mise en forme pour chaque argument objet correspondant, ou vice versa.
CA2242 : Effectuez correctement des tests NaN Cette expression teste une valeur par rapport à Single.Nan ou à Double.Nan. Utilisez Double.IsNan(Double) ou Single.IsNan(Single) pour tester la valeur.
CA2243 : Les littéraux de chaîne d'attribut doivent être analysés correctement Le paramètre de littéral de chaîne d’un attribut n’effectue pas une analyse correcte pour une URL, un GUID ou une version.
CA2244 : Ne pas dupliquer les initialisations d’éléments indexés Un initialiseur d’objet a plusieurs initialiseurs d’éléments indexés avec le même index constant. Tous les initialiseurs, à l’exception du dernier sont redondants.
CA2245 : Ne pas attribuer une propriété à elle-même Une propriété a été attribuée accidentellement à elle-même.
CA2246 : Ne pas attribuer un symbole et son membre dans la même instruction L’affectation d’un symbole et de son membre, soit un champ ou une propriété, dans la même instruction n’est pas recommandée. Il est difficile de déterminer si l’accès du membre était destiné à utiliser l’ancienne valeur du symbole avant l’assignation ou la nouvelle valeur de l’assignation dans cette instruction.
CA2247 : L’argument passé au constructeur TaskCompletionSource doit être l’enum TaskCreationOptions au lieu de l’enum 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 TaskContinuationOptions au lieu d’une TaskCreationOptions, l’appel traite les options comme un état.
CA2248 : fournissez l’argument « enum » 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 : Utiliser de préférence String.Contains à la place de String.IndexOf Les appels à string.IndexOf où le résultat est utilisé pour vérifier la présence ou l’absence d’une sous-chaîne peuvent être remplacés par string.Contains.
CA2250 : utilisez ThrowIfCancellationRequested ThrowIfCancellationRequested vérifie automatiquement si le jeton a été annulé et lève une OperationCanceledException si c’est le cas.
CA2251 : utilisez String.Equals plutôt que String.Compare Il est plus clair et probablement plus rapide d’utiliser String.Equals au lieu de comparer le résultat de String.Compare à zéro.
CA2252 : accepter les fonctionnalités en préversion Acceptez les fonctionnalités en préversion avant d’utiliser des API en préversion.
CA2253 : les espaces réservés nommés ne doivent pas être des valeurs numériques Les espaces réservés nommés dans le modèle de message de journalisation ne doivent pas être composés uniquement de caractères numériques.
CA2254 : le modèle doit être une expression statique Le modèle de message de journalisation ne doit pas varier entre les appels.
CA2255 : l’attribut ModuleInitializer ne doit pas être utilisé dans les bibliothèques Les initialiseurs de module sont destinés à être utilisés par le code d’application pour s’assurer que les composants d’une application sont initialisés avant le début de l’exécution du code de l’application.
CA2256 : tous les membres déclarés dans les interfaces parentes doivent avoir une implémentation dans une interface possédant l’attribut DynamicInterfaceCastableImplementation Les types attribués par DynamicInterfaceCastableImplementationAttribute agissent comme une implémentation d’interface pour un type qui implémente le type IDynamicInterfaceCastable. Par conséquent, ils doivent fournir une implémentation de tous les membres définis dans les interfaces héritées, car le type qui implémente IDynamicInterfaceCastable ne les fournira pas autrement.
CA2257 : les membres définis sur une interface avec « DynamicInterfaceCastableImplementationAttribute » doivent être « static » Étant donné qu’un type qui implémente IDynamicInterfaceCastable ne peut 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 au moment de l’exécution. Marquez les nouveaux membres de l’interface static pour éviter les erreurs d’exécution.
CA2258 : la fourniture d’une interface « DynamicInterfaceCastableImplementation » en Visual Basic n’est pas prise en charge La fourniture d’une interface fonctionnelle possédant l’attribut DynamicInterfaceCastableImplementationAttribute nécessite la fonctionnalité Membres de l’interface par défaut, qui n’est pas prise en charge dans Visual Basic.
CA2259 : Vérifiez que ThreadStatic est utilisé uniquement avec des champs statiques ThreadStaticAttribute affecte static uniquement les champs (Shared en Visual Basic). Quand il est appliqué aux champs d’instance, l’attribut n’a aucun impact sur le comportement.
CA2260 : Implémenter correctement des interfaces mathématiques génériques Les interfaces mathématiques génériques nécessitent que le type dérivé lui-même soit utilisé pour le paramètre de type auto-récurrent.
CA2261 : Ne pas utiliser ConfigureAwaitOptions.SuppressThrowing avec Task<TResult> L’option ConfigureAwaitOptions.SuppressThrowing n’est pas prise en charge par le Task<TResult> générique, car cela peut entraîner le renvoi d’un TResult non valide.
CA2262 : définir MaxResponseHeadersLength correctement Vérifiez que la valeur MaxResponseHeadersLength est fournie correctement. Cette valeur est mesurée en kilo-octets.
CA2264 : Ne passez pas de valeur non nullable à « ArgumentNullException.ThrowIfNull ». 'ArgumentNullException.ThrowIfNull' lève lorsque l’argument passé est 'null'. Certaines constructions telles que les structs non nullables, et « nameof() » et « new » sont connues pour ne jamais être null. Par conséquent, « ArgumentNullException.ThrowIfNull » ne lève jamais.
CA2265 : Ne pas comparer Span<T> ou nulldefault Comparaison d’une étendue ou null default peut ne pas faire ce que vous avez prévu. default et le null littéral sont implicitement convertis en Span<T>.Empty.
CA2263 : préférer la surcharge générique lorsque le type est connu L’utilisation d’une surcharge générique est préférable à la transmission d’un System.Type argument lorsque le type est connu, car ils favorisent un code plus propre et plus sécurisé avec des vérifications améliorées au moment de la compilation.