Avertissements d’analyse du code pour le code managé par CheckIdCode analysis warnings for managed code by CheckId

Le tableau suivant répertorie les avertissements d'analyse du code pour le code managé par l'identificateur CheckId de l'avertissement.The following table lists Code Analysis warnings for managed code by the CheckId identifier of the warning.

AvertissementsWarnings

CheckIdCheckId WarningWarning DescriptionDescription
CA1000CA1000 CA1000 : Ne déclarez pas de membres statiques sur les types génériquesCA1000: Do not declare static members on generic types Lorsqu’un membre statique d’un type générique est appelé, l’argument de type doit être spécifié pour le type.When a static member of a generic type is called, the type argument must be specified for the 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.When a generic instance member that does not support inference is called, the type argument must be specified for the member. Dans ces deux cas, la syntaxe permettant de spécifier l’argument de type est différente et peut être facilement confondue.In these two cases, the syntax for specifying the type argument is different and easily confused.
CA1001CA1001 CA1001 : Les types qui ont des champs supprimables doivent être supprimablesCA1001: Types that own disposable fields should be disposable Une classe déclare et implémente un champ d'instance qui est un type System.IDisposable, et elle n'implémente pas IDisposable.A class declares and implements an instance field that is a System.IDisposable type, and the class does not implement IDisposable. Une classe qui déclare un champ IDisposable possède indirectement une ressource non managée et doit implémenter l'interface IDisposable.A class that declares an IDisposable field indirectly owns an unmanaged resource and should implement the IDisposable interface.
CA1002CA1002 CA1002 : N’exposez pas de listes génériquesCA1002: Do not expose generic lists System.Collections.Generic.List < (de <(T >) >) est une collection générique conçue pour les performances, et non l’héritage.System.Collections.Generic.List<(Of <(T>)>) is a generic collection that is designed for performance, not inheritance. Par conséquent, la liste ne contient aucun membre virtuel.Therefore, List does not contain any virtual members. Les collections génériques qui sont conçues pour l'héritage doivent être exposées à la place.The generic collections that are designed for inheritance should be exposed instead.
CA1003CA1003 CA1003 : Utiliser les instances du gestionnaire d’événements génériquesCA1003: Use generic event handler instances 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.A type contains a delegate that returns void, whose signature contains two parameters (the first an object and the second a type that is assignable to EventArgs), and the containing assembly targets Microsoft .NET Framework 2.0.
CA1004CA1004 CA1004 : Les méthodes génériques doivent fournir un paramètre de typeCA1004: Generic methods should provide type parameter L’inférence désigne la manière dont l’argument de type d’une méthode générique est déterminé par le type d’argument passé à la méthode, au lieu d’utiliser la spécification explicite de l’argument de type.Inference is how the type argument of a generic method is determined by the type of argument that is passed to the method, instead of by the explicit specification of the type argument. Pour activer l’inférence, la signature de paramètre d’une méthode générique doit contenir un paramètre du même type que le paramètre de type de la méthode.To enable inference, the parameter signature of a generic method must include a parameter that is of the same type as the type parameter for the method. Dans ce cas, il n’est pas nécessaire de spécifier l’argument de type.In this case, the type argument does not have to be specified. Lors de l'utilisation de l'inférence pour tous les paramètres de type, la syntaxe d'appel aux méthodes d'instance génériques et non génériques est identique. Cela simplifie l'utilisation des méthodes génériques.When using inference for all type parameters, the syntax for calling generic and non-generic instance methods is identical; this simplifies the usability of generic methods.
CA1005CA1005 CA1005 : Évitez trop de paramètres sur les types génériquesCA1005: Avoid excessive parameters on generic types 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.The more type parameters a generic type contains, the more difficult it is to know and remember what each type parameter represents. Il est généralement évident avec un paramètre de type, comme dans List<T > et dans certains cas, deux possèdent de type, comme dans Dictionary<TKey, TValue >.It is usually obvious with one type parameter, as in List<T>, and in certain cases that have two type parameters, as in Dictionary<TKey, TValue>. Cependant, s’il existe plus de deux paramètres de type, la difficulté devient trop grande pour la plupart des utilisateurs.However, if more than two type parameters exist, the difficulty becomes too great for most users.
CA1006CA1006 CA1006 : Ne pas imbriquer les types génériques dans les signatures de membreCA1006: Do not nest generic types in member signatures Un argument de type imbriqué est un argument de type qui est également un type générique.A nested type argument is a type argument that is also a generic type. Pour appeler un membre dont la signature contient un argument de type imbriqué, l’utilisateur doit instancier un type générique et passer ce type au constructeur d’un deuxième type générique.To call a member whose signature contains a nested type argument, the user must instantiate one generic type and pass this type to the constructor of a second generic type. La procédure et la syntaxe requises sont complexes et doivent être évitées.The required procedure and syntax are complex and should be avoided.
CA1007CA1007 CA1007 : Utiliser des méthodes génériques lorsque cela est appropriéCA1007: Use generics where appropriate Une méthode visible de l'extérieur contient un paramètre de référence de type System.Object.An externally visible method contains a reference parameter of type System.Object. L'utilisation d'une méthode générique autorise le passage de tous les types, soumis à des contraintes, dans la méthode sans cast préalable du type vers le type de paramètre de référence.Use of a generic method enables all types, subject to constraints, to be passed to the method without first casting the type to the reference parameter type.
CA1008CA1008 CA1008 : Les énumérations doivent avoir la valeur zéroCA1008: Enums should have zero value La valeur par défaut d'une énumération non initialisée, comme d'autres types valeur, est zéro.The default value of an uninitialized enumeration, just as other value types, is zero. 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.A nonflags-attributed enumeration should define a member by using the value of zero so that the default value is a valid value of the enumeration. 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.If an enumeration that has the FlagsAttribute attribute applied defines a zero-valued member, its name should be "None" to indicate that no values have been set in the enumeration.
CA1009CA1009 CA1009 : Déclarez les gestionnaires d’événements correctementCA1009: Declare event handlers correctly Les méthodes du gestionnaire d'événements acceptent deux paramètres.Event handler methods take two parameters. Le premier est de type System.Object et se nomme "sender".The first is of type System.Object and is named "sender". Il s'agit de l'objet qui déclenche l'événement.This is the object that raised the event. Le deuxième paramètre est de type System.EventArgs et se nomme "e".The second parameter is of type System.EventArgs and is named "e". Il s'agit des données qui sont associées à l'événement.This is the data that is associated with the event. Les méthodes du gestionnaire d'événements ne doivent pas retourner de valeur ; dans le langage de programmation C#, ceci est indiqué par le type de retour void.Event handler methods should not return a value; in the C# programming language, this is indicated by the return type void.
CA1010CA1010 CA1010 : Les collections doivent implémenter une interface génériqueCA1010: Collections should implement generic interface Pour étendre la facilité d’utilisation d’une collection, implémentez l’une des interfaces de collection génériques.To broaden the usability of a collection, implement one of the generic collection interfaces. La collection peut être ensuite utilisée pour remplir des types de collection génériques.Then the collection can be used to populate generic collection types.
CA1011CA1011 CA1011 : Envisagez de passer les types de base comme paramètresCA1011: Consider passing base types as parameters Lorsqu’un type de base est spécifié en tant que paramètre dans une déclaration de méthode, tout type dérivé du type de base peut être passé en tant qu’argument correspondant à la méthode.When a base type is specified as a parameter in a method declaration, any type that is derived from the base type can be passed as the corresponding argument to the method. Si les fonctionnalités supplémentaires fournies par le type de paramètre dérivé ne sont pas requises, l'utilisation du type de base permet une exploitation plus large de la méthode.If the additional functionality that is provided by the derived parameter type is not required, use of the base type enables wider use of the method.
CA1012CA1012 CA1012 : Les types abstraits ne doivent pas avoir de constructeursCA1012: Abstract types should not have constructors Les constructeurs des types abstraits peuvent être appelés uniquement par des types dérivés.Constructors on abstract types can be called only by derived types. É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.Because public constructors create instances of a type, and you cannot create instances of an abstract type, an abstract type that has a public constructor is incorrectly designed.
CA1013CA1013 CA1013 : Surchargez l’opérateur égal lors de la surcharge de l’opérateur d’addition et de soustractionCA1013: Overload operator equals on overloading add and subtract Un type public ou protégé implémente les opérateurs d'addition ou de soustraction sans implémenter l'opérateur d'égalité.A public or protected type implements the addition or subtraction operators without implementing the equality operator.
CA1014CA1014 CA1014 : Marquez les assemblys avec CLSCompliantAttributeCA1014: Mark assemblies with 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.The Common Language Specification (CLS) defines naming restrictions, data types, and rules to which assemblies must conform if they will be used across programming languages. Un design correct stipule que tous les assemblys indiquent explicitement la conformité CLS avec CLSCompliantAttribute.Good design dictates that all assemblies explicitly indicate CLS compliance by using CLSCompliantAttribute . Si cet attribut n'est pas présent sur un assembly, l'assembly n'est pas conforme.If this attribute is not present on an assembly, the assembly is not compliant.
CA1016CA1016 CA1016 : Marquez les assemblys avec AssemblyVersionAttributeCA1016: Mark assemblies with AssemblyVersionAttribute Le .NET Framework.NET Framework 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.The .NET Framework.NET Framework uses the version number to uniquely identify an assembly, and to bind to types in strongly named assemblies. Le numéro de version est utilisé conjointement avec la version et la stratégie d'éditeur.The version number is used together with version and publisher policy. Par défaut, les applications s'exécutent uniquement avec la version d'assembly avec laquelle elles ont été construites.By default, applications run only with the assembly version with which they were built.
CA1017CA1017 CA1017 : Marquez les assemblys avec ComVisibleAttributeCA1017: Mark assemblies with ComVisibleAttribute ComVisibleAttribute détermine comment les clients COM accèdent à du code managé.ComVisibleAttribute determines how COM clients access managed code. Un bon design stipule que les assemblys indiquent explicitement la visibilité COM.Good design dictates that assemblies explicitly indicate COM visibility. 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.COM visibility can be set for the whole assembly and then overridden for individual types and type members. Si cet attribut n'est pas présent, les clients COM peuvent voir le contenu de l'assembly.If this attribute is not present, the contents of the assembly are visible to COM clients.
CA1018CA1018 CA1018 : Marquez les attributs avec AttributeUsageAttributeCA1018: Mark attributes with 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.When you define a custom attribute, mark it by using AttributeUsageAttribute to indicate where in the source code the custom attribute can be applied. La signification et l'utilisation prévue d'un attribut déterminent ses emplacements valides au sein d'un code.The meaning and intended usage of an attribute will determine its valid locations in code.
CA1019CA1019 CA1019 : Définissez des accesseurs pour les arguments d’attributCA1019: Define accessors for attribute arguments Les attributs peuvent définir des arguments obligatoires qui doivent être spécifiés lorsque vous appliquez l’attribut à une cible.Attributes can define mandatory arguments that must be specified when you apply the attribute to a target. Ceux-ci sont également appelés arguments positionnels parce qu’ils sont fournis aux constructeurs d’attributs en tant que paramètres positionnels.These are also known as positional arguments because they are supplied to attribute constructors as positional parameters. 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.For every mandatory argument, the attribute should also provide a corresponding read-only property so that the value of the argument can be retrieved at execution time. Les attributs peuvent également définir des arguments facultatifs, qui sont également appelés arguments nommés.Attributes can also define optional arguments, which are also known as named arguments. Ces arguments sont fournis aux constructeurs d’attributs par noms et doivent disposer d’une propriété en lecture/écriture correspondante.These arguments are supplied to attribute constructors by name and should have a corresponding read/write property.
CA1020CA1020 CA1020 : Éviter les espaces de noms comportant peu de typesCA1020: Avoid namespaces with few types Assurez-vous que chacun de vos espaces de noms bénéficie d'une organisation logique, et qu'une raison valide justifie le placement des types dans un espace de noms peu rempli.Make sure that each of your namespaces has a logical organization, and that a valid reason exists for putting types in a sparsely populated namespace.
CA1021CA1021 CA1021 : Évitez les paramètres outCA1021: Avoid out parameters 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.Passing types by reference (using out or ref) requires experience with pointers, understanding how value types and reference types differ, and handling methods with multiple return values. Par ailleurs, la différence entre les paramètres out et ref est généralement peu comprise.Also, the difference between out and ref parameters is not widely understood.
CA1023CA1023 CA1023 : Les indexeurs ne doivent pas être multidimensionnelsCA1023: Indexers should not be multidimensional Les indexeurs, c'est-à-dire les propriétés indexées, doivent utiliser un index unique.Indexers (that is, indexed properties) should use a single index. Les indexeurs multidimensionnels peuvent considérablement diminuer la facilité d'utilisation de la bibliothèque.Multidimensional indexers can significantly reduce the usability of the library.
CA1024CA1024 CA1024 : Utilisez des propriétés quand c’est appropriéCA1024: Use properties where appropriate 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.A public or protected method has a name that starts with "Get", takes no parameters, and returns a value that is not an array. La méthode est susceptible de devenir une propriété.The method might be a good candidate to become a property.
CA1025CA1025 CA1025 : Remplacez les arguments répétitifs par un tableau paramsCA1025: Replace repetitive arguments with params array Utilisez un tableau de paramètres au lieu d’arguments répétés lorsque le nombre exact d’arguments est inconnu et lorsque les arguments variables sont de même type ou peuvent être passés comme étant de même type.Use a parameter array instead of repeated arguments when the exact number of arguments is unknown and when the variable arguments are the same type or can be passed as the same type.
CA1026CA1026 CA1026 : N’utilisez pas de paramètres par défautCA1026: Default parameters should not be used Les méthodes qui utilisent des paramètres par défaut sont autorisées dans le cadre de la spécification de langage commun CLS (Common Language Specification) ; toutefois, cette spécification permet aux compilateurs d'ignorer les valeurs assignées à ces paramètres.Methods that use default parameters are allowed under the CLS; however, the CLS lets compilers ignore the values that are assigned to these parameters. Pour préserver le comportement souhaité d'un langage de programmation à l'autre, les méthodes qui utilisent des paramètres par défaut doivent être remplacées par des surcharges de méthode qui fournissent les paramètres par défaut.To maintain the behavior that you want across programming languages, methods that use default parameters should be replaced by method overloads that provide the default parameters.
CA1027CA1027 CA1027 : Marquez les énumérations avec FlagsAttributeCA1027: Mark enums with FlagsAttribute Une énumération est un type valeur qui définit un jeu de constantes nommées associées.An enumeration is a value type that defines a set of related named constants. Appliquez FlagsAttribute à une énumération lorsque ses constantes nommées peuvent être combinées de manière pertinente.Apply FlagsAttribute to an enumeration when its named constants can be meaningfully combined.
CA1028CA1028 CA1028 : Le stockage de l’énumération doit être Int32CA1028: Enum storage should be Int32 Une énumération est un type valeur qui définit un jeu de constantes nommées associées.An enumeration is a value type that defines a set of related named constants. Par défaut, le type de données System.Int32 est utilisé pour stocker la valeur de constante.By default, the System.Int32 data type is used to store the constant value. Bien que vous puissiez modifier ce type sous-jacent, ce n'est ni obligatoire, ni recommandé dans la plupart des scénarios.Although you can change this underlying type, it is not required or recommended for most scenarios.
CA1030CA1030 CA1030 : Utiliser des événements lorsque cela est appropriéCA1030: Use events where appropriate Cette règle détecte des méthodes qui présentent des noms qui ordinairement seraient utilisés pour des événements.This rule detects methods that have names that ordinarily would be used for events. 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.If a method is called in response to a clearly defined state change, the method should be invoked by an event handler. Les objets qui appellent la méthode doivent déclencher des événements au lieu d'appeler directement la méthode.Objects that call the method should raise events instead of calling the method directly.
CA1031CA1031 CA1031 : Ne pas intercepter des types d’exception généraleCA1031: Do not catch general exception types Les exceptions générales ne doivent pas être interceptées.General exceptions should not be caught. Interceptez une exception plus spécifique ou levez à nouveau l'exception générale en tant que dernière instruction dans le bloc catch.Catch a more specific exception, or rethrow the general exception as the last statement in the catch block.
CA1032CA1032 CA1032 : Implémentez des constructeurs d’exception standardCA1032: Implement standard exception constructors Ne pas fournir le jeu complet de constructeurs peut rendre difficile une gestion des exceptions correcte.Failure to provide the full set of constructors can make it difficult to correctly handle exceptions.
CA1033CA1033 CA1033 : Les méthodes d’interface doivent pouvoir être appelées par les types enfantsCA1033: Interface methods should be callable by child types 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.An unsealed externally visible type provides an explicit method implementation of a public interface and does not provide an alternative externally visible method that has the same name.
CA1034CA1034 CA1034 : Les types imbriqués ne doivent pas être visiblesCA1034: Nested types should not be visible Un type imbriqué représente un type déclaré dans la portée d'un autre type.A nested type is a type that is declared in the scope of another type. Les types imbriqués sont utiles pour encapsuler les détails de l'implémentation privée du type conteneur.Nested types are useful to encapsulate private implementation details of the containing type. Utilisés à cette fin, les types imbriqués ne doivent pas être visibles de l'extérieur.Used for this purpose, nested types should not be externally visible.
CA1035CA1035 CA1035 : Les implémentations ICollection ont des membres fortement typésCA1035: ICollection implementations have strongly typed members Cette règle requiert que les implémentations ICollection fournissent des membres fortement typés afin que les utilisateurs ne soient pas tenus d’effectuer un cast d’arguments en type Object lorsqu’ils utilisent les fonctionnalités fournies par l’interface.This rule requires ICollection implementations to provide strongly typed members so that users are not required to cast arguments to the Object type when they use the functionality that is provided by the interface. Cette règle suppose que le type qui implémente ICollection procède ainsi pour gérer une collection d'instances d'un type plus fort qu'Object.This rule assumes that the type that implements ICollection does so to manage a collection of instances of a type that is stronger than Object.
CA1036CA1036 CA1036 : Remplacez les méthodes sur les types comparablesCA1036: Override methods on comparable types Un type public ou protégé implémente l'interface System.IComparable.A public or protected type implements the System.IComparable interface. Il ne substitue pas Object.Equals, ni ne surcharge l'opérateur égal à, différent de, inférieur à ou supérieur à propre au langage.It does not override Object.Equals nor does it overload the language-specific operator for equality, inequality, less than, or greater than.
CA1038CA1038 CA1038 : Les énumérateurs doivent être fortement typésCA1038: Enumerators should be strongly typed Cette règle requiert que les implémentations IEnumerator fournissent également une version fortement typée de la propriété Current afin que les utilisateurs ne soient pas tenus d'effectuer un cast de la valeur de retour en type fort lorsqu'ils utilisent les fonctionnalités fournies par l'interface.This rule requires IEnumerator implementations to also provide a strongly typed version of the Current property so that users are not required to cast the return value to the strong type when they use the functionality that is provided by the interface.
CA1039CA1039 CA1039 : Les listes sont fortement typéesCA1039: Lists are strongly typed Cette règle requiert que les implémentations IList fournissent des membres fortement typés afin que les utilisateurs ne soient pas tenus d’effectuer un cast d’arguments en type System.Object lorsqu’ils utilisent les fonctionnalités fournies par l’interface.This rule requires IList implementations to provide strongly typed members so that users are not required to cast arguments to the System.Object type when they use the functionality that is provided by the interface.
CA1040CA1040 CA1040 : Évitez les interfaces videsCA1040: Avoid empty interfaces Les interfaces définissent des membres qui fournissent un comportement ou un contrat d'utilisation.Interfaces define members that provide a behavior or usage contract. 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.The functionality that is described by the interface can be adopted by any type, regardless of where the type appears in the inheritance hierarchy. Un type implémente une interface en fournissant des implémentations pour les membres de celle-ci.A type implements an interface by providing implementations for the members of the interface. Une interface vide ne définit aucun membre ; par conséquent, elle ne définit aucun contrat pouvant être implémenté.An empty interface does not define any members; therefore, it does not define a contract that can be implemented.
CA1041CA1041 CA1041 : Fournir un message ObsoleteAttributeCA1041: Provide ObsoleteAttribute message Un type ou un membre est marqué avec un attribut System.ObsoleteAttribute dont la propriété ObsoleteAttribute.Message n'est pas spécifiée.A type or member is marked by using a System.ObsoleteAttribute attribute that does not have its ObsoleteAttribute.Message property specified. Lorsqu'un type ou membre marqué avec ObsoleteAttribute est compilé, la propriété Message de l'attribut est affichée.When a type or member that is marked by using ObsoleteAttribute is compiled, the Message property of the attribute is displayed. Cela fournit à l'utilisateur des informations sur le type ou le membre obsolète.This gives the user information about the obsolete type or member.
CA1043CA1043 CA1043 : Utiliser un argument entier ou chaîne pour les indexeursCA1043: Use integral or string argument for indexers Les indexeurs (c'est-à-dire les propriétés indexées) doivent utiliser des types intégral ou chaîne pour l'index.Indexers (that is, indexed properties) should use integral or string types for the 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.These types are typically used for indexing data structures and they increase the usability of the library. 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.Use of the Object type should be restricted to those cases where the specific integral or string type cannot be specified at design time.
CA1044CA1044 CA1044 : Les propriétés ne doivent pas être en écriture seuleCA1044: Properties should not be write only 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.Although it is acceptable and often necessary to have a read-only property, the design guidelines prohibit the use of write-only properties. 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é.This is because letting a user set a value, and then preventing the user from viewing that value, does not provide any security. De plus, sans accès en lecture, l'état des objets partagés ne peut s'afficher, ce qui limite leur utilité.Also, without read access, the state of shared objects cannot be viewed, which limits their usefulness.
CA1045CA1045 CA1045 : Ne pas passer de types par référenceCA1045: Do not pass types by reference 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.Passing types by reference (using out or ref) requires experience with pointers, understanding how value types and reference types differ, and handling methods that have multiple return values. 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.Library architects who design for a general audience should not expect users to master working with out or ref parameters.
CA1046CA1046 CA1046 : Ne pas surcharger l’opérateur égal sur les types de référenceCA1046: Do not overload operator equals on reference types Pour les types référence, l’implémentation par défaut de l’opérateur d’égalité est presque toujours correcte.For reference types, the default implementation of the equality operator is almost always correct. Par défaut, deux références sont égales uniquement si elles pointent sur le même objet.By default, two references are equal only if they point to the same object.
CA1047CA1047 CA1047 : Ne déclarez pas des membres protégés dans les types sealedCA1047: Do not declare protected members in sealed types Les types déclarent des membres protégés afin que des types qui héritent puissent accéder au membre ou le substituer.Types declare protected members so that inheriting types can access or override the member. 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.By definition, sealed types cannot be inherited, which means that protected methods on sealed types cannot be called.
CA1048CA1048 CA1048 : Ne déclarez pas de membres virtuels dans les types sealedCA1048: Do not declare virtual members in sealed types Les types déclarent des méthodes comme étant virtuelles afin d'hériter de types en mesure de substituer l'implémentation de la méthode virtuelle.Types declare methods as virtual so that inheriting types can override the implementation of the virtual method. Par définition, un type sealed ne peut pas être hérité.By definition, a sealed type cannot be inherited. Une méthode virtuelle sur un type sealed est alors sans signification.This makes a virtual method on a sealed type meaningless.
CA1049CA1049 CA1049 : Les types qui ont des ressources natives doivent être supprimablesCA1049: Types that own native resources should be disposable Les types qui allouent des ressources non managées doivent implémenter IDisposable pour permettre aux appelants de libérer ces ressources à la demande et de raccourcir les durées de vie des objets qui les détiennent.Types that allocate unmanaged resources should implement IDisposable to enable callers to release those resources on demand and to shorten the lifetimes of the objects that hold the resources.
CA1050CA1050 CA1050 : Déclarez les types dans des espaces de nomsCA1050: Declare types in namespaces 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.Types are declared in namespaces to prevent name collisions and as a way to organize related types in an object hierarchy.
CA1051CA1051 CA1051 : Ne déclarez pas de champs d’instances visiblesCA1051: Do not declare visible instance fields Un champ s'utilise principalement en tant que détail d'implémentation.The primary use of a field should be as an implementation detail. Les champs doivent être privés ou internes, et doivent être exposés au moyen de propriétés.Fields should be private or internal and should be exposed by using properties.
CA1052CA1052 CA1052 : Les types de conteneurs statiques doivent être sealedCA1052: Static holder types should be 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).A public or protected type contains only static members and is not declared by using the sealed (C# Reference) (NotInheritable) modifier. 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.A type that is not meant to be inherited should be marked by using the sealed modifier to prevent its use as a base type.
CA1053CA1053 CA1053 : Les types de conteneurs statiques ne doivent pas comporter de constructeurCA1053: Static holder types should not have constructors Un type public ou imbriqué déclare uniquement des membres statiques et dispose d'un constructeur par défaut public ou protégé.A public or nested public type declares only static members and has a public or protected default constructor. Le constructeur est inutile car l'appel à des membres statiques ne requiert aucune instance du type.The constructor is unnecessary because calling static members does not require an instance of the 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é.The string overload should call the uniform resource identifier (URI) overload by using the string argument for safety and security.
CA1054CA1054 CA1054 : Les paramètres d’URI ne doivent pas être des chaînesCA1054: URI parameters should not be strings 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.If a method takes a string representation of a URI, a corresponding overload should be provided that takes an instance of the URI class, which provides these services in a safe and secure manner.
CA1055CA1055 CA1055 : Les valeurs de retour d’URI ne doivent pas être des chaînesCA1055: URI return values should not be strings Cette règle considère que la méthode retourne un URI.This rule assumes that the method returns a 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é.A string representation of a URI is prone to parsing and encoding errors, and can lead to security vulnerabilities. La classe System.Uri fournit ces services de manière sûre et sécurisée.The System.Uri class provides these services in a safe and secure manner.
CA1056CA1056 CA1056 : Les propriétés d’URI ne doivent pas être des chaînesCA1056: URI properties should not be strings Cette règle considère que la propriété représente un URI (Uniform Resource Identifier).This rule assumes that the property represents a Uniform Resource Identifier (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é.A string representation of a URI is prone to parsing and encoding errors, and can lead to security vulnerabilities. La classe System.Uri fournit ces services de manière sûre et sécurisée.The System.Uri class provides these services in a safe and secure manner.
CA1057CA1057 CA1057 : Les surcharges d’URI de chaîne appellent des surcharges de System.UriCA1057: String URI overloads call System.Uri overloads Un type déclare des surcharges de méthode qui diffèrent uniquement par le remplacement d'un paramètre de chaîne par un paramètre System.Uri.A type declares method overloads that differ only by the replacement of a string parameter with a System.Uri parameter. La surcharge qui accepte le paramètre de chaîne n'appelle pas la surcharge qui accepte le paramètre URI.The overload that takes the string parameter does not call the overload that takes the URI parameter.
CA1058CA1058 CA1058 : Les types ne doivent pas étendre certains types de baseCA1058: Types should not extend certain base types Un type visible de l'extérieur étend certains types de base.An externally visible type extends certain base types. Utilisez l'une des solutions de remplacement.Use one of the alternatives.
CA1059CA1059 CA1059 : Les membres ne doivent pas exposer certains types concretsCA1059: Members should not expose certain concrete types Un type concret est un type qui présente une implémentation complète et, par conséquent, peut être instancié.A concrete type is a type that has a complete implementation and therefore can be instantiated. Pour permettre une utilisation généralisée du membre, remplacez le type concret par l'interface suggérée.To enable widespread use of the member, replace the concrete type by using the suggested interface.
CA1060CA1060 CA1060 : Déplacer P/Invoke vers une classe NativeMethodsCA1060: Move P/Invokes to NativeMethods class 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 BasicVisual Basic, accèdent à du code non managé.Platform Invocation methods, such as those that are marked by using the System.Runtime.InteropServices.DllImportAttribute attribute, or methods that are defined by using the Declare keyword in Visual BasicVisual Basic, access unmanaged code. Ces méthodes doivent être de la classe NativeMethods, SafeNativeMethods ou UnsafeNativeMethods.These methods should be of the NativeMethods, SafeNativeMethods, or UnsafeNativeMethods class.
CA1061CA1061 CA1061 : Ne masquez pas les méthodes de la classe de baseCA1061: Do not hide base class methods 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.A method in a base type is hidden by an identically named method in a derived type, when the parameter signature of the derived method differs only by types that are more weakly derived than the corresponding types in the parameter signature of the base method.
CA1062CA1062 CA1062 : Valider les arguments de méthodes publiquesCA1062: Validate arguments of public methods 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.All reference arguments that are passed to externally visible methods should be checked against null.
CA1063CA1063 CA1063 : Implémentez IDisposable correctementCA1063: Implement IDisposable correctly Tous les types IDisposable doivent implémenter le modèle Dispose correctement.All IDisposable types should implement the Dispose pattern correctly.
CA1064CA1064 CA1064 : Les exceptions doivent être publiquesCA1064: Exceptions should be public Une exception interne est uniquement visible à l'intérieur de sa propre portée interne.An internal exception is visible only inside its own internal scope. 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.After the exception falls outside the internal scope, only the base exception can be used to catch the exception. Si l’exception interne est héritée Exception, SystemException, ou ApplicationException, le code externe n’aura pas d’informations suffisantes pour savoir que faire avec l’exception.If the internal exception is inherited from Exception, SystemException, or ApplicationException, the external code will not have sufficient information to know what to do with the exception.
CA1065CA1065 CA1065 : Ne levez pas d’exceptions dans des emplacements inattendusCA1065: Do not raise exceptions in unexpected locations Une méthode dont l'objet n'est pas de lever des exceptions lève une exception.A method that is not expected to throw exceptions throws an exception.
CA1300CA1300 CA1300 : Spécifiez MessageBoxOptionsCA1300: Specify MessageBoxOptions Pour afficher correctement une boîte de message pour les cultures qui utilisent un sens de lecture de droite à gauche, les membres RightAlign et RtlReading de l'énumération MessageBoxOptions doivent être passés à la méthode Show.To correctly display a message box for cultures that use a right-to-left reading order, the RightAlign and RtlReading members of the MessageBoxOptions enumeration must be passed to the Show method.
CA1301CA1301 CA1301 : Évitez les accélérateurs en doublonCA1301: Avoid duplicate accelerators Une touche d'accès rapide, également connue sous le nom d'accélérateur, autorise l'accès à un contrôle par le biais du clavier, à l'aide de la touche ALT.An access key, also known as an accelerator, enables keyboard access to a control by using the ALT key. Lorsque plusieurs contrôles présentent des touches d'accès rapide en doublon, le comportement de ces dernières n'est pas correctement défini.When multiple controls have duplicate access keys, the behavior of the access key is not well defined.
CA1302CA1302 CA1302 : Ne codez pas en dur les chaînes spécifiques aux paramètres régionauxCA1302: Do not hardcode locale specific strings L’énumération System.Environment.SpecialFolder contient des membres qui font référence à des dossiers système spéciaux.The System.Environment.SpecialFolder enumeration contains members that refer to special system folders. Les emplacements de ces dossiers peuvent avoir des valeurs distinctes selon le système d'exploitation ; l'utilisateur peut modifier certains des emplacements, et ces derniers sont localisés.The locations of these folders can have different values on different operating systems; the user can change some of the locations; and the locations are localized. La méthode Environment.GetFolderPath retourne les emplacements associés à l'énumération Environment.SpecialFolder, localisés et appropriés pour l'ordinateur en cours d'exécution.The Environment.GetFolderPath method returns the locations that are associated with the Environment.SpecialFolder enumeration, localized and appropriate for the currently running computer.
CA1303CA1303 CA1303 : Ne passez pas des littéraux comme paramètres localisésCA1303: Do not pass literals as localized parameters Une méthode visible de l'extérieur passe un littéral de chaîne en tant que paramètre à un constructeur ou une méthode dans la bibliothèque de classes du .NET Framework.NET Framework ; en outre, cette chaîne doit être localisable.An externally visible method passes a string literal as a parameter to a constructor or method in the .NET Framework.NET Framework class library, and that string should be localizable.
CA1304CA1304 CA1304 : Spécifier CultureInfoCA1304: Specify 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.A method or constructor calls a member that has an overload that accepts a System.Globalization.CultureInfo parameter, and the method or constructor does not call the overload that takes the CultureInfo parameter. 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.When a CultureInfo or System.IFormatProvider object is not supplied, the default value that is supplied by the overloaded member might not have the effect that you want in all locales.
CA1305CA1305 CA1305 : Spécifier IFormatProviderCA1305: Specify 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.A method or constructor calls one or more members that have overloads that accept a System.IFormatProvider parameter, and the method or constructor does not call the overload that takes the IFormatProvider parameter. 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.When a System.Globalization.CultureInfo or IFormatProvider object is not supplied, the default value that is supplied by the overloaded member might not have the effect that you want in all locales.
CA1306CA1306 CA1306 : Définir les paramètres régionaux pour les types de donnéesCA1306: Set locale for data types Les paramètres régionaux déterminent des éléments de présentation des données spécifiques à la culture, telles que la mise en forme utilisée pour les valeurs numériques, les symboles monétaires et l'ordre de tri.The locale determines culture-specific presentation elements for data, such as formatting that is used for numeric values, currency symbols, and sort order. Lorsque vous créez un DataTable ou un DataSet, vous devez définir les paramètres régionaux explicitement.When you create a DataTable or DataSet, you should explicitly set the locale.
CA1307CA1307 CA1307 : Spécifiez StringComparisonCA1307: Specify StringComparison Une opération de comparaison de chaînes utilise une surcharge de méthode qui ne définit pas de paramètre StringComparison.A string comparison operation uses a method overload that does not set a StringComparison parameter.
CA1308CA1308 CA1308 : Normalisez les chaînes en majusculesCA1308: Normalize strings to uppercase Les chaînes doivent être normalisées en majuscules.Strings should be normalized to uppercase. En cas de conversion en minuscules, un petit groupe de caractères ne peut pas faire un aller-retour.A small group of characters cannot make a round trip when they are converted to lowercase.
CA1309CA1309 CA1309 : Utilisez StringComparison avec la valeur OrdinalCA1309: Use ordinal StringComparison Opération de comparaison de chaînes non linguistique qui n'affecte pas la valeur Ordinal ou OrdinalIgnoreCase au paramètre StringComparison.A string comparison operation that is nonlinguistic does not set the StringComparison parameter to either Ordinal or OrdinalIgnoreCase. 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.By explicitly setting the parameter to either StringComparison.Ordinal or StringComparison.OrdinalIgnoreCase, your code often gains speed, becomes more correct, and becomes more reliable.
CA1400CA1400 CA1400 : Des points d’entrée P/Invoke doivent exister.CA1400: P/Invoke entry points should exist Une méthode publique ou protégée est marquée avec l'attribut System.Runtime.InteropServices.DllImportAttribute.A public or protected method is marked by using the System.Runtime.InteropServices.DllImportAttribute attribute. La bibliothèque non managée n'a pas pu être localisée, ou la méthode n'a pu être mise en correspondance avec aucune fonction de la bibliothèque.Either the unmanaged library could not be located or the method could not be matched to a function in the library.
CA1401CA1401 CA1401 : Les P/Invoke ne doivent pas être visibleCA1401: P/Invokes should not be visible 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 BasicVisual Basic).A public or protected method in a public type has the System.Runtime.InteropServices.DllImportAttribute attribute (also implemented by the Declare keyword in Visual BasicVisual Basic). De telles méthodes ne doivent pas être exposées.Such methods should not be exposed.
CA1402CA1402 CA1402 : Évitez les surcharges dans les interfaces COM visiblesCA1402: Avoid overloads in COM visible interfaces Lorsque les méthodes surchargées sont exposées aux clients COM, seule la première surcharge de méthode conserve son nom.When overloaded methods are exposed to COM clients, only the first method overload retains its name. Les surcharges suivantes sont renommées de manière unique par l'ajout d'un trait de soulignement () au nom et d'un entier qui correspond à l'ordre de déclaration de la surcharge.Subsequent overloads are uniquely renamed by appending to the name an underscore character () and an integer that corresponds to the order of declaration of the overload.
CA1403CA1403 CA1403 : Les types Structurer automatiquement ne doivent pas être visibles par COMCA1403: Auto layout types should not be COM visible Un type valeur visible par COM est marqué avec l'attribut System.Runtime.InteropServices.StructLayoutAttribute qui a la valeur LayoutKind.Auto. La disposition de ces types peut varier suivant les versions du .NET Framework.NET Framework, ce qui bloque les clients COM qui attendent une disposition spécifique.A COM-visible value type is marked by using the System.Runtime.InteropServices.StructLayoutAttribute attribute set to LayoutKind.Auto. The layout of these types can change between versions of the .NET Framework.NET Framework, which will break COM clients that expect a specific layout.
CA1404CA1404 CA1404 : Appeler GetLastError immédiatement après P/InvokeCA1404: Call GetLastError immediately after P/Invoke Un appel est fait à la méthode Marshal.GetLastWin32Error ou l’équivalent Win32Win32 fonction GetLastError et l’appel immédiatement antérieur n’est pas un système d’exploitation appeler la méthode.A call is made to the Marshal.GetLastWin32Error method or the equivalent Win32Win32 GetLastError function, and the immediately previous call is not to an operating system invoke method.
CA1405CA1405 CA1405 : Les types de base type visibles par COM doivent être visibles par COMCA1405: COM visible type base types should be COM visible Un type visible par COM dérive d'un type qui n'est pas visible par COM.A COM-visible type derives from a type that is not COM-visible.
CA1406CA1406 CA1406 : Éviter les arguments Int64 pour les clients Visual Basic 6CA1406: Avoid Int64 arguments for Visual Basic 6 clients Les clients COM Visual Basic 6 ne peuvent pas accéder aux entiers de 64 bits.Visual Basic 6 COM clients cannot access 64-bit integers.
CA1407CA1407 CA1407 : Éviter les membres statiques dans les types visibles par COMCA1407: Avoid static members in COM visible types COM ne prend pas en charge les méthodes statiques.COM does not support static methods.
CA1408CA1408 CA1408 : N’utilisez pas le paramètre AutoDual ClassInterfaceTypeCA1408: Do not use AutoDual ClassInterfaceType Les types qui utilisent une interface double permettent aux clients de se lier à une disposition d'interface spécifique.Types that use a dual interface enable clients to bind to a specific interface layout. Les modifications apportées à une version future de la disposition du type ou des types de base bloquent les clients COM qui se lient à l'interface.Any changes in a future version to the layout of the type or any base types will break COM clients that bind to the interface. Par défaut, si l'attribut ClassInterfaceAttribute n'est pas spécifié, une interface de répartition uniquement est utilisée.By default, if the ClassInterfaceAttribute attribute is not specified, a dispatch-only interface is used.
CA1409CA1409 CA1409 : Les types visibles par COM doivent pouvoir être créésCA1409: Com visible types should be creatable Un type référence marqué spécifiquement comme visible par des clients COM contient un constructeur public paramétré, mais ne contient pas de constructeur public par défaut (sans paramètre).A reference type that is specifically marked as visible to COM contains a public parameterized constructor but does not contain a public default (parameterless) constructor. Les clients COM ne peuvent pas créer de type sans constructeur public par défaut.A type without a public default constructor is not creatable by COM clients.
CA1410CA1410 CA1410 : Les méthodes d’inscription COM doivent être mises en correspondanceCA1410: COM registration methods should be matched Un type déclare une méthode marquée avec l'attribut System.Runtime.InteropServices.ComRegisterFunctionAttribute, mais ne déclare pas une méthode marquée avec l'attribut System.Runtime.InteropServices.ComUnregisterFunctionAttribute, ou vice versa.A type declares a method that is marked by using the System.Runtime.InteropServices.ComRegisterFunctionAttribute attribute but does not declare a method marked by using the System.Runtime.InteropServices.ComUnregisterFunctionAttribute attribute, or vice versa.
CA1411CA1411 CA1411 : Les méthodes d’inscription COM ne doivent pas être visiblesCA1411: COM registration methods should not be visible Une méthode marquée avec l'attribut System.Runtime.InteropServices.ComRegisterFunctionAttribute ou System.Runtime.InteropServices.ComUnregisterFunctionAttribute est visible de l'extérieur.A method marked by using the System.Runtime.InteropServices.ComRegisterFunctionAttribute attribute or the System.Runtime.InteropServices.ComUnregisterFunctionAttribute attribute is externally visible.
CA1412CA1412 CA1412 : Marquez les interfaces ComSource comme IDispatchCA1412: Mark ComSource Interfaces as IDispatch Un type est marqué avec l'attribut System.Runtime.InteropServices.ComSourceInterfacesAttribute et au moins une des interfaces spécifiées n'est pas marquée avec l'attribut System.Runtime.InteropServices.InterfaceTypeAttribute ayant la valeur ComInterfaceType.InterfaceIsIDispatch.A type is marked by using the System.Runtime.InteropServices.ComSourceInterfacesAttribute attribute, and at least one of the specified interfaces is not marked by using the System.Runtime.InteropServices.InterfaceTypeAttribute attribute set to ComInterfaceType.InterfaceIsIDispatch.
CA1413CA1413 CA1413 : Évitez les champs non publics dans les types valeur visibles par COMCA1413: Avoid non-public fields in COM visible value types Les champs d'instance non publics des types valeur visibles par COM sont visibles par les clients COM.Nonpublic instance fields of COM-visible value types are visible to COM clients. Passez en revue le contenu des champs pour voir les informations qui ne doivent pas être exposées, sinon vous aurez une conception imprévue ou des conséquences sur la sécurité.Review the content of the fields for information that should not be exposed, or that will have unintended design or security effects.
CA1414CA1414 CA1414 : Marquer les arguments P/Invoke booléens comme MarshalAsCA1414: Mark boolean P/Invoke arguments with MarshalAs Le type de données booléen contient plusieurs représentations dans le code non managé.The Boolean data type has multiple representations in unmanaged code.
CA1415CA1415 CA1415 : Déclarer correctement les P/InvokeCA1415: Declare P/Invokes correctly Cette règle recherche des déclarations de méthode d'appel de code non managé qui ciblent des fonctions Win32Win32 présentant un pointeur vers un paramètre de structure OVERLAPPED, et le paramètre managé correspondant n'est pas un pointeur vers une structure System.Threading.NativeOverlapped.This rule looks for operating system invoke method declarations that target Win32Win32 functions that have a pointer to an OVERLAPPED structure parameter and the corresponding managed parameter is not a pointer to a System.Threading.NativeOverlapped structure.
CA1500CA1500 CA1500 : Les noms de variable ne doivent pas être identiques à des noms de champsCA1500: Variable names should not match field names Une méthode d’instance déclare un paramètre ou une variable locale dont le nom correspond à un champ d’instance du type déclarant, ce qui entraîne des erreurs.An instance method declares a parameter or a local variable whose name matches an instance field of the declaring type, leading to errors.
CA1501CA1501 CA1501 : Évitez l’excès d’héritageCA1501: Avoid excessive inheritance Un type est imbriqué de plus de quatre niveaux dans sa hiérarchie d'héritage.A type is more than four levels deep in its inheritance hierarchy. Les hiérarchies de type profondément imbriquées peuvent être difficiles à suivre, comprendre et gérer.Deeply nested type hierarchies can be difficult to follow, understand, and maintain.
CA1502CA1502 CA1502 : Éviter une complexité excessiveCA1502: Avoid excessive complexity 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.This rule measures the number of linearly independent paths through the method, which is determined by the number and complexity of conditional branches.
CA1504CA1504 CA1504 : Vérifiez les noms de champs peu clairsCA1504: Review misleading field names Le nom d’un champ d’instance commence par « s_ » ou le nom d’un champ statique de (Shared en Visual Basic) commence par « m_ ».The name of an instance field starts with "s_", or the name of a static (Shared in Visual Basic) field starts with "m_".
CA1505CA1505 CA1505 : Évitez le code impossible à maintenirCA1505: Avoid unmaintainable code Un type ou une méthode a une faible valeur d'indice de maintenabilité.A type or method has a low maintainability index value. 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.A low maintainability index indicates that a type or method is probably difficult to maintain and would be a good candidate for redesign.
CA1506CA1506 CA1506 : Évitez les couplages de classe excessifsCA1506: Avoid excessive class coupling 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.This rule measures class coupling by counting the number of unique type references that a type or method contains.
CA1600CA1600 CA1600 : N’utilisez pas de priorité de processus inactifCA1600: Do not use idle process priority N'affectez pas la valeur Idle à la priorité de processus.Do not set process priority to Idle. Sinon, les processus avec System.Diagnostics.ProcessPriorityClass.Idle occuperaient le processeur alors qu'il devrait être inactif et bloqueraient par conséquent la veille.Processes that have System.Diagnostics.ProcessPriorityClass.Idle will occupy the CPU when it would otherwise be idle, and will therefore block standby.
CA1601CA1601 CA1601 : Ne pas utiliser de minuteries qui empêchent les changements d’état de l’alimentationCA1601: Do not use timers that prevent power state changes En effet, toute activité périodique supérieure à cette fréquence occupe le processeur et interfère avec les minuteries d'inactivité qui déclenchent la mise en veille de l'écran et des disques durs pour économiser de l'énergie.Higher-frequency periodic activity will keep the CPU busy and interfere with power-saving idle timers that turn off the display and hard disks.
CA1700CA1700 CA1700 : Ne nommez pas les valeurs d’énumération 'Reserved'CA1700: Do not name enum values 'Reserved' Cette règle suppose qu'un membre de l'énumération dont le nom contient le terme "reserved" n'est pas utilisé actuellement, mais constitue un espace réservé à renommer ou à supprimer dans une version ultérieure.This rule assumes that an enumeration member that has a name that contains "reserved" is not currently used but is a placeholder to be renamed or removed in a future version. Renommer ou supprimer un membre constitue une modification avec rupture.Renaming or removing a member is a breaking change.
CA1701CA1701 CA1701 : La casse des mots composés de chaînes de ressources doit être correcteCA1701: Resource string compound words should be cased correctly Chaque mot dans la chaîne de ressource est fractionné en jetons basés sur la casse.Each word in the resource string is split into tokens based on the casing. Chaque combinaison de deux jetons contiguë est vérifiée par la bibliothèque du correcteur orthographique Microsoft.Each contiguous two-token combination is checked by the Microsoft spelling checker library. S'il est reconnu, le mot produit une violation de la règle.If recognized, the word produces a violation of the rule.
CA1702CA1702 CA1702 : La casse des mots composés doit être correcteCA1702: Compound words should be cased correctly Le nom d'un identificateur contient plusieurs mots et au moins l'un des mots semble être un mot composé qui ne présente pas une casse correcte.The name of an identifier contains multiple words, and at least one of the words appears to be a compound word that is not cased correctly.
CA1703CA1703 CA1703 : Les chaînes de ressources doit être orthographiées correctementCA1703: Resource strings should be spelled correctly Une chaîne de ressource contient un ou plusieurs mots qui ne sont pas reconnus par la bibliothèque du vérificateur d'orthographe Microsoft.A resource string contains one or more words that are not recognized by the Microsoft spelling checker library.
CA1704CA1704 CA1704 : Les identificateurs doivent être correctement orthographiésCA1704: Identifiers should be spelled correctly Le nom d'un identificateur visible de l'extérieur contient un ou plusieurs mots qui ne sont pas reconnus par la bibliothèque du vérificateur d'orthographe Microsoft.The name of an externally visible identifier contains one or more words that are not recognized by the Microsoft spelling checker library.
CA1707CA1707 CA1707 : Les identificateurs ne doivent pas contenir de traits de soulignementCA1707: Identifiers should not contain underscores Par convention, les noms d'identificateurs ne contiennent pas de trait de soulignement ().By convention, identifier names do not contain the underscore () character. Cette règle vérifie les espaces de noms, types, membres et paramètres.This rule checks namespaces, types, members, and parameters.
CA1708CA1708 CA1708 : Les identificateurs ne doivent pas différer que par leur casseCA1708: Identifiers should differ by more than case 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.Identifiers for namespaces, types, members, and parameters cannot differ only by case because languages that target the common language runtime are not required to be case-sensitive.
CA1709CA1709 CA1709 : La casse des identificateurs doit être correcteCA1709: Identifiers should be cased correctly Par convention, les noms de paramètres utilisent la casse mixte et les noms d'espaces de noms, de types et de membres utilisent la convention de casse Pascal.By convention, parameter names use camel casing and namespace, type, and member names use Pascal casing.
CA1710CA1710 CA1710 : Les identificateurs doivent avoir un suffixe correctCA1710: Identifiers should have correct suffix 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.By convention, the names of types that extend certain base types or that implement certain interfaces, or types that are derived from these types, have a suffix that is associated with the base type or interface.
CA1711CA1711 CA1711 : Les identificateurs ne doivent pas avoir un suffixe incorrectCA1711: Identifiers should not have incorrect suffix 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.By convention, only the names of types that extend certain base types or that implement certain interfaces, or types that are derived from these types, should end with specific reserved suffixes. Les autres noms de types ne doivent pas utiliser ces suffixes réservés.Other type names should not use these reserved suffixes.
CA1712CA1712 CA1712 : Ne préfixez pas les valeurs d’énumération avec le nom du typeCA1712: Do not prefix enum values with type name 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.Names of enumeration members are not prefixed by using the type name because development tools are expected to provide type information.
CA1713CA1713 CA1713 : Les événements ne doivent avoir le préfixe Before ou AfterCA1713: Events should not have before or after prefix Le nom d'un événement commence par « Before » ou « After ».The name of an event starts with "Before" or "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.To name related events that are raised in a specific sequence, use the present or past tense to indicate the relative position in the sequence of actions.
CA1714CA1714 CA1714 : Les énumérations d’indicateurs doivent avoir des noms au plurielCA1714: Flags enums should have plural names Une énumération publique comporte l'attribut System.FlagsAttribute et son nom ne se termine pas par « s ».A public enumeration has the System.FlagsAttribute attribute, and its name does not end in "s". Les types marqués avec FlagsAttribute ont des noms au pluriel, car l'attribut indique que plusieurs valeurs peuvent être spécifiées.Types that are marked by using FlagsAttribute have names that are plural because the attribute indicates that more than one value can be specified.
CA1715CA1715 CA1715 : Les identificateurs doivent avoir un préfixe correctCA1715: Identifiers should have correct prefix Le nom d'une interface extérieurement visible ne commence pas par un « I » majuscule.The name of an externally visible interface does not start with an uppercase "I". 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.The name of a generic type parameter on an externally visible type or method does not start with an uppercase "T".
CA1716CA1716 CA1716 : Les identificateurs ne doivent pas correspondre à des mots clésCA1716: Identifiers should not match keywords Un nom d'espace de noms ou un nom de type correspond à un mot clé réservé dans un langage de programmation.A namespace name or a type name matches a reserved keyword in a programming language. 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.Identifiers for namespaces and types should not match keywords that are defined by languages that target the common language runtime.
CA1717CA1717 CA1717 : Seuls les noms des énumérations FlagsAttribute doivent être au plurielCA1717: Only FlagsAttribute enums should have plural names 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.Naming conventions dictate that a plural name for an enumeration indicates that more than one value of the enumeration can be specified at the same time.
CA1719CA1719 CA1719 : Les noms des paramètres ne doivent pas être identiques aux noms des membresCA1719: Parameter names should not match member names Un nom de paramètre doit véhiculer la signification du paramètre et un nom de membre celle du membre.A parameter name should communicate the meaning of a parameter and a member name should communicate the meaning of a member. Un design où ceux-ci sont identiques est rare.It would be a rare design where these were the same. Donner à un paramètre le même que son membre n'est pas une méthode intuitive et rend la bibliothèque difficile à utiliser.Naming a parameter the same as its member name is unintuitive and makes the library difficult to use.
CA1720CA1720 CA1720 : Les identificateurs ne doivent pas contenir de noms de typesCA1720: Identifiers should not contain type names 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.The name of a parameter in an externally visible member contains a data type name, or the name of an externally visible member contains a language-specific data type name.
CA1721CA1721 CA1721 : Les noms des propriétés ne doivent pas être identiques à ceux des méthodes GetCA1721: Property names should not match get methods 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.The name of a public or protected member starts with "Get" and otherwise matches the name of a public or protected property. Les méthodes et propriétés « Get » doivent porter des noms distinguant clairement leur fonction."Get" methods and properties should have names that clearly distinguish their function.
CA1722CA1722 CA1722 : Les identificateurs ne doivent pas avoir un préfixe incorrectCA1722: Identifiers should not have incorrect prefix Par convention, seuls certains éléments de programmation présentent des noms qui commencent par un préfixe spécifique.By convention, only certain programming elements have names that begin with a specific prefix.
CA1724CA1724 CA1724 : Les noms de types ne doivent pas être identiques aux espaces de nomsCA1724: Type Names Should Not Match Namespaces Les noms de types ne doivent pas correspondre aux noms d'espaces de noms définis dans la bibliothèque de classes .NET Framework.NET Framework.Type names should not match the names of namespaces that are defined in the .NET Framework.NET Framework class library. Enfreindre cette règle peut réduire la facilité d'utilisation de la bibliothèque.Violating this rule can reduce the usability of the library.
CA1725CA1725 CA1725 : Les noms de paramètres doivent correspondre à la déclaration de baseCA1725: Parameter names should match base declaration La désignation cohérente des paramètres dans une hiérarchie de substitution augmente la facilité d'utilisation des substitutions de méthode.Consistent naming of parameters in an override hierarchy increases the usability of the method overrides. 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.A parameter name in a derived method that differs from the name in the base declaration can cause confusion about whether the method is an override of the base method or a new overload of the method.
CA1726CA1726 CA1726 : Utilisez les termes préférésCA1726: Use preferred terms Le nom d'un identificateur visible de l'extérieur contient un terme pour lequel un autre terme par défaut existe.The name of an externally visible identifier includes a term for which an alternative, preferred term exists. Le nom peut également inclure le terme « Indicateur » ou « Indicateurs ».Alternatively, the name includes the term "Flag" or "Flags".
CA1800CA1800 CA1800 : N’effectuez pas de cast inutilementCA1800: Do not cast unnecessarily Les casts en doublon font baisser les performances, surtout lorsque les casts sont exécutés au sein d'instructions d'itération compactes.Duplicate casts decrease performance, especially when the casts are performed in compact iteration statements.
CA1801CA1801 CA1801 : Passez en revue les paramètres inutilisésCA1801: Review unused parameters Une signature de méthode inclut un paramètre qui n'est pas utilisé dans le corps de la méthode.A method signature includes a parameter that is not used in the method body.
CA1802CA1802 CA1802 : Utilisez des littéraux où c’est appropriéCA1802: Use Literals Where Appropriate Un champ est déclaré statique et en lecture seule (Shared et ReadOnly en Visual BasicVisual Basic), et est initialisé avec une valeur qui est calculable à la compilation.A field is declared static and read-only (Shared and ReadOnly in Visual BasicVisual Basic), and is initialized by using a value that is computable at compile time. La valeur est assignée au champ ciblé étant calculable à la compilation, remplacez la déclaration pour une variable const (Const en Visual BasicVisual Basic) afin que la valeur est calculée au moment de la compilation plutôt qu’au moment de l’exécution.Because the value that is assigned to the targeted field is computable at compile time, change the declaration to a const (Const in Visual BasicVisual Basic) field so that the value is computed at compile time instead of at run time.
CA1804CA1804 CA1804 : Supprimez les variables locales inutiliséesCA1804: Remove unused locals Les variables locales inutilisées et les assignations inutiles augmentent la taille d'un assembly et font baisser les performances.Unused local variables and unnecessary assignments increase the size of an assembly and decrease performance.
CA1806CA1806 CA1806 : Ne pas ignorer les résultats de méthodeCA1806: Do not ignore method results 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é.A new object is created but never used; or a method that creates and returns a new string is called and the new string is never used; or a COM or P/Invoke method returns an HRESULT or error code that is never used.
CA1809CA1809 CA1809 : Évitez le surplus de variables localesCA1809: Avoid excessive locals Une méthode d'optimisation des performances courante consiste à stocker une valeur dans un registre de processeur au lieu de la mémoire ; cette méthode est appelée « enregistrement de la valeur ».A common performance optimization is to store a value in a processor register instead of memory, which is referred to as "enregistering the value". Pour augmenter le risque que toutes les variables locales sont enregistrées, limitez le nombre de variables locales à 64.To increase the chance that all local variables are enregistered, limit the number of local variables to 64.
CA1810CA1810 CA1810 : Initialisez les champs statiques de type référence en ligneCA1810: Initialize reference type static fields 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.When a type declares an explicit static constructor, the just-in-time (JIT) compiler adds a check to each static method and instance constructor of the type to make sure that the static constructor was previously called. Les vérifications des constructeurs statiques peuvent diminuer les performances.Static constructor checks can decrease performance.
CA1811CA1811 CA1811 : Évitez le recours à du code privé non appeléCA1811: Avoid uncalled private code Un membre privé ou interne (de niveau assembly) n'a pas d'appelants dans l'assembly, et n'est appelé ni par le Common Language Runtime, ni par un délégué.A private or internal (assembly-level) member does not have callers in the assembly; it is not invoked by the common language runtime; and it is not invoked by a delegate.
CA1812CA1812 CA1812 : Évitez les classes internes non instanciéesCA1812: Avoid uninstantiated internal classes Une instance d'un type de niveau assembly n'est pas créée par le code au sein de l'assembly.An instance of an assembly-level type is not created by code in the assembly.
CA1813CA1813 CA1813 : Évitez les attributs unsealedCA1813: Avoid unsealed attributes La bibliothèque de classes du .NET Framework.NET Framework fournit des méthodes pour récupérer des attributs personnalisés.The .NET Framework.NET Framework class library provides methods for retrieving custom attributes. Par défaut, ces méthodes recherchent la hiérarchie d'héritage des attributs.By default, these methods search the attribute inheritance hierarchy. Le fait de sceller l'attribut élimine la recherche dans la hiérarchie d'héritage et peut améliorer les performances.Sealing the attribute eliminates the search through the inheritance hierarchy and can improve performance.
CA1814CA1814 CA1814 : Utilisez des tableaux en escalier à la place de tableaux multidimensionnelsCA1814: Prefer jagged arrays over multidimensional Un tableau en escalier est un tableau dont les éléments sont des tableaux.A jagged array is an array whose elements are arrays. 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.The arrays that make up the elements can be of different sizes, leading to less wasted space for some sets of data.
CA1815CA1815 CA1815 : Remplacez Equals et l’opérateur égal à dans les types valeurCA1815: Override equals and operator equals on value types 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.For value types, the inherited implementation of Equals uses the Reflection library and compares the contents of all fields. 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.Reflection is computationally expensive, and comparing every field for equality might be unnecessary. 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.If you expect users to compare or sort instances, or to use instances as hash table keys, your value type should implement Equals.
CA1816CA1816 CA1816 : Appelez GC.SuppressFinalize correctementCA1816: Call GC.SuppressFinalize correctly Une méthode qui est une implémentation de Dispose n’appelle pas de catalogue global. 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).A method that is an implementation of Dispose does not call GC.SuppressFinalize; or a method that is not an implementation of Dispose calls GC.SuppressFinalize; or a method calls GC.SuppressFinalize and passes something other than this (Me in Visual Basic).
CA1819CA1819 CA1819 : Les propriétés ne doivent pas retourner des tableauxCA1819: Properties should not return arrays 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.Arrays that are returned by properties are not write-protected, even when the property is read-only. Pour protéger le tableau de toute falsification, la propriété doit retourner une copie du tableau.To keep the array tamper-proof, the property must return a copy of the array. En général, les utilisateurs ne comprennent l'incidence négative en matière de performances de l'appel à une telle propriété.Typically, users will not understand the adverse performance implications of calling such a property.
CA1820CA1820 CA1820 : Vérifiez la présence de chaînes vides en utilisant la longueur de chaîneCA1820: Test for empty strings using string length 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.Comparing strings by using the String.Length property or the String.IsNullOrEmpty method is significantly faster than using Equals.
CA1821CA1821 CA1821 : Supprimez les finaliseurs videsCA1821: Remove empty finalizers É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.Whenever you can, avoid finalizers because of the additional performance overhead that is involved in tracking object lifetime. Un finaliseur vide entraîne une charge supplémentaire sans aucun avantage.An empty finalizer incurs added overhead and delivers no benefit.
CA1822CA1822 CA1822 : Marquez les membres comme statiqueCA1822: Mark members as static Les membres qui n'accèdent pas aux données d'instance ou n'appellent pas de méthodes d'instance peuvent être marquées comme static (Shared en Visual BasicVisual Basic).Members that do not access instance data or call instance methods can be marked as static (Shared in Visual BasicVisual 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.After you mark the methods as static, the compiler will emit nonvirtual call sites to these members. Cette opération se traduit par un gain de performances mesurable pour le code dépendant des performances.This can give you a measurable performance gain for performance-sensitive code.
CA1823CA1823 CA1823 : Évitez les champs privés inutilisésCA1823: Avoid unused private fields Des champs privés qui ne sont pas accessibles dans l'assembly ont été détectés.Private fields were detected that do not appear to be accessed in the assembly.
CA1824CA1824 CA1824 : Marquez les assemblys avec NeutralResourcesLanguageAttributeCA1824: Mark assemblies with NeutralResourcesLanguageAttribute L'attribut NeutralResourcesLanguage informe le ResourceManager de la langue qui a été utilisée pour afficher les ressources d'une culture neutre d'un assembly.The NeutralResourcesLanguage attribute informs the ResourceManager of the language that was used to display the resources of a neutral culture for an 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.This improves lookup performance for the first resource that you load and can reduce your working set.
CA1900CA1900 CA1900 : Les champs de type valeur doivent être portablesCA1900: Value type fields should be portable Cette règle vérifie que les structures déclarées avec une disposition explicite s’aligneront correctement lorsqu’elles seront marshalées pour le code non managé sur les systèmes d’exploitation 64 bits.This rule checks that structures that are declared by using explicit layout will align correctly when marshaled to unmanaged code on 64-bit operating systems.
CA1901CA1901 CA1901 : Les déclarations P/Invoke doivent être portablesCA1901: P/Invoke declarations should be portable Cette règle évalue la taille de chaque paramètre et la valeur de retour d’un P/Invoke, puis vérifie que la taille du paramètre est correcte lorsqu’elle est marshalée au code non managé sur les systèmes d’exploitation 32 bits et 64 bits.This rule evaluates the size of each parameter and the return value of a P/Invoke, and verifies that the size of the parameter is correct when marshaled to unmanaged code on 32-bit and 64-bit operating systems.
CA1903CA1903 CA1903 : Utiliser l’API seulement à partir de l’infrastructure cibleCA1903: Use only API from targeted framework Un membre ou un type utilise un membre ou un type qui a été introduit dans un Service Pack qui ne figurait pas dans le Framework ciblé du projet.A member or type is using a member or type that was introduced in a service pack that was not included together with the targeted framework of the project.
CA2000CA2000 CA2000 : Supprimez les objets avant de perdre l’étendueCA2000: Dispose objects before losing scope 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.Because an exceptional event might occur that will prevent the finalizer of an object from running, the object should be explicitly disposed before all references to it are out of scope.
CA2001CA2001 CA2001 : Évitez d’appeler des méthodes susceptibles de poser des problèmesCA2001: Avoid calling problematic methods Un membre appelle une méthode potentiellement dangereuse ou problématique.A member calls a potentially dangerous or problematic method.
CA2002CA2002 CA2002 : Ne définissez pas un verrou sur des objets à identité faibleCA2002: Do not lock on objects with weak identity Un objet est dit d'identité faible lorsqu'il est accessible directement au-delà des limites d'un domaine d'application.An object is said to have a weak identity when it can be directly accessed across application domain boundaries. 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.A thread that tries to acquire a lock on an object that has a weak identity can be blocked by a second thread in a different application domain that has a lock on the same object.
CA2003CA2003 CA2003 : Ne traitez pas les fibres comme des threadsCA2003: Do not treat fibers as threads Un thread managé est traité comme un thread Win32Win32.A managed thread is being treated as a Win32Win32 thread.
CA2004CA2004 CA2004 : Supprimez les appels à GC.KeepAliveCA2004: Remove calls to GC.KeepAlive Si vous envisagez d'utiliser SafeHandle, supprimez tous les appels à GC.KeepAlive (objet).If you convert to SafeHandle usage, remove all calls to GC.KeepAlive (object). Dans ce cas, les classes n'ont pas à appeler GC.KeepAlive.In this case, classes should not have to call GC.KeepAlive. Cela suppose qu'elles n'ont pas de finaliseur mais qu'elles dépendent de SafeHandle pour finaliser le handle du système d'exploitation à leur place.This assumes they do not have a finalizer but rely on SafeHandle to finalize the OS handle for them.
CA2006CA2006 CA2006 : Utilisez SafeHandle pour encapsuler les ressources nativesCA2006: Use SafeHandle to encapsulate native resources L'utilisation de IntPtr dans du code managé peut être le signe d'un problème potentiel de sécurité et de fiabilité.Use of IntPtr in managed code might indicate a potential security and reliability problem. Toute utilisation de IntPtr doit être passée en revue pour déterminer s'il est nécessaire de recourir à un SafeHandle ou une technologie similaire à la place.All uses of IntPtr must be reviewed to determine whether use of a SafeHandle, or similar technology, is required in its place.
CA2100CA2100 CA2100 : Recherchez les failles de sécurité dans des requêtes SQLCA2100: Review SQL queries for security vulnerabilities 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.A method sets the System.Data.IDbCommand.CommandText property by using a string that is built from a string argument to the method. Cette règle suppose que l’argument de chaîne contient des entrées d’utilisateur.This rule assumes that the string argument contains user input. Une chaîne de commande SQL générée par une entrée d'utilisateur est vulnérable aux attaques par injection de code SQL.A SQL command string that is built from user input is vulnerable to SQL injection attacks.
CA2101CA2101 CA2101 : Spécifiez le marshaling pour les arguments de chaîne P/InvokeCA2101: Specify marshaling for P/Invoke string arguments 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.A platform invoke member allows partially trusted callers, has a string parameter, and does not explicitly marshal the string. Cela peut provoquer une faille de sécurité potentielle.This can cause a potential security vulnerability.
CA2102CA2102 CA2102 : Interceptez les exceptions non CLSCompliant dans des gestionnaires générauxCA2102: Catch non-CLSCompliant exceptions in general handlers Un membre dans un assembly qui n'est pas marqué avec RuntimeCompatibilityAttribute ou qui est marqué avec RuntimeCompatibility(WrapNonExceptionThrows = false) contient un bloc catch qui gère System.Exception et ne contient pas de bloc catch général immédiatement après.A member in an assembly that is not marked by using the RuntimeCompatibilityAttribute or is marked RuntimeCompatibility(WrapNonExceptionThrows = false) contains a catch block that handles System.Exception and does not contain an immediately following general catch block.
CA2103CA2103 CA2103 : Vérifiez la sécurité impérativeCA2103: Review imperative security Une méthode utilise la sécurité impérative et est susceptible de construire l'autorisation à l'aide d'informations d'état ou de valeurs de retour qui peuvent changer pendant que la demande est active.A method uses imperative security and might be constructing the permission by using state information or return values that can change as long as the demand is active. Utilisez la sécurité de déclaration dès que possible.Use declarative security whenever possible.
CA2104CA2104 CA2104 : Ne déclarez pas les types référence mutables en lecture seuleCA2104: Do not declare read only mutable reference types Un type visible de l’extérieur contient un champ en lecture seule visible de l’extérieur qui constitue un type référence mutable.An externally visible type contains an externally visible read-only field that is a mutable reference type. Un type mutable est un type dont les données d’instance peuvent être modifiées.A mutable type is a type whose instance data can be modified.
CA2105CA2105 CA2105 : Les champs de tableau ne doivent pas être en lecture seuleCA2105: Array fields should not be read only Lorsque vous appliquez le modificateur en lecture seule (ReadOnly en Visual BasicVisual Basic) à un champ qui contient un tableau, ce champ ne peut pas être modifié pour référencer un tableau différent.When you apply the read-only (ReadOnly in Visual BasicVisual Basic) modifier to a field that contains an array, the field cannot be changed to reference a different array. Toutefois, les éléments du tableau stockés dans un champ en lecture seule peuvent être modifiés.However, the elements of the array that are stored in a read-only field can be changed.
CA2106CA2106 CA2106 : Sécurisez les assertionsCA2106: Secure asserts Une méthode déclare une autorisation et aucune vérification de sécurité n’est exécutée sur l’appelant.A method asserts a permission and no security checks are performed on the caller. L’assertion d’une autorisation de sécurité effectuée sans vérification de sécurité peut rendre votre code vulnérable et facile à exploiter.Asserting a security permission without performing any security checks can leave an exploitable security weakness in your code.
CA2107CA2107 CA2107 : Passez en revue l’utilisation des méthodes Deny et PermitOnlyCA2107: Review deny and permit only usage La méthode PermitOnly et les actions de sécurité de CodeAccessPermission.Deny doivent être uniquement utilisées par les développeurs ayant des connaissances approfondies de la sécurité du .NET Framework.NET Framework.The PermitOnly method and CodeAccessPermission.Deny security actions should be used only by those who have an advanced knowledge of .NET Framework.NET Framework security. Le code qui utilise ces actions de sécurité doit subir une révision de sécurité.Code that uses these security actions should undergo a security review.
CA2108CA2108 CA2108 : Vérifiez la sécurité déclarative dans les types de valeursCA2108: Review declarative security on value types Un type valeur public ou protégé est sécurisé par l’accès aux données ou des demandes de liaison.A public or protected value type is secured by Data Access or Link Demands.
CA2109CA2109 CA2109 : Passez en revue les gestionnaires d’événements visiblesCA2109: Review visible event handlers Une méthode de gestion d’événements publique ou protégée a été détectée.A public or protected event-handling method was detected. Les méthodes de gestion d'événements ne doivent pas être exposées sauf nécessité absolue.Event-handling methods should not be exposed unless absolutely necessary.
CA2111CA2111 CA2111 : Les pointeurs ne doivent pas être visiblesCA2111: Pointers should not be visible Un pointeur n’est ni privé, ni interne ni en lecture seule.A pointer is not private, internal, or read-only. Un code malveillant peut modifier la valeur du pointeur, ce qui peut permettre l'accès aux emplacements arbitraires en mémoire ou provoquer des défaillances des applications ou du système.Malicious code can change the value of the pointer, which potentially gives access to arbitrary locations in memory or causes application or system failures.
CA2112CA2112 CA2112 : Les types sécurisés ne doivent pas exposer de champsCA2112: Secured types should not expose fields Un type public ou protégé contient des champs publics et est sécurisé par des demandes de liaison.A public or protected type contains public fields and is secured by Link Demands. Si un code a accès à une instance d'un type sécurisé par une demande de liaison, ce code n'a pas besoin de satisfaire la demande de liaison pour accéder aux champs du type.If code has access to an instance of a type that is secured by a link demand, the code does not have to satisfy the link demand to access the fields of the type.
CA2114CA2114 CA2114 : La sécurité de la méthode doit être un sur-ensemble du typeCA2114: Method security should be a superset of type Pour une même action, une méthode ne doit pas présenter de sécurité déclarative à la fois au niveau méthode et au niveau type.A method should not have both method-level and type-level declarative security for the same action.
CA2115CA2115 CA2115 : Appelez GC.KeepAlive lorsque vous utilisez des ressources nativesCA2115: Call GC.KeepAlive when using native resources Cette règle détecte les erreurs susceptibles de se produire du fait qu’une ressource non managée est en cours de finalisation alors qu’elle est encore utilisée dans un code non managé.This rule detects errors that might occur because an unmanaged resource is being finalized while it is still being used in unmanaged code.
CA2116CA2116 CA2116 : Les méthodes APTCA doivent appeler seulement des méthodes APTCACA2116: APTCA methods should only call APTCA methods Lorsque l'attribut APTCA (AllowPartiallyTrustedCallersAttribute) est présent dans un assembly entièrement fiable, et lorsque cet assembly exécute du code dans un autre assembly qui n'autorise pas les appelants partiellement fiables, il en résulte une faille de sécurité dont l'exploitation est possible.When the APTCA (AllowPartiallyTrustedCallersAttribute) is present on a fully trusted assembly, and the assembly executes code in another assembly that does not allow for partially trusted callers, a security exploit is possible.
CA2117CA2117 CA2117 : Les types APTCA doivent étendre seulement des types de base APTCACA2117: APTCA types should only extend APTCA base types Lorsque l'attribut APTCA est présent dans un assembly entièrement fiable, et lorsqu'un type présent dans l'assembly hérite d'un type qui n'autorise pas les appelants partiellement approuvés, il en résulte une faille de sécurité dont l'exploitation est possible.When the APTCA is present on a fully trusted assembly, and a type in the assembly inherits from a type that does not allow for partially trusted callers, a security exploit is possible.
CA2118CA2118 CA2118 : Passez en revue l’utilisation de SuppressUnmanagedCodeSecurityAttributeCA2118: Review SuppressUnmanagedCodeSecurityAttribute usage SuppressUnmanagedCodeSecurityAttribute modifie le comportement par défaut du système en matière de sécurité pour les membres qui exécutent du code non managé utilisant COM Interop ou l'appel de code non managé.SuppressUnmanagedCodeSecurityAttribute changes the default security system behavior for members that execute unmanaged code that uses COM interop or operating system invocation. Cet attribut est essentiellement utilisé pour accroître les performances ; toutefois, les gains de performance s'accompagnent de risques substantiels pour la sécurité.This attribute is primarily used to increase performance; however, the performance gains come together with significant security risks.
CA2119CA2119 CA2119 : Scellez les méthodes qui satisfont les interfaces privéesCA2119: Seal methods that satisfy private interfaces Un type public pouvant être hérité fournit une implémentation de méthode substituable d'une interface interne (Friend en Visual BasicVisual Basic).An inheritable public type provides an overridable method implementation of an internal (Friend in Visual BasicVisual Basic) interface. Pour corriger une violation de cette règle, empêchez la méthode d’être substituée en dehors de l’assembly.To fix a violation of this rule, prevent the method from being overridden outside the assembly.
CA2120CA2120 CA2120 : Sécurisez les constructeurs de sérialisationCA2120: Secure serialization constructors Ce type possède un constructeur qui accepte un objet System.Runtime.Serialization.SerializationInfo et un objet System.Runtime.Serialization.StreamingContext (la signature du constructeur de sérialisation).This type has a constructor that takes a System.Runtime.Serialization.SerializationInfo object and a System.Runtime.Serialization.StreamingContext object (the signature of the serialization constructor). Ce constructeur n’est pas sécurisé par une vérification de la sécurité, mais au moins un des constructeurs normaux dans le type est sécurisé.This constructor is not secured by a security check, but one or more of the regular constructors in the type are secured.
CA2121CA2121 CA2121 : Les constructeurs statiques doivent être privésCA2121: Static constructors should be private Le système appelle le constructeur statique avant la création de la première instance du type ou le référencement de tout membre statique.The system calls the static constructor before the first instance of the type is created or any static members are referenced. Si un constructeur statique n’est pas privé, il peut être appelé par un code autre que le système.If a static constructor is not private, it can be called by code other than the system. Selon les opérations effectuées dans le constructeur, cette possibilité peut provoquer un comportement inattendu.Depending on the operations that are performed in the constructor, this can cause unexpected behavior.
CA2122CA2122 CA2122 : N’exposez pas indirectement des méthodes avec des demandes de liaisonCA2122: Do not indirectly expose methods with link demands Un membre public ou protégé a des demandes de liaison et est appelé par un membre qui ne procède à aucune vérification de la sécurité.A public or protected member has Link Demands and is called by a member that does not perform any security checks. Une demande de liaison vérifie uniquement les autorisations de l'appelant immédiat.A link demand checks the permissions of the immediate caller only.
CA2123CA2123 CA2123 : Les demandes de liaison de substitution doivent être identiques au composant de baseCA2123: Override link demands should be identical to base Cette règle met en correspondance une méthode et sa méthode de base, qui est soit une interface, soit une méthode virtuelle dans un autre type, puis compare les demandes de liaison sur chacune.This rule matches a method to its base method, which is either an interface or a virtual method in another type, and then compares the link demands on each. Si cette règle est violée, un appelant malveillant peut ignorer la demande de liaison simplement en appelant la méthode non protégée.If this rule is violated, a malicious caller can bypass the link demand just by calling the unsecured method.
CA2124CA2124 CA2124 : Incluez dans un wrapper les clauses finally vulnérables dans un bloc try externeCA2124: Wrap vulnerable finally clauses in outer try Une méthode publique ou protégée contient un bloc try/finally.A public or protected method contains a try/finally block. Le bloc finally semble réinitialiser l’état de sécurité et n’est lui-même placé dans aucun bloc finally.The finally block appears to reset the security state and is not itself enclosed in a finally block.
CA2126CA2126 CA2126 : Les demandes de liaison de types nécessitent des demandes d’héritageCA2126: Type link demands require inheritance demands Un type unsealed public est protégé par une demande de liaison et a une méthode substituable.A public unsealed type is protected by using a link demand and has an overridable method. Ni le type ni la méthode ne sont protégés par une demande d'héritage.Neither the type nor the method is protected by using an inheritance demand.
CA2127CA2127 CA2136 : Les membres ne doivent pas avoir d’annotations de transparence en conflitCA2136: Members should not have conflicting transparency annotations Le code critique ne peut pas apparaître dans un assembly transparent de 100 pour cent.Critical code cannot occur in a 100 percent-transparent assembly. Cette règle analyse les assemblys entièrement transparents 100 pour cent de toutes les annotations SecurityCritical au type, du champ et de la méthode.This rule analyzes 100 percent-transparent assemblies for any SecurityCritical annotations at the type, field, and method levels.
CA2128CA2128 CA2147 : Les méthodes transparentes ne peuvent pas utiliser d’assertions de sécuritéCA2147: Transparent methods may not use security asserts Cette règle analyse toutes les méthodes et les types dans un assembly qui est transparent à 100 pour cent ou mixte/mi-critique et signale toutes les utilisations déclaratives ou impératives d’Assert.This rule analyzes all methods and types in an assembly that is either 100 percent-transparent or mixed transparent/critical, and flags any declarative or imperative use of Assert.
CA2129CA2129 CA2140 : Le code transparent ne doit référencer des éléments critiques de sécuritéCA2140: Transparent code must not reference security critical items Les méthodes marquées avec SecurityTransparentAttribute appellent des membres non publics marqués en tant que SecurityCritical.Methods that are marked by SecurityTransparentAttribute call nonpublic members that are marked as SecurityCritical. Cette règle analyse toutes les méthodes et tous les types dans un assembly qui est mi-transparent et mi-critique, et elle signale tous les appels du code transparent au code critique non public qui ne sont pas marqués comme SecurityTreatAsSafe.This rule analyzes all methods and types in an assembly that is mixed transparent/critical, and flags any calls from transparent code to nonpublic critical code that are not marked as SecurityTreatAsSafe.
CA2130CA2130 CA2130 : Les constantes critiques de sécurité doivent être transparentesCA2130: Security critical constants should be transparent La mise en application de la transparence n’est pas effectuée pour les valeurs de constante car les compilateurs alignent les valeurs de constante afin qu’aucune recherche ne soit requise au moment de l’exécution.Transparency enforcement is not enforced for constant values because compilers inline constant values so that no lookup is required at run time. Les champs constants doivent être transparents de sécurité (security-transparent) afin que les relecteurs de code ne supposent pas que le code transparent ne peut pas accéder à la constante.Constant fields should be security transparent so that code reviewers do not assume that transparent code cannot access the constant.
CA2131CA2131 CA2131 : Les types critiques de sécurité ne peuvent pas participer à l’équivalence des typesCA2131: Security critical types may not participate in type equivalence Un type participe à l'équivalence des types et un type lui-même, ou un membre ou champ du type, est marqué à l'aide de l'attribut SecurityCriticalAttribute.A type participates in type equivalence and either the type itself, or a member or field of the type, is marked by using the SecurityCriticalAttribute attribute. Cette règle se déclenche sur tout type ou type critique contenant des méthodes critiques ou des champs qui participent à l'équivalence de type.This rule occurs on any critical types or types that contain critical methods or fields that are participating in type equivalence. Lorsque le CLR détecte un tel type, il ne peut pas le charger avec une exception TypeLoadException au moment de l'exécution.When the CLR detects such a type, it does not load it with a TypeLoadException at run time. En général, cette règle se déclenche uniquement lorsque les utilisateurs implémentent l'équivalence de type manuellement plutôt qu'en comptant sur tlbimp et les compilateurs pour faire l'équivalence de type.Typically, this rule is raised only when users implement type equivalence manually instead of in by relying on tlbimp and the compilers to do the type equivalence.
CA2132CA2132 CA2132 : Les constructeurs par défaut doivent être au moins aussi critiques que les constructeurs par défaut de type de baseCA2132: Default constructors must be at least as critical as base type default constructors Les types et les membres qui possèdent l’attribut SecurityCriticalAttribute ne peuvent pas être utilisés par le code d’application Silverlight.Types and members that have the SecurityCriticalAttribute cannot be used by Silverlight application code. Les types et membres critiques de sécurité peuvent être uniquement utilisés par le .NET Framework.NET Framework dans la bibliothèque de classes Silverlight.Security-critical types and members can be used only by trusted code in the .NET Framework.NET Framework for Silverlight class library. Parce qu'une construction publique ou protégée dans une classe dérivée doit avoir la même transparence ou une transparence supérieure à sa classe de base, une classe dans une application ne peut pas être dérivée d'une classe marqué SecurityCritical.Because a public or protected construction in a derived class must have the same or greater transparency than its base class, a class in an application cannot be derived from a class marked as SecurityCritical.
CA2133CA2133 CA2133 : Les délégués doivent lier les méthodes avec une transparence cohérenteCA2133: Delegates must bind to methods with consistent transparency Cet avertissement se déclenche sur une méthode qui lie un délégué marqué à l'aide de l'attribut SecurityCriticalAttribute à une méthode transparente ou marquée à l'aide de l'attribut SecuritySafeCriticalAttribute.This warning is raised on a method that binds a delegate that is marked by using the SecurityCriticalAttribute to a method that is transparent or that is marked by using the SecuritySafeCriticalAttribute. L'avertissement se déclenche également sur une méthode qui lie un délégué transparent ou critique sécurisé (security-safe-critical) à une méthode critique.The warning also is raised on a method that binds a delegate that is transparent or safe-critical to a critical method.
CA2134CA2134 CA2134 : La transparence des méthodes doit rester cohérente lors du remplacement des méthodes de baseCA2134: Methods must keep consistent transparency when overriding base methods Cette règle se déclenche lorsqu'une méthode marquée à l'aide de l'attribut SecurityCriticalAttribute remplace une méthode qui est transparente ou marquée à l'aide de l'attribut SecuritySafeCriticalAttribute.This rule is raised when a method marked by using the SecurityCriticalAttribute overrides a method that is transparent or marked by using the SecuritySafeCriticalAttribute. La règle se déclenche également lorsqu'une méthode qui est transparente ou marquée à l'aide de l'attribut SecuritySafeCriticalAttribute remplace une méthode qui est marquée à l'aide d'un attribut SecurityCriticalAttribute.The rule also is raised when a method that is transparent or marked by using the SecuritySafeCriticalAttribute overrides a method that is marked by using a SecurityCriticalAttribute. La règle est appliquée lors de la substitution d’une méthode virtuelle ou de l’implémentation d’une interface.The rule is applied when overriding a virtual method or implementing an interface.
CA2135CA2135 CA2135 : Les assemblys de niveau 2 ne doivent pas contenir de LinkDemandsCA2135: Level 2 assemblies should not contain LinkDemands L’utilisation de LinkDemands est déconseillée dans l’ensemble de règles de sécurité de niveau 2.LinkDemands are deprecated in the level 2 security rule set. Au lieu d'utiliser LinkDemands pour implémenter la sécurité au moment de la compilation JIT, marquez les méthodes, types et champs avec l'attribut SecurityCriticalAttribute.Instead of using LinkDemands to enforce security at JIT compilation time, mark the methods, types, and fields by using the SecurityCriticalAttribute attribute.
CA2136CA2136 CA2136 : Les membres ne doivent pas avoir d’annotations de transparence en conflitCA2136: Members should not have conflicting transparency annotations Les attributs de transparence sont appliqués à partir d’éléments de code de plus grande portée à des éléments de plus petite portée.Transparency attributes are applied from code elements of larger scope to elements of smaller scope. Les attributs de transparence d'éléments de code avec une plus grande portée sont prioritaires sur les attributs de transparence des éléments de code contenus dans le premier élément.The transparency attributes of code elements that have larger scope take precedence over transparency attributes of code elements that are contained in the first element. Par exemple, une classe marquée à l'aide de l'attribut SecurityCriticalAttribute ne peut pas contenir de méthode marquée à l'aide de l'attribut SecuritySafeCriticalAttribute.For example, a class that is marked by using the SecurityCriticalAttribute attribute cannot contain a method that is marked by using the SecuritySafeCriticalAttribute attribute.
CA2137CA2137 CA2137 : Les méthodes transparentes doivent contenir uniquement des IL vérifiablesCA2137: Transparent methods must contain only verifiable IL Une méthode contient du code non vérifiable ou retourne un type par référence.A method contains unverifiable code or returns a type by reference. Cette règle se déclenche lorsque le code transparent de sécurité tente d'exécuter du code MISL (Microsoft Intermediate Language) non vérifiable.This rule is raised on attempts by security transparent code to execute unverifiable microsoft intermediate language (MISL). Toutefois, la règle ne contient pas de vérificateur IL (Intermediate Language) complet, et à la place utilise l’heuristique pour intercepter la plupart des violations de vérification MSIL.However, the rule does not contain a full IL verifier, and instead uses heuristics to catch most violations of MSIL verification.
CA2138CA2138 CA2138 : Les méthodes transparentes ne doivent pas appeler les méthodes avec l’attribut SuppressUnmanagedCodeSecurityCA2138: Transparent methods must not call methods with the SuppressUnmanagedCodeSecurity attribute Une méthode transparente de sécurité appelle une méthode qui est marquée à l'aide de l'attribut SuppressUnmanagedCodeSecurityAttribute.A security transparent method calls a method that is marked by using the SuppressUnmanagedCodeSecurityAttribute attribute.
CA2139CA2139 CA2139 : Les méthodes transparentes ne peuvent pas utiliser l’attribut HandleProcessCorruptingExceptionsCA2139: Transparent methods may not use the HandleProcessCorruptingExceptions attribute Cette règle est déclenchée par toute méthode transparente qui essaie de gérer une exception qui endommage un processus à l'aide de l'attribut HandleProcessCorruptedStateExceptionsAttribute.This rule is raised by any method that is transparent and attempts to handle a process corrupting exception by using the HandleProcessCorruptedStateExceptionsAttribute attribute. Une exception qui endommage un processus est une classification d'exception CLR version 4.0 des exceptions comme AccessViolationException.A process corrupting exception is a CLR version 4.0 exception classification of exceptions such as AccessViolationException. L'attribut HandleProcessCorruptedStateExceptionsAttribute peut uniquement être utilisé par des méthodes critiques de sécurité et sera ignoré s'il s'applique à une méthode transparente.The HandleProcessCorruptedStateExceptionsAttribute attribute may be used only by security critical methods, and will be ignored if it is applied to a transparent method.
CA2140CA2140 CA2140 : Le code transparent ne doit référencer des éléments critiques de sécuritéCA2140: Transparent code must not reference security critical items Un élément de code marqué à l'aide de l'attribut SecurityCriticalAttribute est critique de sécurité.A code element that is marked by using the SecurityCriticalAttribute attribute is security critical. Une méthode transparente ne peut pas utiliser un élément critique de sécurité.A transparent method cannot use a security critical element. Si un type transparent essaie d'utiliser un type critique de sécurité, TypeAccessException, MethodAccessException ou FieldAccessException est déclenché.If a transparent type attempts to use a security critical type, a TypeAccessException, MethodAccessException, or FieldAccessException is raised.
CA2141CA2141 CA2141 : Les méthodes transparentes ne satisfont pas les LinkDemandsCA2141:Transparent methods must not satisfy LinkDemands Une méthode transparente de sécurité appelle une méthode dans un assembly qui n'est pas marqué à l'aide de l'attribut APTCA, ou une méthode transparente de sécurité satisfait une demande LinkDemand pour un type ou une méthode.A security transparent method calls a method in an assembly that is not marked by using the APTCA, or a security transparent method satisfies a LinkDemand for a type or a method.
CA2142CA2142 CA2142 : Le code transparent ne doit pas être protégé avec des LinkDemandsCA2142: Transparent code should not be protected with LinkDemands Cette règle se déclenche sur les méthodes transparentes qui requièrent l'accès de LinkDemands.This rule is raised on transparent methods that require LinkDemands to access them. Le code transparent de sécurité ne doit pas être responsable de la vérification de la sécurité d’une opération. Par conséquent, il ne doit pas demander d’autorisations.Security transparent code should not be responsible for verifying the security of an operation, and therefore should not demand permissions.
CA2143CA2143 CA2143 : Les méthodes transparentes ne doivent pas utiliser de demandes de sécuritéCA2143: Transparent methods should not use security demands Le code transparent de sécurité ne doit pas être responsable de la vérification de la sécurité d’une opération. Par conséquent, il ne doit pas demander d’autorisations.Security transparent code should not be responsible for verifying the security of an operation, and therefore should not demand permissions. Le code transparent de sécurité doit utiliser des demandes complètes pour prendre des décisions de sécurité et le code critique sécurisé ne doit pas dépendre du code transparent pour l’exécution de ces demandes.Security transparent code should use full demands to make security decisions and safe-critical code should not rely on transparent code to have made the full demand.
CA2144CA2144 CA2144 : Le code transparent ne doit pas charger d’assemblys depuis des tableaux d’octetsCA2144: Transparent code should not load assemblies from byte arrays La revue de sécurité du code transparent n’est pas aussi complète que la revue de sécurité du code critique, car le code transparent ne peut pas exécuter d’actions relatives à la sécurité.The security review for transparent code is not as complete as the security review for critical code because transparent code cannot perform security sensitive actions. Les assemblys chargés à partir d'un tableau d'octets peuvent ne pas être remarqués dans du code transparent, et ce tableau d'octets peut contenir du code critique, voire critique de sécurité, qui doit être audité.Assemblies that are loaded from a byte array might not be noticed in transparent code, and that byte array might contain critical, or more important safe-critical code, that does have to be audited.
CA2145CA2145 CA2145 : Les méthodes transparentes ne doivent pas être décorées avec SuppressUnmanagedCodeSecurityAttributeCA2145: Transparent methods should not be decorated with the SuppressUnmanagedCodeSecurityAttribute Les méthodes décorées par l'attribut SuppressUnmanagedCodeSecurityAttribute ont un LinkDemand implicite sur toute méthode qui l'appelle.Methods that are decorated by the SuppressUnmanagedCodeSecurityAttribute attribute have an implicit LinkDemand put upon any method that calls it. Ce LinkDemand requiert que le code appelant soit critique de sécurité.This LinkDemand requires that the calling code be security critical. Le marquage de la méthode qui utilise SuppressUnmanagedCodeSecurity avec l’attribut SecurityCriticalAttribute rend cette exigence plus évidente pour les appelants de la méthode.Marking the method that uses SuppressUnmanagedCodeSecurity by using the SecurityCriticalAttribute attribute makes this requirement more obvious for callers of the method.
CA2146CA2146 CA2146 : Les types doivent être au moins aussi critiques que leurs types de base et leurs interfacesCA2146: Types must be at least as critical as their base types and interfaces Cette règle se déclenche lorsqu'un type dérivé a un attribut de transparence de sécurité qui n'est pas aussi critique que son type de base ou l'interface implémentée.This rule is raised when a derived type has a security transparency attribute that is not as critical as its base type or implemented interface. Seuls les types critiques peuvent dériver des types de base critiques ou implémenter des interfaces critiques, et seuls les types critiques ou critiques sécurisés peuvent dériver des types de base critiques sécurisés ou implémenter des interfaces critiques sécurisées.Only critical types can derive from critical base types or implement critical interfaces, and only critical or safe-critical types can derive from safe-critical base types or implement safe-critical interfaces.
CA2147CA2147 CA2147 : Les méthodes transparentes ne peuvent pas utiliser d’assertions de sécuritéCA2147: Transparent methods may not use security asserts Aucune autorisation suffisante n’est accordée à un code marqué comme attribut SecurityTransparentAttribute pour procéder à une assertion.Code that is marked as SecurityTransparentAttribute is not granted sufficient permissions to assert.
CA2149CA2149 CA2149 : Les méthodes transparentes ne doivent pas appeler du code natifCA2149: Transparent methods must not call into native code Cette règle se déclenche sur toute méthode transparente qui appelle directement en code natif (par exemple, via un appel P/Invoke).This rule is raised on any transparent method that calls directly into native code (for example, through a P/Invoke). Les violations de cette règle provoquent une exception MethodAccessException dans le modèle de transparence de niveau 2, et une demande complète pour le code UnmanagedCode dans le modèle de transparence de niveau 1.Violations of this rule lead to a MethodAccessException in the level 2 transparency model and a full demand for UnmanagedCode in the level 1 transparency model.
CA2151CA2151 CA2151 : Les champs avec des types critiques doivent être des champs critiques de sécuritéCA2151: Fields with critical types should be security critical Pour utiliser les types critiques de sécurité, le code qui référence le type doit être critique de sécurité ou critique sécurisé.To use security critical types, the code that references the type must be either security critical or security safe critical. Ceci est vrai même si la référence est indirecte.This is true even if the reference is indirect. Par conséquent, un champ transparent de sécurité ou critique sécurisé est trompeur, car le code transparent ne pourra toujours pas accéder au champ.Therefore, having a security transparent or security safe critical field is misleading because transparent code will still be unable to access the field.
CA2200CA2200 CA2200 : Levez à nouveau une exception pour conserver les détails de la pileCA2200: Rethrow to preserve stack details Une exception est à nouveau levée et est spécifiée explicitement dans l'instruction throw.An exception is rethrown and the exception is explicitly specified in the throw statement. 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.If an exception is rethrown by specifying the exception in the throw statement, the list of method calls between the original method that threw the exception and the current method is lost.
CA2201CA2201 CA2201 : Ne levez pas des types d’exceptions réservésCA2201: Do not raise reserved exception types Cela rend l'erreur d'origine difficile à détecter et à déboguer.This makes the original error difficult to detect and debug.
CA2202CA2202 CA2202 : Ne pas supprimer des objets plusieurs foisCA2202: Do not dispose objects multiple times Une implémentation de méthode contient des chemins d’accès de code qui peuvent provoquer des appels multiples à System.IDisposable.Dispose ou un Dispose équivalent (par exemple, une méthode Close() sur certains types) sur le même objet.A method implementation contains code paths that could cause multiple calls to System.IDisposable.Dispose or a Dispose equivalent (such as a Close() method on some types) on the same object.
CA2204CA2204 CA2204 : Les littéraux doivent être correctement orthographiésCA2204: Literals should be spelled correctly Une chaîne littéral dans un corps de méthode contient un ou plusieurs mots qui ne sont pas reconnus par la bibliothèque de vérificateur d'orthographe Microsoft.A literal string in a method body contains one or more words that are not recognized by the Microsoft spelling checker library.
CA2205CA2205 CA2205 : Utilisez des équivalents managés de l’API Win32CA2205: Use managed equivalents of Win32 API Une méthode d'appel de code non managé est définie et une méthode dotée de la fonctionnalité équivalente existe dans la bibliothèque de classes du .NET Framework.NET Framework.An operating system invoke method is defined and a method that has the equivalent functionality is located in the .NET Framework.NET Framework class library.
CA2207CA2207 CA2207 : Initialisez les champs statiques des types de valeurs inlineCA2207: Initialize value type static fields inline Un type valeur déclare un constructeur statique explicite.A value type declares an explicit static constructor. 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.To fix a violation of this rule, initialize all static data when it is declared and remove the static constructor.
CA2208CA2208 CA2208 : Instanciez les exceptions d’argument correctementCA2208: Instantiate argument exceptions correctly 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.A call is made to the default (parameterless) constructor of an exception type that is or derives from ArgumentException, or an incorrect string argument is passed to a parameterized constructor of an exception type that is or derives from ArgumentException.
CA2210CA2210 CA2210 : Les assemblys doivent avoir des noms forts validesCA2210: Assemblies should have valid strong names Le nom fort protège les clients du chargement à leur insu d'un assembly falsifié.The strong name protects clients from unknowingly loading an assembly that has been tampered with. Les assemblys sans noms forts ne doivent pas être déployés hors de scénarios très limités.Assemblies without strong names should not be deployed outside very limited scenarios. Si vous partagez ou distribuez des assemblys qui ne sont pas signés correctement, ceux-ci peuvent être falsifiés, le Common Language Runtime peut ne pas les charger ou l'utilisateur peut être amené à désactiver une vérification sur son ordinateur.If you share or distribute assemblies that are not correctly signed, the assembly can be tampered with, the common language runtime might not load the assembly, or the user might have to disable verification on his or her computer.
CA2211CA2211 CA2211 : Les champs non constants ne doivent pas être visiblesCA2211: Non-constant fields should not be visible Les champs static qui ne sont ni constants ni en lecture seule ne sont pas thread-safe.Static fields that are neither constants nor read-only are not 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.Access to such a field must be carefully controlled and requires advanced programming techniques to synchronize access to the class object.
CA2212CA2212 CA2212 : Ne marquez pas les composants pris en charge avec WebMethodCA2212: Do not mark serviced components with WebMethod Une méthode dans un type qui hérite de System.EnterpriseServices.ServicedComponent est marquée avec System.Web.Services.WebMethodAttribute.A method in a type that inherits from System.EnterpriseServices.ServicedComponent is marked by using System.Web.Services.WebMethodAttribute. Sachant que WebMethodAttribute et une méthode ServicedComponent ont des comportements incompatibles et des exigences en matière de contexte et de flux de transactions, le comportement de la méthode est incorrect dans certains scénarios.Because WebMethodAttribute and a ServicedComponent method have conflicting behavior and requirements for context and transaction flow, the behavior of the method will be incorrect in some scenarios.
CA2213CA2213 CA2213 : Les champs pouvant être supprimés doivent l’êtreCA2213: Disposable fields should be disposed Un type qui implémente System.IDisposable déclare des champs de types qui implémentent également IDisposable.A type that implements System.IDisposable declares fields that are of types that also implement IDisposable. La méthode Dispose du champ n’est pas appelée par la méthode Dispose du type déclarant.The Dispose method of the field is not called by the Dispose method of the declaring type.
CA2214CA2214 CA2214 : N’appelez pas de méthodes substituables dans les constructeursCA2214: Do not call overridable methods in constructors 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é.When a constructor calls a virtual method, the constructor for the instance that invokes the method may not have executed.
CA2215CA2215 CA2215 : Les méthodes Dispose doivent appeler la méthode Dispose de la classe de baseCA2215: Dispose methods should call base class dispose 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.If a type inherits from a disposable type, it must call the Dispose method of the base type from its own Dispose method.
CA2216CA2216 CA2216 : Les types supprimables doivent déclarer un finaliseurCA2216: Disposable types should declare finalizer 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.A type that implements System.IDisposable and has fields that suggest the use of unmanaged resources does not implement a finalizer, as described by Object.Finalize.
CA2217CA2217 CA2217 : Ne marquez pas les énumérations avec FlagsAttributeCA2217: Do not mark enums with 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.An externally visible enumeration is marked by using FlagsAttribute, and it has one or more values that are not powers of two or a combination of the other defined values on the enumeration.
CA2218CA2218 CA2218 : Remplacez GetHashCode lors du remplacement de EqualsCA2218: Override GetHashCode on overriding Equals GetHashCode retourne une valeur fondée sur l’instance actuelle adaptée aux algorithmes de hachage et aux structures de données telles qu’une table de hachage.GetHashCode returns a value, based on the current instance, that is suited for hashing algorithms and data structures such as a hash table. Deux objets de même type et égaux doivent retourner le même code de hachage.Two objects that are the same type and are equal must return the same hash code.
CA2219CA2219 CA2219 : Ne levez pas d’exceptions dans les clauses d’exceptionCA2219: Do not raise exceptions in exception clauses Lorsqu'une exception est levée dans une clause finally ou fault, la nouvelle exception masque l'exception active.When an exception is raised in a finally or fault clause, the new exception hides the active exception. Lorsqu'une exception est levée dans une clause filter, le runtime l'intercepte en silence.When an exception is raised in a filter clause, the run time silently catches the exception. Cela rend l'erreur d'origine difficile à détecter et à déboguer.This makes the original error difficult to detect and debug.
CA2220CA2220 CA2220 : Les finaliseurs doivent appeler le finaliseur de la classe de baseCA2220: Finalizers should call base class finalizer La finalisation doit être propagée par le biais de la hiérarchie d'héritage.Finalization must be propagated through the inheritance hierarchy. Pour garantir ce procédé, les types doivent appeler leur méthode Finalize de classe de base à partir de leur propre méthode Finalize.To guarantee this, types must call their base class Finalize method in their own Finalize method.
CA2221CA2221 CA2221 : Les finaliseurs doivent être protégésCA2221: Finalizers should be protected Les finaliseurs doivent utiliser le modificateur d’accès family.Finalizers must use the family access modifier.
CA2222CA2222 CA2222 : Ne réduisez pas la visibilité des membres héritésCA2222: Do not decrease inherited member visibility Vous ne devez pas modifier le modificateur d’accès destiné aux membres hérités.You should not change the access modifier for inherited members. La modification d'un membre hérité au profit d'un état privé n'empêche pas les appelants d'accéder à l'implémentation de classe de base de la méthode.Changing an inherited member to private does not prevent callers from accessing the base class implementation of the method.
CA2223CA2223 CA2223 : Les membres ne doivent pas différer uniquement par leur type de retourCA2223: Members should differ by more than return type Bien que le Common Language Runtime autorise l’utilisation de types de retour pour différencier des membres autrement identiques, cette fonctionnalité ne figure pas dans la Common Language Specification, et n’est pas une fonctionnalité courante des langages de programmation .NET.Although the common language runtime allows the use of return types to differentiate between otherwise identical members, this feature is not in the Common Language Specification, nor is it a common feature of .NET programming languages.
CA2224CA2224 CA2224 : Remplacez Equals lors de la surcharge de l’opérateur égalCA2224: Override equals on overloading operator equals Un type public implémente l'opérateur d'égalité, mais ne se substitue pas à Object.Equals.A public type implements the equality operator but does not override Object.Equals.
CA2225CA2225 CA2225 : Les surcharges d’opérateur ont d’autres méthodes nomméesCA2225: Operator overloads have named alternates 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.An operator overload was detected, and the expected named alternative method was not found. 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.The named alternative member provides access to the same functionality as the operator and is provided for developers who program in languages that do not support overloaded operators.
CA2226CA2226 CA2226 : Les opérateurs doivent avoir des surcharges symétriquesCA2226: Operators should have symmetrical overloads Un type implémente l’opérateur d’égalité ou d’inégalité et n’implémente pas l’opérateur opposé.A type implements the equality or inequality operator and does not implement the opposite operator.
CA2227CA2227 CA2227 : Les propriétés de collection doivent être en lecture seuleCA2227: Collection properties should be read only Une propriété de collection accessible en écriture permet à un utilisateur de remplacer la collection par une collection différente.A writable collection property allows a user to replace the collection with a different collection. 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.A read-only property stops the collection from being replaced but still allows the individual members to be set.
CA2228CA2228 CA2228 : Ne distribuez pas des formats de ressources non commercialisésCA2228: Do not ship unreleased resource formats Les fichiers de ressources générés à l'aide de versions préliminaires du .NET Framework.NET Framework peuvent ne pas être utilisables par les versions prises en charge du .NET Framework.NET Framework.Resource files that were built by using prerelease versions of the .NET Framework.NET Framework might not be usable by supported versions of the .NET Framework.NET Framework.
CA2229CA2229 CA2229 : Implémentez des constructeurs de sérialisationCA2229: Implement serialization constructors Pour corriger une violation de cette règle, implémentez le constructeur de sérialisation.To fix a violation of this rule, implement the serialization constructor. Dans le cas d'une classe sealed, rendez le constructeur privé ; sinon, attribuez-lui l'état protégé.For a sealed class, make the constructor private; otherwise, make it protected.
CA2230CA2230 CA2230 : Utilisez le mot clé params pour les arguments de variablesCA2230: Use params for variable arguments Un type public ou protégé contient une méthode publique ou protégée qui utilise la convention d’appel VarArgs au lieu du mot clé params.A public or protected type contains a public or protected method that uses the VarArgs calling convention instead of the params keyword.
CA2231CA2231 CA2231 : Surchargez l’opérateur égal (equals) en remplaçant ValueType.EqualsCA2231: Overload operator equals on overriding ValueType.Equals Un type valeur se substitue à Object.Equals mais n'implémente pas l'opérateur d'égalité.A value type overrides Object.Equals but does not implement the equality operator.
CA2232CA2232 CA2232 : Marquez les points d’entrée Windows Forms avec STAThreadCA2232: Mark Windows Forms entry points with STAThread STAThreadAttribute indique que le modèle de thread COM pour l'application est un thread cloisonné (STA, Single-Threaded Apartment).STAThreadAttribute indicates that the COM threading model for the application is a single-threaded apartment. Cet attribut doit être présent au point d'entrée de toute application qui utilise des Windows Forms ; s'il est omis, les composants Windows peuvent ne pas fonctionner correctement.This attribute must be present on the entry point of any application that uses Windows Forms; if it is omitted, the Windows components might not work correctly.
CA2233CA2233 CA2233 : Les opérations ne doivent pas provoquer de dépassement de capacitéCA2233: Operations should not overflow Vous ne devez pas exécuter d’opérations arithmétiques sans valider au préalable les opérandes.You should not perform arithmetic operations without first validating the operands. Cela permet de vérifier que le résultat de l'opération ne se trouve pas hors de la plage des valeurs possibles pour les types de données impliqués.This makes sure that the result of the operation is not outside the range of possible values for the data types that are involved.
CA2234CA2234 CA2234 : Passez des objets System.Uri au lieu de chaînesCA2234: Pass System.Uri objects instead of strings 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 ».A call is made to a method that has a string parameter whose name contains "uri", "URI", "urn", "URN", "url", or "URL". Le type déclarant de la méthode contient une surcharge de méthode correspondante qui a un paramètre System.Uri.The declaring type of the method contains a corresponding method overload that has a System.Uri parameter.
CA2235CA2235 CA2235 : Marquez tous les champs non sérialisablesCA2235: Mark all non-serializable fields Un champ d'instance d'un type non sérialisable est déclaré dans un type sérialisable.An instance field of a type that is not serializable is declared in a type that is serializable.
CA2236CA2236 CA2236 : Appelez les méthodes de la classe de base sur les types ISerializableCA2236: Call base class methods on ISerializable types Pour corriger une violation de cette règle, appelez la méthode GetObjectData ou le constructeur de sérialisation du type de base issu du constructeur ou de la méthode du type dérivé correspondant.To fix a violation of this rule, call the base type GetObjectData method or serialization constructor from the corresponding derived type method or constructor.
CA2237CA2237 CA2237 : Marquez les types ISerializable avec SerializableAttributeCA2237: Mark ISerializable types with 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.To be recognized by the common language runtime as serializable, types must be marked by using the SerializableAttribute attribute even when the type uses a custom serialization routine through implementation of the ISerializable interface.
CA2238CA2238 CA2238 : Implémentez les méthodes de sérialisation correctementCA2238: Implement serialization methods correctly Une méthode qui gère un événement de sérialisation n’a pas la signature, le type de retour ou la visibilité appropriée.A method that handles a serialization event does not have the correct signature, return type, or visibility.
CA2239CA2239 CA2239 : Spécifiez des méthodes de désérialisation pour les champs facultatifsCA2239: Provide deserialization methods for optional fields Un type présente un champ marqué avec l’attribut System.Runtime.Serialization.OptionalFieldAttribute et ne fournit aucune méthode de gestion des événements de désérialisation.A type has a field that is marked by using the System.Runtime.Serialization.OptionalFieldAttribute attribute, and the type does not provide deserialization event handling methods.
CA2240CA2240 CA2240 : Implémentez ISerializable correctementCA2240: Implement ISerializable correctly Pour corriger une violation de cette règle, rendez la méthode GetObjectData visible et substituable, et assurez-vous que tous les champs d'instance sont intégrés au processus de sérialisation ou sont marqués explicitement avec l'attribut NonSerializedAttribute.To fix a violation of this rule, make the GetObjectData method visible and overridable, and make sure that all instance fields are included in the serialization process or explicitly marked by using the NonSerializedAttribute attribute.
CA2241CA2241 CA2241 : Fournissez des arguments corrects aux méthodes de mise en formeCA2241: Provide correct arguments to formatting methods 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.The format argument that is passed to System.String.Format does not contain a format item that corresponds to each object argument, or vice versa.
CA2242CA2242 CA2242 : Effectuez correctement des tests NaNCA2242: Test for NaN correctly Cette expression teste une valeur par rapport à Single.Nan ou Double.Nan.This expression tests a value against Single.Nan or Double.Nan. Utilisez Single.IsNan(Single) ou Double.IsNan(Double) pour tester la valeur.Use Single.IsNan(Single) or Double.IsNan(Double) to test the value.
CA2243CA2243 CA2243 : Les littéraux de chaîne d’attribut doivent être analysés correctementCA2243: Attribute string literals should parse correctly 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.The string literal parameter of an attribute does not parse correctly for a URL, a GUID, or a version.
CA5122CA5122 Déclarations ca5122 : P/Invoke ne doivent pas être sécurisées critiqueCA5122 P/Invoke declarations should not be safe critical Les méthodes sont marquées SecuritySafeCritical lorsqu’elles effectuent une opération relative à la sécurité, mais elle peuvent également être utilisées en toute sécurité par du code transparent.Methods are marked as SecuritySafeCritical when they perform a security sensitive operation, but are also safe to be used by transparent code. Le code transparent peut ne jamais appeler directement du code natif via P/Invoke.Transparent code may never directly call native code through a P/Invoke. Par conséquent, marquer une méthode P/Invoke comme critique sécurisé ne permet pas au code transparent de l’appeler et s’avère trompeur pour l’analyse de sécurité.Therefore, marking a P/Invoke as security safe critical will not enable transparent code to call it, and is misleading for security analysis.