Rimuovere le violazioni dell'analisi del codice

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:

1. Posizionare il cursore nella riga di codice con la violazione e premere CTRL+Punto (.) o ALT+INVIO per aprire il menu Azioni rapide.

2. Selezionare Elimina o configura i problemi>Elimina <il numero> di regola e quindi scegliere Origine o 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:

1. Nella finestra Elenco errori selezionare le regole da eliminare.

2. 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.

   

3. Selezionare Applica per salvare le modifiche apportate al file di codice.

Escludere la diagnostica della compilazione 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 aggiornata con le origini correnti e può sempre essere eliminata dall'elenco errori. Per escludere la diagnostica di compilazione dalla selezione, seguire questa procedura:

1. Nell'elenco a discesa Filtro origine elenco errori modificare la selezione da Compilazione + IntelliSense a Solo IntelliSense.

   

2. 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:

1. Nell'editor di codice posizionare il cursore su una riga di codice con una violazione e premere CTRL+PUNTO (.) o ALT+INVIO per aprire il menu Azioni rapide.

2. Selezionare Elimina <numero> di regola e quindi scegliere In File di eliminazione.

   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:

1. Nella finestra Elenco errori selezionare le regole da eliminare.

2. 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.

   

3. Selezionare Applica per salvare il file di eliminazione globale.

Eliminare tutte le violazioni correnti

L'eliminazione di tutte le violazioni correnti viene talvolta definita base. Per eliminare tutte le violazioni correnti in una soluzione o in un progetto, seguire questa procedura:

1. Nella barra dei menu di Visual Studio selezionare Analizza compilazione>e Elimina problemi attivi.

2. 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 Esplora soluzioni impostazioni del progetto, seguire questa procedura:

1. In Esplora soluzioni selezionare il progetto.

2. Fare clic con il pulsante destro del mouse e quindi scegliere Proprietà (o premere ALT + INVIO).

3. Nella finestra Proprietà selezionare Analisi codice nel riquadro sinistro e quindi deselezionare Elimina i risultati dal codice generato.

Eliminazione nell'origine e attributo SuppressMessageAttribute

L'eliminazione nell'origine (ISS) usa l'attributo SuppressMessageAttribute per eliminare 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:

1. Nell'editor di codice posizionare il cursore su una riga di codice con una violazione e premere CTRL+PUNTO (.) o ALT+INVIO per aprire il menu Azioni rapide.

2. Selezionare Elimina o configura problemi>Elimina <il numero> di regola dal menu Azioni rapide.

3. 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 dell'interfaccia della riga di comando usare le macro CA_SUPPRESS_MESSAGE o CA_GLOBAL_SUPPRESS_MESSAGE nel file di intestazione per aggiungere l'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 eliminarli selezionando Analizza compilazione>e Elimina problemi attivi.

Formato 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: 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: destinazione in cui viene eliminato 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 FxCop legacy) Questo ambito elimina 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 elimina gli avvisi per un tipo.

  • member: questo ambito elimina gli avvisi relativi a un membro.

  • namespace: questo ambito elimina gli avvisi sullo spazio dei nomi stesso. Non elimina 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 elimina gli avvisi in uno spazio dei nomi e tutti i relativi simboli discendenti. L'analisi legacy ignora il namespaceanddescendants valore.

• Target: identificatore che specifica la destinazione in cui viene eliminato l'avviso. Deve contenere un nome completo del componente.

Quando vengono visualizzati avvisi in Visual Studio, è possibile visualizzare esempi di SuppressMessageAttribute aggiungendo 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. Ad 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. Ad 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 eliminare 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 in un particolare simbolo (una variabile o un parametro locale) rispettano la MessageId proprietà . 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. Viene eliminata solo la violazione per il age simbolo.

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 contro le risorse e gli spazi dei nomi. 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 eliminazioni a livello globale:

• Quando si elimina un avviso con un namespace ambito, l'avviso viene eliminato dallo spazio dei nomi stesso. Non elimina 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 eliminazioni devono vivere 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 eliminazione 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 eliminazioni ASP.NET vengono archiviate in questo file perché le impostazioni a livello di progetto non sono disponibili per il code-behind di un modulo. Visual Studio crea e aggiunge un file di eliminazione globale al progetto la prima volta che si seleziona l'opzione In Project Suppress File (File eliminazione progetto) del comando Suppress (Elimina ) nella finestra 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.

Contenuto correlato

• Scope
• System.Diagnostics.CodeAnalysis
• Personalizzare le regole dell'analizzatore Roslyn