Azioni rapide comuni

Le sezioni di questo argomento presentano alcune delle azioni rapide comuni applicabili sia a codice C# che a codice Visual Basic. Queste azioni sono correzioni del codice per la diagnostica del compilatore o per gli analizzatori .NET Compiler Platform predefiniti di Visual Studio.

Azioni per risolvere errori

Le Azioni rapide in questa sezione consentono di correggere gli errori nel codice che impedirebbero la compilazione. Se sono disponibili Azioni rapide per correggere un errore in una riga di codice, l'icona visualizzata nel margine o sotto la sottolineatura ondulata rossa è una lampadina con una "x" rossa.

Correggere errori di ortografia in simboli o parole chiave

Se si digita accidentalmente un tipo o una parola chiave con errori di ortografia in Visual Studio, questa azione rapida consente di correggerlo automaticamente. Questi elementi verranno visualizzati nel menu lampadina come "Cambia< parola> con errori di ortografia" in "<parola> corretta". Ad esempio:

C#

// Before
private viod MyMethod()
{
}

// Change 'viod' to 'void'

// After
private void MyMethod()
{
}

VB

' Before
Function MyFunction as Intger
End Function

' Change 'Intger' to 'Integer'

' After
Function MyFunction as Integer
End Function

ID errore	Linguaggi applicabili
CS0103, BC30002	C# r Visual Basic

Risolvere i conflitti di unione Git

Queste azioni rapide consentono di risolvere conflitti di unione Git apportando una modifica che rimuove i marcatori e il codice in conflitto.

// Before
private void MyMethod()
{
    if (false)
    {

    }
}

// Take changes from 'HEAD'

// After
private void MyMethod()
{
    if (true)
    {

    }
}

ID errore	Linguaggi applicabili	Versione supportata
CS8300, BC37284	C# r Visual Basic	Visual Studio 2017 versione 15.3 e successive

Azioni per la rimozione di codice non necessario

Rimuovere istruzioni using/Imports non necessarie

L'azione rapida Remove Unnecessary Usings/Imports rimuove tutte le direttive e Import inutilizzate using per il file corrente. Quando si seleziona questo elemento, le istruzioni Imports di spazi dei nomi inutilizzate vengono rimosse.

Rimuovere un cast non necessario

Se si esegue il cast di un tipo a un altro tipo che non richiede un cast, l'azione rapida Rimuovi cast non necessario rimuove il cast non necessario.

C#

// before
int number = (int)3;

// Remove Unnecessary Cast

// after
int number = 3;

VB

' Before
Dim number as Integer = CType(3, Integer)

' Remove Unnecessary Cast

' After
Dim number as Integer = 3

Rimuovi variabili non usate

Questa azione rapida consente di rimuovere le variabili dichiarate che non sono mai state usate nel codice.

// Before
public MyMethod()
{
    var unused = 8;
    var used = 1;
    return DoStuff(used);
}

// Remove unused variables

// After
public MyMethod()
{
    var used = 1;
    return DoStuff(used);
}

ID di diagnostica	Linguaggi applicabili	Versione supportata
CS0219, BC42024	C# r Visual Basic	Visual Studio 2017 versione 15.3 e successive

Rimuovere il tipo dall'espressione con valore predefinito

Questa azione rapida rimuove il tipo valore da un'espressione con valore predefinito e usa il valore letterale predefinito quando il compilatore può dedurre il tipo dell'espressione.

// Before
void DoWork(CancellationToken cancellationToken = default(CancellationToken)) { ... }

// Simplify default expression

// After
void DoWork(CancellationToken cancellationToken = default) { ... }

ID di diagnostica	Linguaggi applicabili	Versione supportata
IDE0034	C# 7.1+	Visual Studio 2017 versione 15.3 e successive

Azioni per l'aggiunta di codice mancante

Aggiungere istruzioni using o import per i tipi in assembly di riferimento, pacchetti NuGet o altri tipi nella soluzione

L'uso di tipi che si trovano in altri progetti nella soluzione visualizzerà automaticamente l'azione rapida, ma gli altri devono essere abilitati dalla scheda Strumenti > Opzioni > editor > di testo C# o Visual Basic > Advanced :

• Suggerisci le direttive using/import per i tipi in assembly di riferimento
• Suggerisci le direttive using/import per i tipi in pacchetti NuGet

Se abilitato, se si usa un tipo in uno spazio dei nomi attualmente non importato ma presente in un assembly di riferimento o in un pacchetto NuGet, viene creata la direttiva using o import.

C#

// Before
Debug.WriteLine("Hello");

// using System.Diagnostics;

// After
using System.Diagnostics;

Debug.WriteLine("Hello");

VB

' Before
Debug.WriteLine("Hello")

' Imports System.Diagnostics

' After
Imports System.Diagnostics

Debug.WriteLine("Hello")

ID di diagnostica	Linguaggi applicabili
CS0103, BC30451	C# r Visual Basic

Aggiungere elementi case mancanti, un'istruzione case predefinita o entrambi

Quando si crea un'istruzione switch in C# o un'istruzione Select Case in Visual Basic, è possibile usare un'azione codice per aggiungere automaticamente elementi case mancanti, un'istruzione case predefinita o entrambi.

Si consideri la seguente enumerazione e l'istruzione switch o Select Case vuota:

C#

enum MyEnum
{
    Item1,
    Item2,
    Item3
}

...

MyEnum myEnum = MyEnum.Item1;

switch(myEnum)
{
}

VB

Enum MyEnum
    Item1
    Item2
    Item3
End Enum

...

Dim myEnum as MyEnum = MyEnum.Item1

Select Case myEnum
End Select

L'azione rapida Aggiungi entrambi compila i case mancanti e aggiunge un case predefinito:

C#

switch(myEnum)
{
    case MyEnum.Item1:
        break;
    case MyEnum.Item2:
        break;
    case MyEnum.Item3:
        break;
    default:
        break;
}

VB

Select Case myEnum
    Case MyEnum.Item1
        Exit Select
    Case MyEnum.Item2
        Exit Select
    Case Else
        Exit Select
End Select

ID di diagnostica	Linguaggi applicabili	Versione supportata
IDE0010	C# r Visual Basic	Visual Studio 2017 versione 15.3 e successive

Aggiungere controlli null per i parametri

Questa azione rapida consente di aggiungere un controllo nel codice per indicare se un parametro è null.

// Before
class MyClass
{
    public string MyProperty { get; set; }

    public MyClass(string myProperty) // cursor inside myProperty
    {
        MyProperty = myProperty;
    }
}

// Add null check

// After
class MyClass
{
    public string MyProperty { get; set; }

    public MyClass(string myProperty)
    {
        MyProperty = myProperty ?? throw new ArgumentNullException(nameof(myProperty));
    }
}

Linguaggi applicabili	Versione supportata
C# r Visual Basic	Visual Studio 2017 versione 15.3 e successive

Aggiungi il nome di argomento

// Before
var date = new DateTime(1997, 7, 8);

// Include argument name 'year' (include trailing arguments)

// After
var date = new DateTime(year: 1997, month: 7, day: 8);

Linguaggi applicabili	Versione supportata
C# r Visual Basic	Visual Studio 2017 versione 15.3 e successive

Aggiungi parentesi graffe

L'azione rapida Aggiungi parentesi graffe racchiude tra parentesi graffe le istruzioni if a riga singola.

// Before
if (true)
    return "hello,world";

// Add braces

// After
if (true)
{
    return "hello,world";
}

ID di diagnostica	Linguaggi applicabili	Versione supportata
IDE0011	C#	Visual Studio 2017 e versioni successive

Aggiungi i modificatori e Ordina i modificatori

Queste azioni rapide consentono di organizzare i modificatori grazie alla possibilità di ordinare i modificatori di accessibilità esistenti e di aggiungere quelli mancanti.

// Before
enum Color
{
    Red, White, Blue
}

// Add accessibility modifiers

// After
internal enum Color
{
    Red, White, Blue
}

// Before
static private int thisFieldIsPublic;

// Order modifiers

// After
private static int thisFieldIsPublic;

ID di diagnostica	Linguaggi applicabili	Versione supportata
IDE0036	C# r Visual Basic	Visual Studio 2017 versione 15.5 e successive
IDE0040	C# r Visual Basic	Visual Studio 2017 versione 15.5 e successive

Trasformazioni del codice

Convertire il costrutto "if" in "switch"

Questa azione rapida consente di convertire un costrutto if-then-else in un costrutto switch.

C#

// Before
if (obj is string s)
{
  Console.WriteLine("obj is a string: " + s);
}

else if (obj is int i && i > 10)
{
  Console.WriteLine("obj is an int greater than 10");
}

// Convert to switch

// After
switch (obj)
{
  case string s:
    Console.WriteLine("Obj is a string: " + s);
    break;
  case int i when i > 10:
    Console.WriteLine("obj is an int greater than 10");
    break;
}

VB

' Before
If TypeOf obj Is String s Then
    Console.WriteLine("obj is a string: " + s)
Else If TypeOf obj Is Integer i And i > 10 Then
    Console.WriteLine("obj is an int greater than 10")
End If

' Convert to switch

' After
Select Case obj
  Case String s
    Console.WriteLine("Obj is a string: " + s)
    Exit Sub
  Case Integer i when i > 10
    Console.WriteLine("obj is an int greater than 10")
    Exit Sub
End Select

Linguaggi applicabili	Versione supportata
C# r Visual Basic	Visual Studio 2017 versione 15.3 e successive

Convertire in una stringa interpolata

Le stringhe interpolate rappresentano un modo semplice, simile al metodo String.Format, per esprimere stringhe con variabili incorporate. Questa azione rapida riconosce i casi in cui le stringhe sono concatenate o usano String.Format e ne modifica l'utilizzo in quello di una stringa interpolata.

C#

// Before
int num = 3;
string s = string.Format("My string with {0} in the middle", num);

// Convert to interpolated string

// After
int num = 3;
string s = $"My string with {num} in the middle";

VB

' Before
Dim num as Integer = 3
Dim s as String = String.Format("My string with {0} in the middle", num)

' Convert to interpolated string

' After
Dim num as Integer = 3
Dim s As String = $"My string with {num} in the middle"

Linguaggi applicabili	Versione supportata
C# 6.0+ e Visual Basic 14+	Visual Studio 2017 e versioni successive

Usare gli inizializzatori di oggetto

Questa azione rapida permette di usare inizializzatori di oggetto invece di richiamare il costruttore e introdurre righe aggiuntive di istruzioni di assegnazione.

C#

// Before
var c = new Customer();
c.Age = 21;

// Object initialization can be simplified

// After
var c = new Customer() { Age = 21 };

VB

' Before
Dim c = New Customer()
c.Age = 21

' Object initialization can be simplified

' After
Dim c = New Customer() With {.Age = 21}

ID di diagnostica	Linguaggi applicabili	Versione supportata
IDE0017	C# r Visual Basic	Visual Studio 2017 e versioni successive

Usare gli inizializzatori di insieme

Questa azione rapida consente di usare gli inizializzatori di insieme invece di più chiamate al metodo Add della classe.

C#

// Before
var list = new List<int>();
list.Add(1);
list.Add(2);
list.Add(3);

// Collection initialization can be simplified

// After
var list = new List<int> { 1, 2, 3 };

VB

' Before
Dim list = New List(Of Integer)
list.Add(1)
list.Add(2)
list.Add(3)

' Collection initialization can be simplified

' After
Dim list = New List(Of Integer) From {1, 2, 3}

ID di diagnostica	Linguaggi applicabili	Versione supportata
IDE0028	C# r Visual Basic	Visual Studio 2017 e versioni successive

Convertire una proprietà automatica in proprietà completa

Questa azione rapida consente di convertire una proprietà automatica in una proprietà completa e viceversa.

C#

// Before
private int MyProperty { get; set; }

// Convert to full property

// After
private int MyProperty
{
    get { return _myProperty; }
    set { _myProperty = value; }
}

VB

' Before
Public Property Name As String

' Convert to full property

' After
Private _Name As String

Public Property Name As String
    Get
        Return _Name
    End Get
    Set
        _Name = Value
    End Set
End Property

Linguaggi applicabili	Versione supportata
C# r Visual Basic	Visual Studio 2017 versione 15.5 e successive

Convertire il corpo di blocco in membro con corpo di espressione

Questa azione rapida consente di convertire i corpi di blocco in membri con corpo di espressione per metodi, costruttori, operatori, proprietà, indicizzatori e funzioni di accesso.

//Before
class MyClass4
{
    private int _myProperty;

    public int MyProperty
    {
        get { return _myProperty; }
        set
        {
            _myProperty = value;
        }
    }

    public MyClass4(int myProperty)
    {
        MyProperty = myProperty;
    }

    public void PrintProperty()
    {
        Console.WriteLine(MyProperty);
    }
}

// Use expression body for accessors/constructors/methods

// After
class MyClass4
{
    private int _myProperty;

    public int MyProperty
    {
        get => _myProperty;
        set => _myProperty = value;
    }

    public MyClass4(int myProperty) => MyProperty = myProperty;

    public void PrintProperty() => Console.WriteLine(MyProperty);
}

ID di diagnostica	Linguaggi applicabili	Versione supportata
IDE0021-27	C# 6.0+	Visual Studio 2017 e versioni successive

Convertire una funzione anonima in funzione locale

Questa azione rapida converte le funzioni anonime in funzioni locali.

// Before
Func<int, int> fibonacci = null;
fibonacci = (int n) =>
{
    return n <= 1 ? 1 : fibonacci(n - 1) + fibonacci(n - 2);
};

// Use local function

// After
int fibonacci(int n)
{
    return n <= 1 ? 1 : fibonacci(n-1) + fibonacci(n-2);
}

Convertire "ReferenceEquals" in "is null"

ID di diagnostica	Linguaggi applicabili	Versione supportata
IDE0041	C# 7.0+	Visual Studio 2017 versione 15.5 e successive

Questa azione rapida suggerisce l'uso di criteri di ricerca anziché del modello di codifica ReferenceEquals, ove possibile.

// Before
var value = "someString";
if (object.ReferenceEquals(value, null))
{
    return;
}

// Use 'is null' check

// After
var value = "someString";
if (value is null)
{
    return;
}

ID di diagnostica	Linguaggi applicabili	Versione supportata
IDE0039	C# 7.0+	Visual Studio 2017 versione 15. e versioni successive

Introdurre criteri di ricerca

Questa azione rapida suggerisce l'uso di criteri di ricerca con cast e controlli null in C#.

// Before
if (o is int)
{
    var i = (int)o;
    ...
}

// Use pattern matching

// After
if (o is int i)
{
    ...
}

// Before
var s = o as string;
if (s != null)
{
    ...
}

// Use pattern matching

// After
if (o is string s)
{
    ...
}

ID di diagnostica	Linguaggi applicabili	Versione supportata
IDE0020	C# 7.0+	Visual Studio 2017 e versioni successive
IDE0019	C# 7.0+	Visual Studio 2017 e versioni successive

Modificare la base per i valori letterali numerici

Questa azione rapida consente di convertire un valore letterale numerico da un sistema numerico di base a un altro. È possibile, ad esempio, convertire un numero in formato esadecimale o binario.

C#

// Before
int countdown = 2097152;

// Convert to hex

// After
int countdown = 0x200000;

VB

' Before
Dim countdown As Integer = 2097152

' Convert to hex

' After
Dim countdown As Integer = &H200000

Linguaggi applicabili	Versione supportata
C# 7.0+ e Visual Basic 14+	Visual Studio 2017 versione 15.3 e successive

Inserire separatori di cifre in valori letterali

Questa azione rapida consente di aggiungere caratteri separatori nei valori letterali.

C#

// Before
int countdown = 1000000;

// Separate thousands

// After
int countdown = 1_000_000;

VB

' Before
Dim countdown As Integer = 1000000

' Separate thousands

' After
Dim countdown As Integer = 1_000_000

Linguaggi applicabili	Versione supportata
C# 7.0+ e Visual Basic 14+	Visual Studio 2017 versione 15.3 e successive

Usare nomi di tupla espliciti

Questa azione rapida identifica le aree in cui è possibile usare nomi di tupla espliciti invece di Elemento1, Elemento2 e così via.

C#

// Before
(string name, int age) customer = GetCustomer();
var name = customer.Item1;

// Use explicit tuple name

// After
(string name, int age) customer = GetCustomer();
var name = customer.name;

VB

' Before
Dim customer As (name As String, age As Integer) = GetCustomer()
Dim name = customer.Item1

' Use explicit tuple name

' After
Dim customer As (name As String, age As Integer) = GetCustomer()
Dim name = customer.name

ID di diagnostica	Linguaggi applicabili	Versione supportata
IDE0033	C# 7.0+ e Visual Basic 15+	Visual Studio 2017 e versioni successive

Usare nomi dedotti

Questa azione rapida segnala quando il codice può essere semplificato tramite l'uso di nomi dei membri dedotti nei tipi anonimi o di nomi di elemento dedotti nelle tuple.

// Before
var anon = new { age = age, name = name };

// Use inferred member name

// After
var anon = new { age, name };

// Before
var tuple = (age: age, name: name);

// Use inferred tuple element name

// After
var tuple = (age, name);

ID di diagnostica	Linguaggi applicabili	Versione supportata
IDE0037	C#	Visual Studio 2017 versione 15.5 e successive
IDE0037	C# 7.1+	Visual Studio 2017 versione 15.5 e successive

Decostruisci la dichiarazione di variabile

Questa azione rapida consente di decostruire le dichiarazioni delle variabili di tupla.

// Before
var person = GetPersonTuple();
Console.WriteLine($"{person.name} {person.age}");

(int x, int y) point = GetPointTuple();
Console.WriteLine($"{point.x} {point.y}");

//Deconstruct variable declaration

// After
var (name, age) = GetPersonTuple();
Console.WriteLine($"{name} {age}");

(int x, int y) = GetPointTuple();
Console.WriteLine($"{x} {y}");

ID di diagnostica	Linguaggi applicabili	Versione supportata
IDE0042	C# 7.0+	Visual Studio 2017 versione 15.5 e successive

Rendere sincrono un metodo

Quando si usa la parola chiave async o Async per un metodo, si prevede che venga usata anche la parola chiave await o Await all'interno del metodo stesso. Se tuttavia ciò non avviene, viene visualizzata un'azione rapida che consente di impostare il metodo come sincrono rimuovendo la parola chiave async o Async e modificando il tipo restituito. Usare l'opzione Imposta il metodo come sincrono dal menu Azioni rapide.

C#

// Before
async Task<int> MyAsyncMethod()
{
    return 3;
}

// Make method synchronous

// After
int MyAsyncMethod()
{
    return 3;
}

VB

' Before
Async Function MyAsyncMethod() As Task(Of Integer)
    Return 3
End Function

' Make method synchronous

' After
Function MyAsyncMethod() As Integer
    Return 3
End Function

ID errore	Linguaggi applicabili
CS1998, BC42356	C# r Visual Basic

Rendere asincrono un metodo

Quando si usa la parola chiave await o Await all'interno di un metodo, si prevede che il metodo stesso sia contrassegnato dalla parola chiave async o Async. In caso contrario, verrà comunque visualizzata un'azione rapida che imposta il metodo come asincrono. Usare l'opzione Rendi asincrono il metodo/Rendi asincrona la funzione dal menu Azioni rapide.

C#

// Before
int MyAsyncMethod()
{
    return await Task.Run(...);
}

// Make method asynchronous

// After
async Task<int> MyAsyncMethod()
{
    return await Task.Run(...);
}

VB

' Before
Function MyAsyncMethod() as Integer
    Return  Await Task.Run(...)
End Function

' Make method asynchronous

' After
Async Function MyAsyncMethod() As Task(Of Integer)
    Return Await Task.Run(...)
End Function

ID errore	Linguaggi applicabili	Versione supportata
CS4032, BC37057	C# r Visual Basic	Visual Studio 2017 e versioni successive

Vedi anche

• Azioni rapide