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.
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.
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()
{
}
ID do erro | Linguagens Aplicáveis |
---|---|
CS0103, BC30002 | C# e Visual Basic |
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)
{
}
}
ID do erro | Linguagens Aplicáveis | Versão com suporte |
---|---|---|
CS8300, BC37284 | C# e Visual Basic | Visual Studio 2017 versão 15.3 e posteriores |
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.
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.
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);
}
ID do diagnóstico | Linguagens Aplicáveis | Versão com suporte |
---|---|---|
CS0219, BC42024 | C# e Visual Basic | Visual Studio 2017 versão 15.3 e posteriores |
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) { ... }
ID do diagnóstico | Linguagens Aplicáveis | Versão com suporte |
---|---|---|
IDE0034 | C# 7.1+ | Visual Studio 2017 versão 15.3 e posteriores |
Adicionar usos/importações para tipos em assemblies de referência, pacotes NuGet ou outros tipos na solução
O uso dos tipos localizados em outros projetos na sua solução exibirá automaticamente a Ação Rápida, no entanto, os outros precisam ser habilitados na aba Ferramentas > Opções > Editor de texto > C# ou Visual Basic > Avançado:
O uso dos tipos localizados em outros projetos na sua solução exibirá automaticamente a Ação Rápida. No entanto, as outras precisam ser habilitadas na aba Ferramentas > Opções > Editor de texto > C# ou Básico > Avançado:
- 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");
ID do diagnóstico | Linguagens Aplicáveis |
---|---|
CS0103, BC30451 | C# e Visual Basic |
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:
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;
}
ID do diagnóstico | Linguagens Aplicáveis | Versão com suporte |
---|---|---|
IDE0010 | C# e Visual Basic | Visual Studio 2017 versão 15.3 e posteriores |
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));
}
}
Linguagens Aplicáveis | Versão com suporte |
---|---|
C# e Visual Basic | Visual Studio 2017 versão 15.3 e posteriores |
// 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);
Linguagens Aplicáveis | Versão com suporte |
---|---|
C# e Visual Basic | Visual Studio 2017 versão 15.3 e posteriores |
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";
}
ID do diagnóstico | Linguagens Aplicáveis | Versão com suporte |
---|---|---|
IDE0011 | C# | Visual Studio 2017 e posterior |
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;
ID do diagnóstico | Linguagens Aplicáveis | Versão com suporte |
---|---|---|
IDE0036 | C# e Visual Basic | Visual Studio 2017 versão 15.5 e posterior |
IDE0040 | C# e Visual Basic | Visual Studio 2017 versão 15.5 e posterior |
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;
}
Linguagens Aplicáveis | Versão com suporte |
---|---|
C# e Visual Basic | Visual Studio 2017 versão 15.3 e posteriores |
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";
Linguagens Aplicáveis | Versão com suporte |
---|---|
C# 6.0+ e Visual Basic 14+ | Visual Studio 2017 e posterior |
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 };
ID do diagnóstico | Linguagens Aplicáveis | Versão com suporte |
---|---|---|
IDE0017 | C# e Visual Basic | Visual Studio 2017 e posterior |
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 };
ID do diagnóstico | Linguagens Aplicáveis | Versão com suporte |
---|---|---|
IDE0028 | C# e Visual Basic | Visual Studio 2017 e posterior |
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; }
}
Linguagens Aplicáveis | Versão com suporte |
---|---|
C# e Visual Basic | Visual Studio 2017 versão 15.5 e posterior |
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);
}
ID do diagnóstico | Linguagens Aplicáveis | Versão com suporte |
---|---|---|
IDE0021-27 | C# 6.0+ | Visual Studio 2017 e posterior |
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);
}
ID do diagnóstico | Linguagens Aplicáveis | Versão com suporte |
---|---|---|
IDE0041 | C# 7.0+ | Visual Studio 2017 versão 15.5 e posterior |
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;
}
ID do diagnóstico | Linguagens Aplicáveis | Versão com suporte |
---|---|---|
IDE0039 | C# 7.0+ | Visual Studio 2017 versão 15. e posterior |
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)
{
...
}
ID do diagnóstico | Linguagens Aplicáveis | Versão com suporte |
---|---|---|
IDE0020 | C# 7.0+ | Visual Studio 2017 e posterior |
IDE0019 | C# 7.0+ | Visual Studio 2017 e posterior |
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.
Linguagens Aplicáveis | Versão com suporte |
---|---|
C# 7.0+ e Visual Basic 14+ | Visual Studio 2017 versão 15.3 e posteriores |
Essa Ação Rápida permite que você adicione caracteres separadores em valores literais.
Linguagens Aplicáveis | Versão com suporte |
---|---|
C# 7.0+ e Visual Basic 14+ | Visual Studio 2017 versão 15.3 e posteriores |
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;
ID do diagnóstico | Linguagens Aplicáveis | Versão com suporte |
---|---|---|
IDE0033 | C# 7.0+ e Visual Basic 15+ | Visual Studio 2017 e posterior |
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);
ID do diagnóstico | Linguagens Aplicáveis | Versão com suporte |
---|---|---|
IDE0037 | C# | Visual Studio 2017 versão 15.5 e posterior |
IDE0037 | C# 7.1+ | Visual Studio 2017 versão 15.5 e posterior |
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}");
ID do diagnóstico | Linguagens Aplicáveis | Versão com suporte |
---|---|---|
IDE0042 | C# 7.0+ | Visual Studio 2017 versão 15.5 e posterior |
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;
}
ID do erro | Linguagens Aplicáveis |
---|---|
CS1998, BC42356 | C# e Visual Basic |
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(...);
}
ID do erro | Linguagens Aplicáveis | Versão com suporte |
---|---|---|
CS4032, BC37057 | C# e Visual Basic | Visual Studio 2017 e posterior |