Supprimer les violations d’analyse du code

2025-06-12

Si vous collaborez avec votre équipe lorsque vous créez du code, il est souvent utile d’indiquer qu’un avertissement n’est pas applicable. La suppression des violations d’analyse du code indique aux membres de l’équipe que le code a été examiné et que l’avertissement peut être supprimé. Les sections suivantes décrivent les différentes façons de supprimer les violations d’analyse du code à l’aide de l’IDE Visual Studio.

Supprimer les violations à l’aide du fichier EditorConfig

Dans le fichier EditorConfig de votre solution ou projet, ajoutez une entrée pour chaque règle à configurer et définissez son niveau de gravité à none. Par exemple : dotnet_diagnostic.CA1822.severity = none. Pour plus d’informations, consultez Configurer manuellement la gravité des règles dans un fichier EditorConfig. Pour ajouter un fichier EditorConfig, consultez Ajouter un fichier EditorConfig à un projet.

Supprimer les violations dans le code source

Vous pouvez supprimer les violations dans votre code source à l’aide d’une directive de préprocesseur, qui supprime les violations pour une ligne de code spécifique :

C# : avertissement #pragma
Visual Basic : Désactiver l’avertissement

Vous pouvez également utiliser l’attribut SuppressMessageAttribute pour supprimer un avertissement dans votre code C# et Visual Basic.

Supprimer les violations à l’aide de l’éditeur de code

Pour supprimer les violations à l’aide de l’éditeur de code, procédez comme suit :

Placez le curseur dans la ligne de code avec la violation et appuyez sur Ctrl+point (.) ou Alt+Entrée pour ouvrir le Menu Actions Rapides.
Sélectionnez Supprimer ou configurer les problèmes>Supprimer <le numéro de règle>, puis choisissez dans Source ou dans Source (attribut).
- Si vous choisissez dans Source, vous voyez un aperçu de la directive de préprocesseur ajoutée à votre code.
- Si vous choisissez dans Source (attribut), vous voyez un aperçu de l’attribut SuppressMessageAttribute ajouté à votre code.

Supprimer les violations à l’aide de la liste d’erreurs

Pour supprimer les violations à l’aide de la fenêtre Liste d’erreurs , procédez comme suit :

Dans la fenêtre Liste d’erreurs , sélectionnez les règles à supprimer.
Cliquez avec le bouton droit, puis sélectionnez Supprimer>dans la source.

La boîte de dialogue Aperçu des modifications s’ouvre et affiche un aperçu de la directive d’avertissement C# #pragma ou de la directive d’avertissement Visual Basic #Disable ajoutée au code source.
Sélectionnez Appliquer pour enregistrer les modifications apportées à votre fichier de code.

Exclure les diagnostics de compilation de l'Error List

Si vous ne voyez pas l’option Supprimer le menu dans la fenêtre Liste d’erreurs , la violation provient probablement d’une build et non d’une analyse dynamique. La fenêtre Liste d’erreurs affiche des diagnostics ou des violations de règles, à partir de l’analyse du code en direct et des builds. Étant donné que les diagnostics de build peuvent être obsolètes, par exemple, si vous avez modifié le code pour corriger la violation, mais que vous ne l’avez pas régénéré, vous ne pouvez pas toujours supprimer ces diagnostics de la liste d’erreurs.

Les diagnostics de l’analyse dynamique ou IntelliSense sont toujours up-to-date avec les sources actuelles et peuvent toujours être supprimés de la liste d’erreurs. Pour exclure les diagnostics de génération de votre sélection, procédez comme suit :

Dans la liste déroulante du filtre source de la liste d’erreurs, changez la sélection de Build + IntelliSense à IntelliSense uniquement.
Sélectionnez les diagnostics que vous souhaitez supprimer et continuer comme décrit précédemment.

Supprimer les violations à l’aide d’un fichier de suppression global

Le fichier de suppression global utilise l’attribut SuppressMessageAttribute pour supprimer les violations de code.

Utiliser un fichier de suppression global de l’éditeur de code

Pour supprimer les violations avec un fichier de suppression global à l’aide de l’éditeur de code, procédez comme suit :

Dans l’éditeur de code, placez le curseur sur une ligne de code avec une violation, puis appuyez sur Ctrl+Point (.) ou Alt+Entrée pour ouvrir le menu Actions rapides .
Sélectionnez Supprimer <numéro de règle>, puis choisissez dans Fichier de suppression.

Visual Studio crée un onglet dans l’éditeur de code contenant le nouveau fichier de suppression global.

Utiliser un fichier de suppression global de la liste d’erreurs

Pour supprimer les violations avec un fichier de suppression global à l’aide de la fenêtre Liste d’erreurs , procédez comme suit :

Dans la fenêtre Liste d’erreurs , sélectionnez les règles à supprimer.
Cliquez avec le bouton droit, puis sélectionnez Supprimer>dans le fichier de suppression.

La boîte de dialogue Aperçu des modifications s’ouvre et affiche un aperçu de l’attribut SuppressMessageAttribute ajouté au fichier de suppression global.
Sélectionnez Appliquer pour enregistrer le fichier de suppression globale.

Supprimer toutes les violations actuelles

La suppression de toutes les violations actuelles est parfois appelée établissement d'une référence. Pour supprimer toutes les violations actuelles dans une solution ou un projet, procédez comme suit :

Dans la barre de menus de Visual Studio, sélectionnez Analyser>Compiler et masquer les problèmes actifs.
Sélectionnez Pour la solution pour supprimer les violations pour l’ensemble de la solution, ou sélectionnez Pour <le nom> du projet pour supprimer uniquement les violations pour votre projet.

Supprimer les violations à l’aide des paramètres du projet

Pour supprimer les violations à l’aide des paramètres de projet de l’Explorateur de solutions, procédez comme suit :

Dans l’Explorateur de solutions, sélectionnez votre projet.
Cliquez avec le bouton droit, puis sélectionnez Propriétés (ou appuyez sur Alt + Entrée).
Dans la fenêtre Propriétés , sélectionnez Analyse du code dans le volet gauche, puis désactivez supprimer les résultats du code généré.

Supprimer les violations à l’aide d’un ensemble de règles

Dans l’éditeur du jeu de règles, décochez la case à côté de son nom ou réglez Action sur Aucun.

Suppression dans le code source et attribut SuppressMessageAttribute

La suppression in-source (ISS) utilise l’attribut SuppressMessageAttribute pour supprimer un avertissement. Vous pouvez ajouter l’attribut SuppressMessageAttribute au fichier source près du segment de code qui a généré l’avertissement.

Vous pouvez entrer l’attribut manuellement dans l’éditeur de code ou ajouter automatiquement l’attribut comme suit :

Dans l’éditeur de code, placez le curseur sur une ligne de code avec une violation, puis appuyez sur Ctrl+Point (.) ou Alt+Entrée pour ouvrir le menu Actions rapides .
Sélectionnez Supprimer ou configurer les problèmes>Supprimer le <numéro de règle> dans le menu Actions rapides.
Effectuez l’une des étapes suivantes :
- Sélectionnez dans Source (attribut).
  
  Visual Studio ajoute un SuppressMessageAttribute attribut à votre code.
- Sélectionnez dans le fichier de suppression.
  
  Visual Studio crée un onglet dans l’éditeur de code contenant un nouveau fichier de suppression global avec SuppressMessageAttribute des attributs.

L’attribut SuppressMessageAttribute est un attribut conditionnel, qui est inclus dans les métadonnées de votre assembly de code managé. Cet attribut est inclus uniquement si le symbole de compilation est défini au moment de la CODE_ANALYSIS compilation.

Dans le code C++ et CLI uniquement, utilisez les macros CA_SUPPRESS_MESSAGE ou CA_GLOBAL_SUPPRESS_MESSAGE dans le fichier d’en-tête pour ajouter l’attribut.

Si vous migrez un projet vers la dernière version de Visual Studio, vous pouvez voir un grand nombre d’avertissements d’analyse du code. Si vous n’êtes pas prêt à corriger les avertissements, vous pouvez les supprimer tous en sélectionnant Analyser>Construire et supprimer les problèmes actifs.

Remarque

N’utilisez pas de suppressions dans le code source sur les versions de production pour empêcher l’expédition accidentelle des métadonnées de suppression.

Format d’attribut SuppressMessageAttribute

L’attribut SuppressMessageAttribute a le format suivant :

[Scope:SuppressMessage("Rule Category", "Rule Id", Justification = "Justification", MessageId = "MessageId", Scope = "Scope", Target = "Target")]

<Scope:SuppressMessage("Rule Category", "Rule Id", Justification = "Justification", MessageId = "MessageId", Scope = "Scope", Target = "Target")>

Les propriétés de l’attribut sont les suivantes :

Category: La catégorie de la règle. Pour plus d’informations sur les catégories de règles d’analyse du code, consultez Règles de qualité du code.
CheckId: Identificateur de la règle. Le support comprend un nom court et un nom long pour l’identificateur de règle. Le nom court est CAXXXX; le nom long est CAXXXX:FriendlyTypeName.
Justification: texte utilisé pour documenter la raison de la suppression du message.
MessageId: identificateur unique du problème pour chaque message.
Scope: cible sur laquelle l’avertissement est supprimé. Si la cible n’est pas spécifiée, le système la définit à celle de l’attribut. Les périmètres pris en charge incluent :
- module: Cette étendue supprime les avertissements d’un assemblage. Il s’agit d’une suppression globale qui s’applique à l’ensemble du projet.
- resource : (FxCop hérité uniquement) Cette portée supprime les avertissements liés aux informations de diagnostic consignées dans les fichiers de ressources qui font partie du module (assembly). Cette étendue n’est pas lue ou respectée dans les compilateurs C#/VB pour les diagnostics d’analyseur Roslyn, qui analysent uniquement les fichiers sources.
- type: cette portée supprime les avertissements concernant un type.
- member: cette étendue supprime les avertissements contre un membre.
- namespace: cette étendue supprime les avertissements par rapport à l’espace de noms lui-même. Il ne supprime pas les avertissements concernant les types au sein de l’espace de noms.
- namespaceanddescendants: (Nécessite la version 3.x ou ultérieure du compilateur et Visual Studio 2019 ou version ultérieure) Cette étendue supprime les avertissements dans un espace de noms et tous ses symboles descendants. L’analyse héritée ignore la valeur namespaceanddescendants.
Target: identificateur qui spécifie la cible sur laquelle l’avertissement est supprimé. Il doit contenir un nom de composant complet.

Lorsque vous voyez des avertissements dans Visual Studio, vous pouvez afficher des exemples d’ajout SuppressMessageAttributed’une suppression au fichier de suppression global. L’attribut de suppression et ses propriétés requises apparaissent dans une fenêtre d’aperçu.

Utilisation de SuppressMessageAttribute

Les avertissements d’analyse du code sont supprimés au niveau auquel l’attribut SuppressMessageAttribute est appliqué. Par exemple, l’attribut peut être appliqué au niveau de l’assembly, du module, du type, du membre ou du paramètre. L’objectif de l’application de cet attribut est de coupler étroitement les informations de suppression au code où la violation se produit.

La forme générale de suppression inclut la catégorie de règle et un identificateur de règle, qui contient une représentation facultative lisible par l’homme du nom de la règle. Par exemple:

[SuppressMessage("Microsoft.Design", "CA1039:ListsAreStrongTyped")]

S’il existe des raisons de performances strictes pour réduire les métadonnées de suppression dans la source, le nom de la règle peut être omis. La catégorie de règle et son ID de règle forment ensemble un identificateur de règle suffisamment unique. Par exemple:

[SuppressMessage("Microsoft.Design", "CA1039")]

Pour des raisons de maintenance, omettre le nom de la règle n’est pas recommandé.

Supprimer les violations sélectives au sein d’un corps de méthode

Les attributs de suppression peuvent être appliqués à une méthode, mais ne peuvent pas être incorporés dans un corps de méthode. Toutes les violations d’une règle particulière sont supprimées si vous ajoutez l’attribut SuppressMessageAttribute à la méthode.

Dans certains cas, vous pouvez supprimer une instance particulière de la violation. Prenons l’exemple où le code futur n’est pas automatiquement exempté de la règle d’analyse du code. Certaines règles d’analyse du code vous permettent de supprimer une instance particulière de la violation à l’aide de la MessageId propriété de l’attribut SuppressMessageAttribute . En général, les règles héritées pour les violations sur un symbole particulier (variable ou paramètre local) respectent la MessageId propriété. CA1500 :VariableNamesShouldNotMatchFieldNames est un exemple de règle de ce type. Toutefois, les règles héritées pour les violations sur le code exécutable (non symbole) ne respectent pas la MessageId propriété. En outre, les analyseurs de la plateforme du compilateur .NET (« Roslyn ») ne respectent pas la MessageId propriété.

Pour supprimer une violation de symbole particulière d’une règle, spécifiez le nom du symbole pour la MessageId propriété de l’attribut SuppressMessageAttribute . L’exemple suivant montre le code avec deux violations de CA1500 :VariableNamesShouldNotMatchFieldNames : une violation pour la name variable et une autre violation pour la age variable. Seule la violation du age symbole est supprimée.

public class Animal
{
    int age;
    string name;

    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Maintainability", "CA1500:VariableNamesShouldNotMatchFieldNames", MessageId = "age")]
    private void PrintInfo()
    {
        int age = 5;
        string name = "Charlie";

        Console.WriteLine($"Age {age}, Name {name}");
    }
}

Public Class Animal
    Dim age As Integer
    Dim name As String

    <CodeAnalysis.SuppressMessage("Microsoft.Maintainability", "CA1500:VariableNamesShouldNotMatchFieldNames", MessageId:="age")>
    Sub PrintInfo()
        Dim age As Integer = 5
        Dim name As String = "Charlie"

        Console.WriteLine("Age {0}, Name {1}", age, name)
    End Sub

End Class

Suppressions au niveau global

L’outil d’analyse du code managé examine les SuppressMessageAttribute attributs appliqués au niveau de l’assembly, du module, du type, du membre ou du paramètre. Il soumet également des infractions concernant les ressources et les espaces de noms. Ces violations doivent être appliquées au niveau mondial et sont ciblées. Par exemple, le message suivant supprime une violation d’espace de noms :

[module: SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace", Target = "MyNamespace")]

Pour les suppressions au niveau global :

Lorsque vous masquez un avertissement avec une namespace portée, cela masque l’avertissement par rapport à l’espace de noms lui-même. Il ne supprime pas l’avertissement contre les types dans l’espace de noms.
Target contient toujours le nom qualifié complet de l’élément.
Toute suppression peut être exprimée en spécifiant une étendue explicite. Ces suppressions doivent être appliquées au niveau mondial. Vous ne pouvez pas spécifier de suppression au niveau membre en modifiant un type.
Les suppressions au niveau global sont la seule façon de supprimer les messages qui font référence au code généré par le compilateur qui ne mappe pas à la source utilisateur fournie explicitement. Par exemple, le code suivant supprime une violation contre un constructeur émis par le compilateur :

[module: SuppressMessage("Microsoft.Design", "CA1055:AbstractTypesDoNotHavePublicConstructors", Scope="member", Target="Microsoft.Tools.FxCop.Type..ctor()")]

Fichier de suppression globale

Le fichier de suppression globale gère les suppressions qui sont des suppressions de niveau global ou des suppressions qui ne spécifient pas de cible. Par exemple, les suppressions pour les violations au niveau de l'assemblage sont stockées dans ce fichier. En outre, certaines suppressions de ASP.NET sont stockées dans ce fichier, car les paramètres au niveau du projet ne sont pas disponibles pour le code derrière un formulaire. Visual Studio crée et ajoute un fichier de suppression global à votre projet la première fois que vous sélectionnez l’option Fichier de suppression de projet de la commande Supprimer dans la fenêtre Liste d’erreurs .

Étendue de suppression de module

Vous pouvez supprimer les violations de qualité du code pour l’ensemble de l’assemblage à l’aide du champ module.

Par exemple, l’attribut suivant dans votre fichier projet GlobalSuppressions supprime la violation ConfigureAwait pour un projet ASP.NET Core :

[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Reliability", "CA2007:Consider calling ConfigureAwait on the awaited task", Justification = "ASP.NET Core doesn't use thread context to store request context.", Scope = "module")]

Code généré

Les compilateurs de code managé et certains outils externes génèrent du code pour faciliter le développement rapide du code. Le code généré par le compilateur qui apparaît dans les fichiers sources est marqué avec l’attribut GeneratedCodeAttribute .

Pour l’analyse du code source, vous pouvez supprimer les messages dans le code généré dans un fichier .editorconfig . Pour plus d’informations, consultez Exclure le code généré.

Pour l’analyse du code hérité, vous pouvez choisir de supprimer les avertissements et erreurs d’analyse du code généré. Pour plus d’informations sur la suppression de ces avertissements et erreurs, consultez Supprimer les avertissements d’analyse du code pour le code généré.