Ações Rápidas Comuns

As seções neste tópico listam algumas das Ações Rápidas comuns aplicáveis ao código C# e ao Visual Basic. Essas ações são correções de código para diagnóstico de compilador ou analisadores internos da Plataforma do Compilador do .NET no Visual Studio.

Ações que corrigem erros

As Ações Rápidas nesta seção corrige erros no código que fariam com que um build falhasse. 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 rabiscos vermelho é uma lâmpada com um 'x' vermelho.

Corrigir símbolo ou palavra-chave com ortografia incorreta

Se você acidentalmente digitar incorretamente um tipo ou palavra-chave no Visual Studio, essa Ação Rápida a corrigirá automaticamente para você. Você verá esses itens no menu de lâmpada como "Alterar '<palavra> incorreta' 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 conflito de mesclagem do Git

Essas Ações Rápidas permitem resolver conflitos de mesclagem do Git "fazendo uma alteração", 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 Desnecessários/Importações remove quaisquer diretivas e Import não usadas using para o arquivo atual. Quando você seleciona esse item, as importações de namespace não usadas são removidas.

Remover conversão desnecessária

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

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

Esta Ação Rápida permite que você remova variáveis que foram declaradas, mas nunca usadas em seu 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 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 em sua solução

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

Quando habilitado, se você usar um tipo em um namespace que atualmente não é importado, mas existe em um assembly de referência ou pacote NuGet, a diretiva 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 casos ausentes/caso padrão/ambos

Ao criar uma switch instrução em C#ou Select Case instrução no Visual Basic, você pode usar uma Ação de Código para adicionar automaticamente itens de caso ausentes, uma instrução de caso padrão ou ambos.

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

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

Usar a Ação Adicionar Ambas as Ações Rápidas preenche os casos ausentes e adiciona um caso padrão:

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 nulas para parâmetros

Essa Ação Rápida permite que você adicione uma verificação em seu código para informar 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 encapsula chaves em torno de instruções de linha if única.

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

// Add braces

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

Adicionar e ordenar modificadores

Essas Ações Rápidas ajudam a organizar modificadores, permitindo que você classifique os modificadores de acessibilidade existentes e adicione modificadores de acessibilidade 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 o constructo 'if' em 'switch'

Esta Ação Rápida permite converter um constructo if-then-else em um constructo de comutador .

// 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, semelhantes ao método String.Format . Essa Ação Rápida reconhece casos em que as cadeias de caracteres são concatenadas ou usam String.Format e altera o uso para 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 que você use 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 que você use inicializadores de coleção em vez de várias chamadas para o Add método de 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 propriedade automática em propriedade completa

Esta Ação Rápida permite que você converta 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 corpo do bloco em membro com corpo de expressão

Esta Ação Rápida permite converter corpos de bloco em membros aptos à 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'

Essa Ação Rápida sugere o uso da correspondência de padrões em vez do ReferenceEquals padrão de codificação, 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 correspondência de padrões

Esta Ação Rápida sugere o uso de 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éricos

Esta Ação Rápida permite converter um literal numérico de um sistema numérico base para outro. Por exemplo, você pode alterar um número para hexadecimal ou para 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ígito em literais

Esta Ação Rápida permite adicionar caracteres separadores a 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ícitos

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 aponta quando o código pode ser simplificado para usar nomes de membro inferidos em tipos anônimos ou nomes de elementos 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);

Declaração de tupla de desconstrução

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 ou Async a async palavra-chave em um método, espera-se que dentro desse método a palavra-chave ou Await a await palavra-chave também seja usada. No entanto, se esse não for o caso, será exibida uma Ação Rápida que torna o método síncrono removendo a async palavra-chave ou Async alterando o tipo de retorno. Use a opção Fazer método síncrono no 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 ou Await dentro await de um método, espera-se que o método seja marcado com a palavra-chave ou Async a async palavra-chave. No entanto, se esse não for o caso, será exibida uma Ação Rápida que torna o método assíncrono. Use a opção Fazer método/Função assíncrona no 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

Consulte também

• Ações rápidas