Ações Rápidas comuns

As seções deste tópico listam algumas das Ações Rápidas comuns aplicáveis ao código do C# e do Visual Basic. Essas ações são correções de código para diagnósticos do compilador ou os analisadores do .NET Compiler Platform internos do Visual Studio.

Ações que corrigem erros

Nesta seção, as Ações Rápidas corrigem erros no código que podem fazer com que um build falhe. Quando as Ações Rápidas estão disponíveis para corrigir um erro em uma linha de código, o ícone exibido na margem ou abaixo do rabisco vermelho é uma lâmpada com um "x" vermelho.

Corrigir o símbolo ou a palavra-chave incorreta

Se você digitar incorretamente um tipo ou uma palavra-chave no Visual Studio acidentalmente, essa Ação Rápida corrigirá esse erro de forma automática. Você verá esses itens no Menu de lâmpada como "Alterar '<palavra digitada incorretamente>' para '<palavra correta>'". Por exemplo:

// Before
private viod MyMethod()
{
}

// Change 'viod' to 'void'

// After
private void MyMethod()
{
}

' Before
Function MyFunction as Intger
End Function

' Change 'Intger' to 'Integer'

' After
Function MyFunction as Integer
End Function

Resolver conflitos de mesclagem do git

Estas Ações rápidas permitem resolver conflitos de mesclagem do git "fazendo uma alteração", que remove o código e os marcadores conflitantes.

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

    }
}

// Take changes from 'HEAD'

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

    }
}

Ações que removem código desnecessário

Remover usos/importações desnecessários

A Ação Rápida Remover Usos/Importações Desnecessários remove todas as instruções para o arquivo atual using e Import não utilizadas. Ao selecionar esse item, as importações de namespace não utilizadas são removidas.

Remover conversão desnecessária

Se você converter um tipo em outro que não exige uma conversão, o item de Ação Rápida Remover Conversão Desnecessária removerá a conversão do código.

// before
int number = (int)3;

// Remove Unnecessary Cast

// after
int number = 3;

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

' Remove Unnecessary Cast

' After
Dim number as Integer = 3

Remover variáveis não utilizadas

Essa Ação Rápida permite remover variáveis que foram declaradas, mas nunca foram usadas no código.

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

// Remove unused variables

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

Remover o tipo da expressão de valor padrão

Esta Ação Rápida remove o tipo de valor de uma expressão de valor padrão e usa o literal padrão quando o compilador pode inferir o tipo da expressão.

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

// Simplify default expression

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

Ações que adicionam código ausente

Adicionar usos/importações para tipos em assemblies de referência, pacotes NuGet ou outros tipos na solução

• Sugerir usos/importações para tipos em assemblies de referência
• Sugerir usos/importações para tipos em pacotes NuGet

Quando essa opção estiver habilitada, se você usar um tipo em um namespace que não foi importado, mas que existe em um assembly de referência ou pacote NuGet, a instrução de uso ou importação será criada.

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

// using System.Diagnostics;

// After
using System.Diagnostics;

Debug.WriteLine("Hello");

' Before
Debug.WriteLine("Hello")

' Imports System.Diagnostics

' After
Imports System.Diagnostics

Debug.WriteLine("Hello")

Adicionar maiúsculas e minúsculas ausentes/maiúsculas e minúsculas padrão/ambas

Ao criar uma instrução switch no C# ou uma instrução Select Case no Visual Basic, é possível usar uma Ação de Código para adicionar automaticamente itens com maiúsculas e minúsculas ausentes, uma instrução com maiúsculas e minúsculas padrão ou ambos.

Considere a seguinte enumeração e a instrução switch ou Select Case vazia:

enum MyEnum
{
    Item1,
    Item2,
    Item3
}

...

MyEnum myEnum = MyEnum.Item1;

switch(myEnum)
{
}

Enum MyEnum
    Item1
    Item2
    Item3
End Enum

...

Dim myEnum as MyEnum = MyEnum.Item1

Select Case myEnum
End Select

Ao usar a Ação Rápida Adicionar Ambos, os casos que faltam são preenchidos e um caso padrão é adicionado:

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

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

Adicionar verificações de null para parâmetros

Essa Ação Rápida permite que você adicione uma verificação ao código para determinar se um parâmetro é nulo.

// 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));
    }
}

Adicionar nome do argumento

// 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);

Adicionar chaves

A Ação rápida Adicionar chaves insere chaves em torno de instruções if de linha única.

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

// Add braces

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

Adicionar e ordenar modificadores

Estas Ações rápidas ajudam a organizar os modificadores, permitindo que você classifique modificadores de acessibilidade existentes e adicione os que estão ausentes.

// 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;

Transformações de código

Converter construtor 'if' em 'switch'

Essa Ação Rápida permite que você converta um construtor if-then-else em um construtor switch.

// 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;
}

' 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

Converter em cadeia de caracteres interpolada

Cadeias de caracteres interpoladas são uma maneira fácil de expressar cadeias de caracteres com variáveis inseridas, semelhante ao método String.Format. Essa Ação Rápida reconhece maiúsculas e minúsculas nas quais as cadeias de caracteres são concatenadas ou que usam String.Format e altera o uso de uma cadeia de caracteres interpolada.

// 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";

' 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"

Usar inicializadores de objeto

Esta Ação Rápida permite usar inicializadores de objeto em vez de invocar o construtor e ter linhas adicionais de instruções de atribuição.

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

// Object initialization can be simplified

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

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

' Object initialization can be simplified

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

Usar inicializadores de coleção

Esta Ação rápida permite usar inicializadores de coleção em vez de múltiplas chamadas ao método Add da sua classe.

// 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 };

' 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}

Converter a propriedade automática em propriedade completa

Esta Ação rápida permite converter uma propriedade automática em uma propriedade completa e vice-versa.

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

// Convert to full property

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

' 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

Converter o corpo do bloco em membro apto para expressão

Esta Ação rápida permite converter corpos do bloco em membros aptos para expressão para métodos, construtores, operadores, propriedades, indexadores e acessadores.

//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);
}

Converter função anônima em função local

Esta Ação rápida converte funções anônimas em funções locais.

// 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);
}

Converter 'ReferenceEquals' em 'is null'

Esta Ação rápida sugere o uso de correspondência de padrões em vez do padrão de codificação ReferenceEquals, sempre que possível.

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

// Use 'is null' check

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

Introduzir a correspondência de padrões

Esta Ação rápida sugere o uso da correspondência de padrões com conversões e verificações nulas em 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)
{
    ...
}

Alterar base para literais numéricas

Essa Ação Rápida permite que você converta um literal numérico de um sistema numérico base para outro. Por exemplo, você pode alterar um número para hexadecimal ou formato binário.

// Before
int countdown = 2097152;

// Convert to hex

// After
int countdown = 0x200000;

' Before
Dim countdown As Integer = 2097152

' Convert to hex

' After
Dim countdown As Integer = &H200000

Inserir separadores de dígitos em literais

Essa Ação Rápida permite que você adicione caracteres separadores em valores literais.

// Before
int countdown = 1000000;

// Separate thousands

// After
int countdown = 1_000_000;

' Before
Dim countdown As Integer = 1000000

' Separate thousands

' After
Dim countdown As Integer = 1_000_000

Usar nomes de tupla explícita

Esta Ação rápida identifica áreas em que o nome da tupla explícita pode ser usado em vez de Item1, Item2, etc.

// 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;

' 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

Usar nomes inferidos

Esta Ação Rápida destaca quando o código pode ser simplificado para usar nomes de membros inferidos em tipos anônimos ou nomes de elemento inferidos em tuplas.

// 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);

Desconstruir declaração de tupla

Esta Ação Rápida permite desconstruir declarações de variável de 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}");

Tornar o método síncrono

Ao usar a palavra-chave async ou Async em um método, espera-se que, dentro desse método a palavra-chave await ou Await também seja usada. No entanto, se esse não é o caso, é exibida uma Ação Rápida que torna o método síncrono removendo a palavra-chave async ou Async e alterando o tipo de retorno. Use a opção Tornar o método síncrono do menu Ações Rápidas.

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

// Make method synchronous

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

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

' Make method synchronous

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

Tornar o método assíncrono

Ao usar a palavra-chave await ou Await em um método, espera-se que o próprio método seja marcado com a palavra-chave async ou Async. No entanto, se esse não for o caso, é exibida uma Ação Rápida que torna o método assíncrono. Use a opção Tornar o método ou a função síncrona do menu Ações Rápidas.

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

// Make method asynchronous

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

' 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

Confira também

• Ações Rápidas