Eliminare le violazioni dell'analisi del codice

2025-06-12

Se si collabora con il team durante la creazione del codice, è spesso utile indicare che un avviso non è applicabile. L'eliminazione delle violazioni di analisi del codice indica ai membri del team che il codice è stato esaminato e che l'avviso può essere eliminato. Le sezioni seguenti descrivono i diversi modi per eliminare le violazioni di analisi del codice usando l'IDE di Visual Studio.

Eliminare le violazioni usando il file EditorConfig

Nel file EditorConfig per la soluzione o il progetto aggiungere una voce per ogni regola da configurare e impostarne la gravità su none. Ad esempio: dotnet_diagnostic.CA1822.severity = none. Per altre informazioni, vedere Configurare manualmente la gravità della regola in un file EditorConfig. Per aggiungere un file EditorConfig, vedere Aggiungere un file EditorConfig a un progetto.

Eliminare le violazioni nel codice sorgente

È possibile eliminare le violazioni nel codice sorgente usando una direttiva del preprocessore, che elimina le violazioni per una riga di codice specifica:

C#: avviso #pragma
Visual Basic: Disabilitare l'avviso

In alternativa, è possibile usare l'attributo SuppressMessageAttribute per eliminare un avviso nel codice C# e Visual Basic.

Eliminare le violazioni usando l'editor di codice

Per eliminare le violazioni tramite l'editor di codice, seguire questa procedura:

Posizionare il cursore nella riga di codice con la violazione e premere CTRL+Punto (.) o ALT+INVIO per aprire il menu Azioni rapide .
Selezionare Sopprimere o configurare i problemi>Sopprimi <il numero di regola> e quindi scegliere in Origine o in Origine (attributo).
- Se si sceglie Origine, viene visualizzata un'anteprima della direttiva del preprocessore aggiunta al codice.
- Se si sceglie Origine (attributo), viene visualizzata un'anteprima dell'attributo SuppressMessageAttribute aggiunto al codice.

Eliminare le violazioni usando l'elenco errori

Per eliminare le violazioni tramite la finestra Elenco errori , seguire questa procedura:

Nella finestra Elenco errori selezionare le regole da eliminare.
Fare clic con il pulsante destro del mouse e quindi scegliere Elimina>nell'origine.

Viene visualizzata la finestra di dialogo Anteprima modifiche e viene visualizzata un'anteprima della direttiva di avviso #pragma C# o della direttiva di avviso di Visual Basic #Disable aggiunta al codice sorgente.
Selezionare Applica per salvare le modifiche apportate al file di codice.

Escludere le diagnosi relative alla compilazione dell'elenco errori

Se non viene visualizzata l'opzione di menu Elimina nella finestra Elenco errori , è probabile che la violazione venga eseguita da una compilazione e non da un'analisi in tempo reale. La finestra Elenco errori visualizza la diagnostica o le violazioni delle regole, sia dall'analisi del codice in tempo reale che dalle compilazioni. Poiché la diagnostica della compilazione può essere obsoleta, ad esempio, se è stato modificato il codice per correggere la violazione ma non è stato ricompilato, non è sempre possibile eliminare questi dati di diagnostica dall'elenco errori.

La diagnostica dall'analisi in tempo reale o IntelliSense è sempre up-to-date con le origini correnti e può sempre essere eliminata dall'elenco errori. Per escludere la diagnostica di compilazione dalla selezione, seguire questa procedura:

Nell'elenco a discesa Filtro origine elenco errori modificare la selezione da Compilazione + IntelliSense a Solo IntelliSense.
Selezionare la diagnostica da eliminare e procedere come descritto in precedenza.

Eliminare le violazioni usando un file di eliminazione globale

Il file di eliminazione globale usa l'attributo SuppressMessageAttribute per eliminare le violazioni del codice.

Usare un file di eliminazione globale dall'editor di codice

Per eliminare le violazioni con un file di eliminazione globale usando l'editor di codice, seguire questa procedura:

Nell'editor di codice, posiziona il cursore su una riga di codice con una violazione e premi Ctrl+Period (.) o Alt+Invio per aprire il menu Azioni rapide.
Selezionare Sopprimi <regola numero> e quindi scegliere nel file di soppressione.

Visual Studio crea una scheda nell'editor di codice contenente il nuovo file di eliminazione globale.

Usare un file di eliminazione globale dall'elenco errori

Per eliminare le violazioni con un file di eliminazione globale tramite la finestra Elenco errori , seguire questa procedura:

Nella finestra Elenco errori selezionare le regole da eliminare.
Fare clic con il pulsante destro del mouse e quindi scegliere Elimina>nel file di eliminazione.

Viene visualizzata la finestra di dialogo Anteprima modifiche e viene visualizzata un'anteprima dell'attributo SuppressMessageAttribute aggiunto al file di eliminazione globale.
Selezionare Applica per salvare il file di eliminazione globale.

Eliminare tutte le violazioni correnti

La soppressione di tutte le violazioni correnti viene talvolta definita baselining. Per eliminare tutte le violazioni correnti in una soluzione o in un progetto, seguire questa procedura:

Nella barra dei menu di Visual Studio selezionare Analizza>Compila e elimina problemi attivi.
Selezionare Per la soluzione per eliminare le violazioni per l'intera soluzione oppure selezionare Per <il nome> del progetto per eliminare le violazioni solo per il progetto.

Eliminare le violazioni usando le impostazioni del progetto

Per eliminare le violazioni usando le impostazioni del progetto esplora soluzioni, seguire questa procedura:

In Esplora soluzioni selezionare il progetto.
Fare clic con il pulsante destro del mouse e quindi scegliere Proprietà (o premere ALT + INVIO).
Nella finestra Proprietà, selezionare Analisi codice nel riquadro a sinistra e quindi deselezionare Sopprimere i risultati dal codice generato.

Eliminare le violazioni usando un set di regole

Nell'editor del set di regole deselezionare la casella di controllo accanto al nome o impostare Azione su Nessuno.

Soppressione nel codice sorgente e attributo SuppressMessageAttribute

La soppressione nella sorgente (ISS) usa l'attributo SuppressMessageAttribute per sopprimere un avviso. È possibile aggiungere l'attributo SuppressMessageAttribute al file di origine vicino al segmento di codice che ha generato l'avviso.

È possibile immettere manualmente l'attributo nell'editor di codice oppure aggiungere automaticamente l'attributo come indicato di seguito:

Nell'editor di codice, posiziona il cursore su una riga di codice con una violazione e premi Ctrl+Period (.) o Alt+Invio per aprire il menu Azioni rapide.
Selezionare Elimina o configura problemi>Elimina <il numero> di regola dal menu Azioni rapide.
Completa uno dei seguenti passaggi:
- Selezionare in Origine (attributo).Select in Source (attribute).
  
  Visual Studio aggiunge un SuppressMessageAttribute attributo al codice.
- Selezionare in File di eliminazione.
  
  Visual Studio crea una scheda nell'editor di codice contenente un nuovo file di eliminazione globale con SuppressMessageAttribute attributi.

L'attributo SuppressMessageAttribute è un attributo condizionale, incluso nei metadati dell'assembly di codice gestito. Questo attributo è incluso solo se il CODE_ANALYSIS simbolo di compilazione è definito in fase di compilazione.

Solo nel codice C++ e CLI, usare le macro CA_SUPPRESS_MESSAGE o CA_GLOBAL_SUPPRESS_MESSAGE nel file di intestazione per l'aggiunta dell'attributo.

Se si esegue la migrazione di un progetto alla versione più recente di Visual Studio, è possibile che venga visualizzato un numero elevato di avvisi di analisi del codice. Se non si è pronti per correggere gli avvisi, è possibile sopprimerli selezionando Analizza>Compila e Sopprimi Problemi Attivi.

Annotazioni

Non usare soppressioni nel codice sorgente nelle versioni di rilascio, per impedire la distribuzione accidentale dei metadati di soppressione nel codice sorgente.

Formato dell'attributo SuppressMessageAttribute

L'attributo SuppressMessageAttribute ha il formato seguente:

[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")>

Le proprietà dell'attributo includono:

Category: la categoria della regola. Per altre informazioni sulle categorie di regole di analisi del codice, vedere Regole di qualità del codice.
CheckId: Identificatore della regola. Il supporto include sia un nome breve che un nome lungo per l'identificatore della regola. Il nome breve è CAXXXX. Il nome lungo è CAXXXX:FriendlyTypeName.
Justification: testo utilizzato per documentare il motivo dell'eliminazione del messaggio.
MessageId: identificatore univoco del problema per ogni messaggio.
Scope: la destinazione su cui viene soppresso l'avviso. Se la destinazione non è specificata, il sistema lo imposta sulla destinazione dell'attributo. Gli ambiti supportati includono:
- module: questo ambito elimina gli avvisi per un assembly. Si tratta di un'eliminazione globale che si applica all'intero progetto.
- resource: (solo Legacy FxCop) Questo ambito sopprime gli avvisi nelle informazioni di diagnostica scritte nei file di risorse che fanno parte del modulo (assembly). Questo ambito non viene letto o rispettato nei compilatori C#/VB per la diagnostica dell'analizzatore Roslyn, che analizza solo i file di origine.
- type: questo ambito sopprime gli avvisi contro un tipo.
- member: questo ambito elimina gli avvisi relativi a un membro.
- namespace: questo ambito sopprime gli avvisi sullo spazio dei nomi stesso. Non sopprime gli avvisi sui tipi all'interno dello spazio dei nomi.
- namespaceanddescendants: (richiede la versione del compilatore 3.x o successiva e Visual Studio 2019 o versione successiva) Questo ambito di applicazione elimina gli avvisi in uno spazio dei nomi e tutti i suoi simboli discendenti. L'analisi legacy ignora il valore namespaceanddescendants.
Target: identificatore che specifica la destinazione in cui viene eliminato l'avviso. Deve contenere un nome completamente qualificato del componente.

Quando vengono visualizzati avvisi in Visual Studio, è possibile visualizzare esempi di SuppressMessageAttributeaggiungendo un'eliminazione al file di eliminazione globale. L'attributo di eliminazione e le relative proprietà necessarie vengono visualizzati in una finestra di anteprima.

Utilizzo di SuppressMessageAttribute

Gli avvisi di analisi del codice vengono eliminati a livello a cui viene applicato l'attributo SuppressMessageAttribute . Ad esempio, l'attributo può essere applicato a livello di assembly, modulo, tipo, membro o parametro. Lo scopo dell'applicazione di questo attributo è accoppiare strettamente le informazioni di eliminazione al codice in cui si verifica la violazione.

La forma generale di eliminazione include la categoria di regole e un identificatore di regola, che contiene una rappresentazione facoltativa leggibile del nome della regola. Per esempio:

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

Se esistono motivi di prestazioni rigorosi per ridurre al minimo i metadati di eliminazione nell'origine, è possibile omettere il nome della regola. La categoria di regole e il relativo ID regola formano un identificatore di regola sufficientemente univoco. Per esempio:

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

Per motivi di manutenibilità, non è consigliabile omettere il nome della regola.

Eliminare le violazioni selettive all'interno di un corpo del metodo

Gli attributi di eliminazione possono essere applicati a un metodo, ma non possono essere incorporati all'interno di un corpo del metodo. Tutte le violazioni di una determinata regola vengono eliminate se si aggiunge l'attributo SuppressMessageAttribute al metodo .

In alcuni casi, è possibile sopprimere una particolare istanza della violazione. Si consideri l'esempio in cui il codice futuro non è automaticamente esente dalla regola di analisi del codice. Alcune regole di analisi del codice consentono di eliminare una determinata istanza della violazione usando la MessageId proprietà dell'attributo SuppressMessageAttribute . In generale, le regole legacy per le violazioni di un particolare simbolo (una variabile o un parametro locale) rispettano la proprietà MessageId. CA1500:VariableNamesShouldNotMatchFieldNames è un esempio di tale regola. Tuttavia, le regole legacy per le violazioni nel codice eseguibile (non simbolo) non rispettano la MessageId proprietà . Inoltre, gli analizzatori .NET Compiler Platform ("Roslyn") non rispettano la MessageId proprietà .

Per eliminare una particolare violazione del simbolo di una regola, specificare il nome del simbolo per la MessageId proprietà dell'attributo SuppressMessageAttribute . L'esempio seguente mostra il codice con due violazioni di CA1500:VariableNamesShouldNotMatchFieldNames: una violazione per la name variabile e un'altra violazione per la age variabile. Solo la violazione per il simbolo age è soppressa.

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

Eliminazioni a livello globale

Lo strumento di analisi del codice gestito esamina gli SuppressMessageAttribute attributi applicati a livello di assembly, modulo, tipo, membro o parametro. Invia anche violazioni riguardanti risorse e namespace. Queste violazioni devono essere applicate a livello globale e hanno come ambito e destinazione. Ad esempio, il messaggio seguente elimina una violazione dello spazio dei nomi:

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

Per le soppressioni a livello globale

Quando si sopprime un avviso con un ambito namespace, l'avviso viene soppresso dallo spazio dei nomi stesso. Non sopprime l'avviso per i tipi all'interno dello spazio dei nomi.
Target contiene sempre il nome completo dell'elemento.
Qualsiasi eliminazione può essere espressa specificando un ambito esplicito. Queste soppressioni devono esistere a livello globale. Non è possibile specificare l'eliminazione a livello di membro modificando un tipo.
Le eliminazioni a livello globale sono l'unico modo per eliminare i messaggi che fanno riferimento al codice generato dal compilatore che non esegue il mapping all'origine utente fornita in modo esplicito. Ad esempio, il codice seguente elimina una violazione rispetto a un costruttore generato dal compilatore:

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

File di soppressione globale

Il file di eliminazione globale mantiene eliminazioni che sono eliminazioni a livello globale o eliminazioni che non specificano una destinazione. Ad esempio, le eliminazioni per le violazioni a livello di assembly vengono archiviate in questo file. Inoltre, alcune soppressioni ASP.NET vengono archiviate in questo file perché le impostazioni a livello di progetto non sono disponibili per il codice dietro un modulo. Visual Studio crea e aggiunge un file di soppressione globale al progetto la prima volta che si seleziona l'opzione File di soppressione nel progetto del comando Soppressione nella finestra dell'Elenco errori.

Ambito di eliminazione del modulo

È possibile eliminare le violazioni della qualità del codice per l'intero assembly usando l'ambito module .

Ad esempio, l'attributo seguente nel file di progetto GlobalSuppressions elimina la violazione ConfigureAwait per un progetto 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")]

Codice generato

I compilatori di codice gestito e alcuni strumenti esterni generano codice per facilitare lo sviluppo rapido del codice. Il codice generato dal compilatore visualizzato nei file di origine è contrassegnato con l'attributo GeneratedCodeAttribute .

Per l'analisi del codice sorgente, è possibile eliminare i messaggi nel codice generato in un file con estensione editorconfig . Per altre informazioni, vedere Escludere il codice generato.

Per l'analisi del codice legacy, è possibile scegliere se eliminare gli avvisi e gli errori di analisi del codice per il codice generato. Per informazioni su come eliminare tali avvisi ed errori, vedere Eliminare gli avvisi di analisi del codice per il codice generato.