Acciones rápidas comunes

Las secciones de este tema presentan algunas de las acciones rápidas comunes que se aplican a código de C# y de Visual Basic. Estas acciones son correcciones del código para el diagnóstico de compilador o analizadores de .NET Compiler Platform integrados en Visual Studio.

Acciones que corrigen errores

Las acciones rápidas de esta sección corrigen errores en el código que provocarían que se produjera un error en la compilación. Si hay acciones rápidas disponibles para corregir un error en una línea de código, el icono que se muestra en el margen o debajo del subrayado ondulado rojo es una bombilla con una “x” roja en ella.

Corrección de símbolos o palabras clave mal escritos

Si se equivoca al escribir un tipo o una palabra clave en Visual Studio, esta acción rápida lo corrige automáticamente. Verá estos elementos en el menú de bombilla como "Cambiar '<palabra mal escrita>' a '<palabra correcta>'". Por ejemplo:

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

Identificador del error:	Lenguajes aplicables
CS0103, BC30002	C# y Visual Basic

Resolver conflictos de fusión mediante combinación de GIT

Estas acciones rápidas permiten resolver conflictos de fusión mediante combinación de GIT al "adoptar un cambio" que elimina los marcadores y el código en conflicto.

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

    }
}

// Take changes from 'HEAD'

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

    }
}

Identificador del error:	Lenguajes aplicables	Versión compatible
CS8300, BC37284	C# y Visual Basic	Visual Studio 2017 versión 15.3 y posteriores

Acciones que quitan código innecesario

Quitar instrucciones Using o Import innecesarias

La acción rápida Eliminar instrucciones Using innecesarias/Quitar instrucciones Import innecesarias quita todas las directivas using y Import sin usar del archivo actual. Cuando se seleccione este elemento, las importaciones de espacios de nombres sin usar se quitarán.

Quitar conversión innecesaria

Si convierte un tipo a otro que no requiere una conversión, el elemento de acción rápida Quitar conversión innecesaria quitará la conversión innecesaria.

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

Quitar variables no usadas

Esta acción rápida permite quitar variables que se han declarado pero que nunca se han usado en el 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. de diagnóstico	Lenguajes aplicables	Versión compatible
CS0219, BC42024	C# y Visual Basic	Visual Studio 2017 versión 15.3 y posteriores

Quitar el tipo de la expresión de valor predeterminado

Esta acción rápida quita el tipo de valor de una expresión de valor predeterminado y usa el literal default cuando el compilador puede deducir el tipo de la expresión.

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

// Simplify default expression

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

Id. de diagnóstico	Lenguajes aplicables	Versión compatible
IDE0034	C# 7.1+	Visual Studio 2017 versión 15.3 y posteriores

Acciones que agregan código que falta

Agregar instrucciones Using o Import para tipos en ensamblados de referencia, paquetes NuGet u otros tipos de la solución

Si usa tipos ubicados en otros proyectos de la solución, la acción rápida se mostrará automáticamente, pero deberá habilitar los demás en la pestaña Herramientas > Opciones > Editor de texto > C# o Visual Basic > Avanzadas:

• Sugerir instrucciones Using o Import para tipos de ensamblados de referencia
• Sugerir instrucciones Using o Import para tipos de paquetes NuGet

Cuando está habilitado, si usa un tipo de un espacio de nombres que actualmente no se importa pero que existe en un ensamblado de referencia o un paquete NuGet, se creará la directiva 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. de diagnóstico	Lenguajes aplicables
CS0103, BC30451	C# y Visual Basic

Agregar casos que faltan, un caso predeterminado o ambos

Al crear una instrucción switch en C# o una instrucción Select Case en Visual Basic, puede usar una acción de código para agregar automáticamente los elementos de casos que faltan, una instrucción de caso predeterminado o ambos.

Tenga en cuenta la enumeración siguiente y vacíe la instrucción switch o Select Case:

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

Con la acción rápida Agregar ambos se completan los casos omitidos y se agrega un caso predeterminado:

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. de diagnóstico	Lenguajes aplicables	Versión compatible
IDE0010	C# y Visual Basic	Visual Studio 2017 versión 15.3 y posteriores

Agregar comprobaciones de parámetros nulos

Esta acción rápida permite agregar una comprobación en el código para saber si un parámetro es 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));
    }
}

Lenguajes aplicables	Versión compatible
C# y Visual Basic	Visual Studio 2017 versión 15.3 y posteriores

Agregar nombre de 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);

Lenguajes aplicables	Versión compatible
C# y Visual Basic	Visual Studio 2017 versión 15.3 y posteriores

Agregar llaves

Las acción rápida Agregar llaves encapsula llaves alrededor de instrucciones if de una sola línea.

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

// Add braces

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

Id. de diagnóstico	Lenguajes aplicables	Versión compatible
IDE0011	C#	Visual Studio 2017 y versiones posteriores

Agregar y ordenar modificadores

Estas acciones rápidas ayudan a organizar los modificadores permitiendo ordenar los modificadores de accesibilidad existentes y agregar los que faltan.

// 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. de diagnóstico	Lenguajes aplicables	Versión compatible
IDE0036	C# y Visual Basic	Visual Studio 2017 versión 15.5 y posteriores
IDE0040	C# y Visual Basic	Visual Studio 2017 versión 15.5 y posteriores

Transformaciones de código

Convertir la construcción "if" en "switch"

Esta acción rápida permite convertir una construcción if-then-else en una construcción 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

Lenguajes aplicables	Versión compatible
C# y Visual Basic	Visual Studio 2017 versión 15.3 y posteriores

Convertir en una cadena interpolada

Las cadenas interpoladas son una forma sencilla de expresar cadenas con variables insertadas, similar al método String.Format . Esta acción rápida reconoce los casos en los que las cadenas están concatenadas o usan String.Format y cambia el uso a una cadena interpolada.

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"

Lenguajes aplicables	Versión compatible
C# 6.0+ y Visual Basic 14+	Visual Studio 2017 y versiones posteriores

Usar inicializadores de objeto

Esta acción rápida permite usar inicializadores de objeto en lugar de invocar el constructor y tener líneas adicionales de instrucciones de asignación.

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. de diagnóstico	Lenguajes aplicables	Versión compatible
IDE0017	C# y Visual Basic	Visual Studio 2017 y versiones posteriores

Usar inicializadores de colección

Esta acción rápida permite usar inicializadores de colección en lugar de varias llamadas al método Add de la clase.

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. de diagnóstico	Lenguajes aplicables	Versión compatible
IDE0028	C# y Visual Basic	Visual Studio 2017 y versiones posteriores

Convertir propiedad automática en propiedad completa

Esta acción rápida permite convertir una propiedad automática en una propiedad completa y 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

Lenguajes aplicables	Versión compatible
C# y Visual Basic	Visual Studio 2017 versión 15.5 y posteriores

Convertir cuerpo de bloques en miembro con forma de expresión

Esta acción rápida permite convertir cuerpos de bloques en miembros con forma de expresión para métodos, constructores, operadores, propiedades, indizadores y descriptores de acceso.

//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. de diagnóstico	Lenguajes aplicables	Versión compatible
IDE0021-27	C# 6.0+	Visual Studio 2017 y versiones posteriores

Convertir función anónima en función local

Esta acción rápida convierte funciones anónimas en funciones locales.

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

Convertir "ReferenceEquals" en "es null"

Id. de diagnóstico	Lenguajes aplicables	Versión compatible
IDE0041	C# 7.0+	Visual Studio 2017 versión 15.5 y posteriores

Esta acción rápida sugiere el uso de la coincidencia de patrones en lugar del patrón de codificación ReferenceEquals, siempre que sea posible.

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

// Use 'is null' check

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

Id. de diagnóstico	Lenguajes aplicables	Versión compatible
IDE0039	C# 7.0+	Visual Studio 2017 versión 15. y posteriores

Introducir la coincidencia de patrones

Esta acción rápida sugiere el uso de la coincidencia de patrones con conversiones y comprobaciones de valores NULL en 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. de diagnóstico	Lenguajes aplicables	Versión compatible
IDE0020	C# 7.0+	Visual Studio 2017 y versiones posteriores
IDE0019	C# 7.0+	Visual Studio 2017 y versiones posteriores

Cambiar base de literales numéricos

Esta acción rápida le permite convertir un literal numérico de un sistema numérico base a otro. Por ejemplo, puede cambiar un número a hexadecimal o a formato 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

Lenguajes aplicables	Versión compatible
C# 7.0+ y Visual Basic 14+	Visual Studio 2017 versión 15.3 y posteriores

Insertar separadores de dígitos en literales

Esta acción rápida le permite agregar caracteres separadores en valores literales.

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

Lenguajes aplicables	Versión compatible
C# 7.0+ y Visual Basic 14+	Visual Studio 2017 versión 15.3 y posteriores

Usar nombres de tupla explícitos

Esta acción rápida identifica las áreas donde se puede usar el nombre de tupla explícito en lugar de Elemento1, Elemento2, etc.

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. de diagnóstico	Lenguajes aplicables	Versión compatible
IDE0033	C# 7.0+ y Visual Basic 15+	Visual Studio 2017 y versiones posteriores

Usar nombres deducidos

Esta acción rápida indica si el código se puede simplificar para usar nombres de miembros inferidos en tipos anónimos, o bien nombres de elementos inferidos en 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. de diagnóstico	Lenguajes aplicables	Versión compatible
IDE0037	C#	Visual Studio 2017 versión 15.5 y posteriores
IDE0037	C# 7.1+	Visual Studio 2017 versión 15.5 y posteriores

Deconstruir la declaración de tupla

Esta acción rápida permite deconstruir las declaraciones de variable 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. de diagnóstico	Lenguajes aplicables	Versión compatible
IDE0042	C# 7.0+	Visual Studio 2017 versión 15.5 y posteriores

Convertir un método en sincrónico

Cuando se usa la palabra clave async o Async en un método, se espera que dentro de ese método también se use la palabra clave await o Await. En caso contrario, aparecerá una acción rápida para convertir el método en sincrónico si elimina la palabra clave async o Async y cambia el tipo de valor devuelto. Use la opción Convertir el método en sincrónico del menú Acciones rápidas.

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

Identificador del error:	Lenguajes aplicables
CS1998, BC42356	C# y Visual Basic

Convertir un método en asincrónico

Cuando se usa la palabra clave await o Await dentro de un método, se espera que el método esté marcado con la palabra clave async o Async. En caso contrario, aparece una acción rápida para convertir el método en asincrónico. Use la opción Make method/Function asynchronous (Convertir el método/función en asincrónico) del menú Acciones rápidas.

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

Identificador del error:	Lenguajes aplicables	Versión compatible
CS4032, BC37057	C# y Visual Basic	Visual Studio 2017 y versiones posteriores

Vea también

• Acciones rápidas