Ações Rápidas comunsCommon Quick Actions

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.The sections in this topic list some of the common Quick Actions that are applicable to both C# and Visual Basic code. 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.These actions are code fixes for either compiler diagnostics, or the built-in .NET Compiler Platform analyzers in Visual Studio.

Ações que corrigem errosActions that fix errors

Nesta seção, as Ações Rápidas corrigem erros no código que podem fazer com que um build falhe.The Quick Actions in this section fix errors in code that would cause a build to fail. 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.When Quick Actions are available to fix an error on a line of code, the icon that's displayed in the margin or underneath the red squiggle is a light bulb with a red 'x' on it.

Ícone de erro e menu das Ações Rápidas

Corrigir o símbolo ou a palavra-chave incorretaCorrect misspelled symbol or keyword

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.If you accidentally misspell a type or keyword in Visual Studio, this Quick Action automatically corrects it for you. Você verá esses itens no menu de lâmpada como "alterar ' <misspelled word> ' para ' <correct word> '".You'll see these items in the light bulb menu as "Change '<misspelled word>' to '<correct word>'". Por exemplo:For example:

// 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
ID do erroError ID Linguagens AplicáveisApplicable Languages
CS0103, BC30002CS0103, BC30002 C# e Visual BasicC# and Visual Basic

Resolver conflitos de mesclagem do gitResolve git merge conflict

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.These Quick Actions enable you to resolve git merge conflicts by "taking a change", which removes the conflicting code and markers.

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

    }
}

// Take changes from 'HEAD'

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

    }
}
ID do erroError ID Linguagens AplicáveisApplicable Languages Versão com suporteSupported Version
CS8300, BC37284CS8300, BC37284 C# e Visual BasicC# and Visual Basic Visual Studio 2017 versão 15,3 e posteriorVisual Studio 2017 version 15.3 and later

Ações que removem código desnecessárioActions that remove unnecessary code

Remover usos/importações desnecessáriosRemove unnecessary usings/Imports

A ação rápida remover utilizações/importações desnecessárias remove todas as using diretivas e não usadas Import para o arquivo atual.The Remove Unnecessary Usings/Imports Quick Action removes any unused using and Import directives for the current file. Ao selecionar esse item, as importações de namespace não utilizadas são removidas.When you select this item, unused namespace imports are removed.

Linguagens AplicáveisApplicable Languages Versão com suporteSupported Version
C# e Visual BasicC# and Visual Basic Visual Studio 2015 e posteriorVisual Studio 2015 and later

Remover conversão desnecessáriaRemove unnecessary cast

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.If you cast a type to another type that doesn't require a cast, the Remove Unnecessary Cast Quick Action item removes the unnecessary cast.

// 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
ID do diagnósticoDiagnostic ID Linguagens AplicáveisApplicable Languages Versão com suporteSupported Version
IDE0004IDE0004 C# e Visual BasicC# and Visual Basic Visual Studio 2015 e posteriorVisual Studio 2015 and later

Remover variáveis não utilizadasRemove unused variables

Essa Ação Rápida permite remover variáveis que foram declaradas, mas nunca foram usadas no código.This Quick Action enables you to remove variables that have been declared but never used in your code.

// 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ósticoDiagnostic ID Linguagens AplicáveisApplicable Languages Versão com suporteSupported Version
CS0219, BC42024CS0219, BC42024 C# e Visual BasicC# and Visual Basic Visual Studio 2017 versão 15,3 e posteriorVisual Studio 2017 version 15.3 and later

Remover o tipo da expressão de valor padrãoRemove type from default value expression

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.This Quick Action removes the value type from a default value expression and uses the default literal when the compiler can infer the type of the expression.

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

// Simplify default expression

// After
void DoWork(CancellationToken cancellationToken = default) { ... }
ID do diagnósticoDiagnostic ID Linguagens AplicáveisApplicable Languages Versão com suporteSupported Version
IDE0034IDE0034 C# 7.1+C# 7.1+ Visual Studio 2017 versão 15,3 e posteriorVisual Studio 2017 version 15.3 and later

Ações que adicionam código ausenteActions that add missing code

Adicionar usos/importações para tipos em assemblies de referência, pacotes NuGet ou outros tipos na soluçãoAdd usings/imports for types in reference assemblies, NuGet packages, or other types in your solution

O uso dos tipos localizados em outros projetos da solução exibirá a Ação Rápida automaticamente. No entanto, as outras precisam ser habilitadas na guia Ferramentas > Opções > C# ou Basic > Avançado:Using types located in other projects in your solution will display the Quick Action automatically, however the others need to be enabled from the Tools > Options > C# or Basic > Advanced tab:

  • Sugerir usos/importações para tipos em assemblies de referênciaSuggest usings/imports for types in reference assemblies
  • Sugerir usos/importações para tipos em pacotes NuGetSuggest usings/imports for types in NuGet packages

Quando habilitado, se você usar um tipo em um namespace que não seja importado no momento, mas existir em um assembly de referência ou em um pacote NuGet, a diretiva using ou Import será criada.When enabled, if you use a type in a namespace that is currently not imported but exists in a reference assembly or NuGet package, the using or import directive is created.

// 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")
ID do diagnósticoDiagnostic ID Linguagens AplicáveisApplicable Languages
CS0103, BC30451CS0103, BC30451 C# e Visual BasicC# and Visual Basic

Adicionar maiúsculas e minúsculas ausentes/maiúsculas e minúsculas padrão/ambasAdd missing cases/default case/both

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.When creating a switch statement in C#, or Select Case statement in Visual Basic, you can use a Code Action to automatically add missing case items, a default case statement, or both.

Considere a seguinte enumeração e a instrução switch ou Select Case vazia:Consider the following enumeration and empty switch or Select Case statement:

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:Using the Add Both Quick Action fills in missing cases and adds a default case:

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
ID do diagnósticoDiagnostic ID Linguagens AplicáveisApplicable Languages Versão com suporteSupported Version
IDE0010IDE0010 C# e Visual BasicC# and Visual Basic Visual Studio 2017 versão 15,3 e posteriorVisual Studio 2017 version 15.3 and later

Adicionar verificações de null para parâmetrosAdd null checks for parameters

Essa Ação Rápida permite que você adicione uma verificação ao código para determinar se um parâmetro é nulo.This Quick Action enables you to add a check in your code to tell whether a parameter is 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));
    }
}
Linguagens AplicáveisApplicable Languages Versão com suporteSupported Version
C# e Visual BasicC# and Visual Basic Visual Studio 2017 versão 15,3 e posteriorVisual Studio 2017 version 15.3 and later

Adicionar nome do argumentoAdd argument name

// 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áveisApplicable Languages Versão com suporteSupported Version
C# e Visual BasicC# and Visual Basic Visual Studio 2017 versão 15,3 e posteriorVisual Studio 2017 version 15.3 and later

Adicionar chavesAdd braces

A Ação rápida Adicionar chaves insere chaves em torno de instruções if de linha única.The Add braces Quick Action wraps braces around single-line if statements.

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

// Add braces

// After
if (true)
{
    return "hello,world";
}
ID do diagnósticoDiagnostic ID Linguagens AplicáveisApplicable Languages Versão com suporteSupported Version
IDE0011IDE0011 C#C# Visual Studio 2017 e posteriorVisual Studio 2017 and later

Adicionar e ordenar modificadoresAdd and order modifiers

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.These Quick Actions help organize modifiers by enabling you to sort existing and add missing accessibility modifiers.

// 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ósticoDiagnostic ID Linguagens AplicáveisApplicable Languages Versão com suporteSupported Version
IDE0036IDE0036 C# e Visual BasicC# and Visual Basic Visual Studio 2017 versão 15.5 e posteriorVisual Studio 2017 version 15.5 and later
IDE0040IDE0040 C# e Visual BasicC# and Visual Basic Visual Studio 2017 versão 15.5 e posteriorVisual Studio 2017 version 15.5 and later

Transformações de códigoCode transformations

Converter construtor 'if' em 'switch'Convert 'if' construct to 'switch'

Essa Ação Rápida permite que você converta um construtor if-then-else em um construtor switch.This Quick Action enables you to convert an if-then-else construct to a switch construct.

// 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
Linguagens AplicáveisApplicable Languages Versão com suporteSupported Version
C# e Visual BasicC# and Visual Basic Visual Studio 2017 versão 15,3 e posteriorVisual Studio 2017 version 15.3 and later

Converter em cadeia de caracteres interpoladaConvert to interpolated string

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.Interpolated strings are an easy way to express strings with embedded variables, similar to the String.Format method. 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.This Quick Action recognizes cases where strings are concatenated, or using String.Format, and changes the usage to an interpolated string.

// 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"
Linguagens AplicáveisApplicable Languages Versão com suporteSupported Version
C# 6.0+ e Visual Basic 14+C# 6.0+ and Visual Basic 14+ Visual Studio 2017 e posteriorVisual Studio 2017 and later

Usar inicializadores de objetoUse object initializers

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.This Quick Action enables you to use object initializers rather than invoking the constructor and having additional lines of assignment statements.

// 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}
ID do diagnósticoDiagnostic ID Linguagens AplicáveisApplicable Languages Versão com suporteSupported Version
IDE0017IDE0017 C# e Visual BasicC# and Visual Basic Visual Studio 2017 e posteriorVisual Studio 2017 and later

Usar inicializadores de coleçãoUse collection initializers

Esta Ação rápida permite usar inicializadores de coleção em vez de múltiplas chamadas ao método Add da sua classe.This Quick Action lets you use collection initializers rather than multiple calls to the Add method of your class.

// 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}
ID do diagnósticoDiagnostic ID Linguagens AplicáveisApplicable Languages Versão com suporteSupported Version
IDE0028IDE0028 C# e Visual BasicC# and Visual Basic Visual Studio 2017 e posteriorVisual Studio 2017 and later

Converter a propriedade automática em propriedade completaConvert auto property to full property

Esta Ação rápida permite converter uma propriedade automática em uma propriedade completa e vice-versa.This Quick Action enables you to convert an auto property to a full property, and 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
Linguagens AplicáveisApplicable Languages Versão com suporteSupported Version
C# e Visual BasicC# and Visual Basic Visual Studio 2017 versão 15.5 e posteriorVisual Studio 2017 version 15.5 and later

Converter o corpo do bloco em membro apto para expressãoConvert block body to expression-bodied member

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.This Quick Action allows you to convert block bodies into expression-bodied members for methods, constructors, operators, properties, indexers, and accessors.

//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ósticoDiagnostic ID Linguagens AplicáveisApplicable Languages Versão com suporteSupported Version
IDE0021-27IDE0021-27 C# 6.0+C# 6.0+ Visual Studio 2017 e posteriorVisual Studio 2017 and later

Converter função anônima em função localConvert anonymous function to local function

Esta Ação rápida converte funções anônimas em funções locais.This Quick Action converts anonymous functions into local functions.

// 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'Convert 'ReferenceEquals' to 'is null'

ID do diagnósticoDiagnostic ID Linguagens AplicáveisApplicable Languages Versão com suporteSupported Version
IDE0041IDE0041 C# 7.0+C# 7.0+ Visual Studio 2017 versão 15.5 e posteriorVisual Studio 2017 version 15.5 and later

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.This Quick Action suggests the use of pattern matching rather than the ReferenceEquals coding-pattern, where possible.

// 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ósticoDiagnostic ID Linguagens AplicáveisApplicable Languages Versão com suporteSupported Version
IDE0039IDE0039 C# 7.0+C# 7.0+ Visual Studio 2017 versão 15.Visual Studio 2017 version 15. e posteriorand later

Introduzir a correspondência de padrõesIntroduce pattern matching

Esta Ação rápida sugere o uso da correspondência de padrões com conversões e verificações nulas em C#.This Quick Action suggests the use of pattern matching with casts and null checks 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 do diagnósticoDiagnostic ID Linguagens AplicáveisApplicable Languages Versão com suporteSupported Version
IDE0020IDE0020 C# 7.0+C# 7.0+ Visual Studio 2017 e posteriorVisual Studio 2017 and later
IDE0019IDE0019 C# 7.0+C# 7.0+ Visual Studio 2017 e posteriorVisual Studio 2017 and later

Alterar base para literais numéricasChange base for numeric literals

Essa Ação Rápida permite que você converta um literal numérico de um sistema numérico base para outro.This Quick Action enables you to convert a numeric literal from one base numeric system to another. Por exemplo, você pode alterar um número para hexadecimal ou formato binário.For example, you can change a number to hexadecimal or to binary format.

// 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
Linguagens AplicáveisApplicable Languages Versão com suporteSupported Version
C# 7.0+ e Visual Basic 14+C# 7.0+ and Visual Basic 14+ Visual Studio 2017 versão 15,3 e posteriorVisual Studio 2017 version 15.3 and later

Inserir separadores de dígitos em literaisInsert digit separators into literals

Essa Ação Rápida permite que você adicione caracteres separadores em valores literais.This Quick Action enables you to add separator characters into literal values.

// 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
Linguagens AplicáveisApplicable Languages Versão com suporteSupported Version
C# 7.0+ e Visual Basic 14+C# 7.0+ and Visual Basic 14+ Visual Studio 2017 versão 15,3 e posteriorVisual Studio 2017 version 15.3 and later

Usar nomes de tupla explícitaUse explicit tuple names

Esta Ação rápida identifica áreas em que o nome da tupla explícita pode ser usado em vez de Item1, Item2, etc.This Quick Action identifies areas where the explicit tuple name can be used rather than 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
ID do diagnósticoDiagnostic ID Linguagens AplicáveisApplicable Languages Versão com suporteSupported Version
IDE0033IDE0033 C# 7.0+ e Visual Basic 15+C# 7.0+ and Visual Basic 15+ Visual Studio 2017 e posteriorVisual Studio 2017 and later

Usar nomes inferidosUse inferred names

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.This Quick Action points out when code can be simplified to use inferred member names in anonymous types, or inferred element names in tuples.

// 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ósticoDiagnostic ID Linguagens AplicáveisApplicable Languages Versão com suporteSupported Version
IDE0037IDE0037 C#C# Visual Studio 2017 versão 15.5 e posteriorVisual Studio 2017 version 15.5 and later
IDE0037IDE0037 C# 7.1+C# 7.1+ Visual Studio 2017 versão 15.5 e posteriorVisual Studio 2017 version 15.5 and later

Desconstruir declaração de tuplaDeconstruct tuple declaration

Esta Ação Rápida permite desconstruir declarações de variável de tupla.This Quick Action enables deconstructing tuple variable declarations.

// 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ósticoDiagnostic ID Linguagens AplicáveisApplicable Languages Versão com suporteSupported Version
IDE0042IDE0042 C# 7.0+C# 7.0+ Visual Studio 2017 versão 15.5 e posteriorVisual Studio 2017 version 15.5 and later

Tornar o método síncronoMake method synchronous

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.When using the async or Async keyword on a method, it's expected that inside that method the await or Await keyword is also used. 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.However, if this isn't the case, a Quick Action appears that makes the method synchronous by removing the async or Async keyword and changing the return type. Use a opção Tornar o método síncrono do menu Ações Rápidas.Use the Make method synchronous option from the Quick Actions menu.

// 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
ID do erroError ID Linguagens AplicáveisApplicable Languages
CS1998, BC42356CS1998, BC42356 C# e Visual BasicC# and Visual Basic

Tornar o método assíncronoMake method asynchronous

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.When using the await or Await keyword inside of a method, it's expected that the method is marked with the async or Async keyword. No entanto, se esse não for o caso, é exibida uma Ação Rápida que torna o método assíncrono.However, if this isn't the case, a Quick Action appears that makes the method asynchronous. Use a opção Tornar o método ou a função síncrona do menu Ações Rápidas.Use the Make method/Function asynchronous option from the Quick Actions menu.

// 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
ID do erroError ID Linguagens AplicáveisApplicable Languages Versão com suporteSupported Version
CS4032, BC37057CS4032, BC37057 C# e Visual BasicC# and Visual Basic Visual Studio 2017 e posteriorVisual Studio 2017 and later

Confira tambémSee also