Běžné rychlé akce

Oddíly v tomto tématu obsahují některé běžné rychlé akce , které se vztahují na kód jazyka C# i Visual Basic. Tyto akce jsou opravy kódu pro diagnostiku kompilátoru nebo integrované analyzátory platformy kompilátoru .NET v sadě Visual Studio.

Akce, které opravují chyby

Rychlé akce v této části opravují chyby v kódu, které by způsobily selhání sestavení. Pokud jsou k dispozici rychlé akce pro opravu chyby na řádku kódu, ikona zobrazená na okraji nebo pod červenou vlnovkou je žárovka s červeným znakem x.

Oprava chybně napsaného symbolu nebo klíčového slova

Pokud v sadě Visual Studio omylem chybně zadáte nebo zadáte klíčové slovo, tato rychlá akce ho automaticky opraví za vás. Tyto položky uvidíte v nabídce žárovky jako "<Změnit chybně napsané slovo>" na "<správné slovo>". Příklad:

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

ID chyby	Příslušné jazyky
CS0103, BC30002	C# a Visual Basic

Řešení konfliktu při slučování Gitu

Tyto rychlé akce umožňují vyřešit konflikty při slučování Gitu tím, že "uděláte změnu", která odebere konfliktní kód a značky.

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

    }
}

// Take changes from 'HEAD'

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

    }
}

ID chyby	Příslušné jazyky	Podporovaná verze
CS8300, BC37284	C# a Visual Basic	Visual Studio 2017 verze 15.3 a novější

Akce, které odeberou nepotřebný kód

Odebrání nepotřebných použití/importů

Akce Odebrat nepotřebné použití/Importy rychlých akcí odebere všechny nepoužívané using a Import direktivy pro aktuální soubor. Když vyberete tuto položku, odeberou se nepoužívané importy oboru názvů.

Odebrání nepotřebného přetypování

Pokud přetypujete typ na jiný typ, který nevyžaduje přetypování, odebere položka Akce Rychlé přetypování nepotřebné přetypování.

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

Odebrání nepoužívaných proměnných

Tato rychlá akce umožňuje odebrat proměnné, které byly deklarovány, ale nikdy se v kódu nepoužívaly.

// 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 diagnostiky	Příslušné jazyky	Podporovaná verze
CS0219, BC42024	C# a Visual Basic	Visual Studio 2017 verze 15.3 a novější

Odebrání typu z výchozího výrazu hodnoty

Tato rychlá akce odebere typ hodnoty z výchozího výrazu hodnoty a použije výchozí literál , když kompilátor může odvodit typ výrazu.

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

// Simplify default expression

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

ID diagnostiky	Příslušné jazyky	Podporovaná verze
IDE0034	C# 7.1 nebo novější	Visual Studio 2017 verze 15.3 a novější

Akce, které přidávají chybějící kód

Přidání použití/importů pro typy v referenčních sestaveních, balíčcích NuGet nebo jiných typech v řešení

Použití typů umístěných v jiných projektech v řešení zobrazí rychlou akci automaticky, ostatní je ale potřeba povolit na kartě Nástroje možnosti textového editoru > C# nebo Rozšířené v jazyce Visual Basic>:> >

• Navrhnout použití/import pro typy v referenčních sestaveních
• Návrhy použití/importů pro typy v balíčcích NuGet

Pokud je tato možnost povolená, použijete-li typ v oboru názvů, který není aktuálně importován, ale existuje v referenčním sestavení nebo balíčku NuGet, vytvoří se direktiva using nebo 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 diagnostiky	Příslušné jazyky
CS0103, BC30451	C# a Visual Basic

Přidání chybějících případů / výchozí případ / obojí

Při vytváření switch příkazu v jazyce C# nebo Select Case příkazu v jazyce Visual Basic můžete pomocí akce kódu automaticky přidat chybějící položky případu, výchozí příkaz case nebo obojí.

Představte si následující výčet a prázdný switch příkaz nebo Select Case příkaz:

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

Použití možnosti Přidat obě rychlé akce vyplní chybějící případy a přidá výchozí případ:

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 diagnostiky	Příslušné jazyky	Podporovaná verze
IDE0010	C# a Visual Basic	Visual Studio 2017 verze 15.3 a novější

Přidání kontrol hodnot null pro parametry

Tato rychlá akce umožňuje přidat do kódu vrácení se změnami, abyste mohli zjistit, jestli má parametr hodnotu 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));
    }
}

Příslušné jazyky	Podporovaná verze
C# a Visual Basic	Visual Studio 2017 verze 15.3 a novější

Přidání názvu argumentu

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

Příslušné jazyky	Podporovaná verze
C# a Visual Basic	Visual Studio 2017 verze 15.3 a novější

Přidání složených závorek

Rychlá akce Přidat složené závorky zalamuje složené závorky kolem příkazů s jedním řádkem if .

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

// Add braces

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

ID diagnostiky	Příslušné jazyky	Podporovaná verze
IDE0011	C#	Visual Studio 2017 a novější

Přidání modifikátorů a jejich pořadí

Tyto rychlé akce pomáhají uspořádat modifikátory tím, že umožňují seřadit existující a přidat chybějící modifikátory přístupnosti.

// 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 diagnostiky	Příslušné jazyky	Podporovaná verze
IDE0036	C# a Visual Basic	Visual Studio 2017 verze 15.5 a novější
IDE0040	C# a Visual Basic	Visual Studio 2017 verze 15.5 a novější

Transformace kódu

Převést konstruktor if na switch

Tato rychlá akce umožňuje převést konstruktor if-then-else na konstruktor přepínače .

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

Příslušné jazyky	Podporovaná verze
C# a Visual Basic	Visual Studio 2017 verze 15.3 a novější

Převod na interpolovaný řetězec

Interpolované řetězce představují snadný způsob, jak vyjádřit řetězce pomocí vložených proměnných, podobně jako String.Format metoda. Tato rychlá akce rozpozná případy, kdy jsou řetězce zřetězeny nebo pomocí String.Format, a změní použití na interpolovaný řetězec.

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"

Příslušné jazyky	Podporovaná verze
C# 6.0+ a Visual Basic 14+	Visual Studio 2017 a novější

Použití inicializátorů objektů

Tato rychlá akce umožňuje používat inicializátory objektů místo vyvolání konstruktoru a další řádky příkazů přiřazení.

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 diagnostiky	Příslušné jazyky	Podporovaná verze
IDE0017	C# a Visual Basic	Visual Studio 2017 a novější

Použití inicializátorů kolekcí

Tato rychlá akce umožňuje používat inicializátory kolekcí místo více volání Add metody třídy.

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 diagnostiky	Příslušné jazyky	Podporovaná verze
IDE0028	C# a Visual Basic	Visual Studio 2017 a novější

Převod automatické vlastnosti na úplnou vlastnost

Tato rychlá akce umožňuje převést automatickou vlastnost na úplnou vlastnost a naopak.

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

Příslušné jazyky	Podporovaná verze
C# a Visual Basic	Visual Studio 2017 verze 15.5 a novější

Převod textu bloku na člena s textem výrazu

Tato rychlá akce umožňuje převést blokové tělo na body výrazů pro metody, konstruktory, operátory, vlastnosti, indexery a přístupové objekty.

//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 diagnostiky	Příslušné jazyky	Podporovaná verze
IDE0021-27	C# 6.0+	Visual Studio 2017 a novější

Převod anonymní funkce na místní funkci

Tato rychlá akce převede anonymní funkce na místní funkce.

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

Convert 'ReferenceEquals' to 'is null'

ID diagnostiky	Příslušné jazyky	Podporovaná verze
IDE0041	C# 7.0+	Visual Studio 2017 verze 15.5 a novější

Tato rychlá akce navrhuje použití porovnávání vzorů místo ReferenceEquals vzoru kódování, pokud je to možné.

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

// Use 'is null' check

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

ID diagnostiky	Příslušné jazyky	Podporovaná verze
IDE0039	C# 7.0+	Visual Studio 2017 verze 15 a novější

Zavedení porovnávání vzorů

Tato rychlá akce navrhuje použití porovnávání vzorů s přetypováními a kontrolami null v jazyce 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 diagnostiky	Příslušné jazyky	Podporovaná verze
IDE0020	C# 7.0+	Visual Studio 2017 a novější
IDE0019	C# 7.0+	Visual Studio 2017 a novější

Změna základu pro číselné literály

Tato rychlá akce umožňuje převést číselný literál z jednoho základního číselného systému na jiný. Můžete například změnit číslo na šestnáctkový nebo binární formát.

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

Příslušné jazyky	Podporovaná verze
C# 7.0+ a Visual Basic 14+	Visual Studio 2017 verze 15.3 a novější

Vložení oddělovačů číslic do literálů

Tato rychlá akce umožňuje přidat oddělovače znaků do hodnot literálů.

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

Příslušné jazyky	Podporovaná verze
C# 7.0+ a Visual Basic 14+	Visual Studio 2017 verze 15.3 a novější

Použití explicitních názvů řazené kolekce členů

Tato rychlá akce identifikuje oblasti, kde lze použít explicitní název řazené kolekce členů místo položky1, položky2 atd.

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 diagnostiky	Příslušné jazyky	Podporovaná verze
IDE0033	C# 7.0+ a Visual Basic 15+	Visual Studio 2017 a novější

Použití odvozených názvů

Tato rychlá akce ukazuje, kdy lze kód zjednodušit tak, aby používal odvozené názvy členů v anonymních typech nebo odvozené názvy elementů v řazených kolekcích členů.

// 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 diagnostiky	Příslušné jazyky	Podporovaná verze
IDE0037	C#	Visual Studio 2017 verze 15.5 a novější
IDE0037	C# 7.1 nebo novější	Visual Studio 2017 verze 15.5 a novější

Dekonstrukční deklarace řazené kolekce členů

Tato rychlá akce umožňuje dekonstrukci deklarací proměnných řazené kolekce členů.

// 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 diagnostiky	Příslušné jazyky	Podporovaná verze
IDE0042	C# 7.0+	Visual Studio 2017 verze 15.5 a novější

Synchronní metoda Make

Při použití async nebo Async klíčového slova v metodě je očekáváno, že uvnitř této metody await se používá také klíčové slovo nebo Await klíčové slovo. Pokud to ale není případ, zobrazí se rychlá akce, která provede synchronní metodu odebráním async nebo Async klíčovým slovem a změnou návratového typu. Použijte synchronní možnost Vytvořit metodu z nabídky Rychlé akce.

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

ID chyby	Příslušné jazyky
CS1998, BC42356	C# a Visual Basic

Asynchronní metoda Make

Při použití await nebo klíčového slova uvnitř metody se očekává, že metoda je označena tímto nebo Async klíčovým slovem async Await. Pokud to ale není případ, zobrazí se rychlá akce, která vytvoří metodu asynchronní. Použijte možnost Vytvořit metodu nebo asynchronní funkci z nabídky Rychlé akce.

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

ID chyby	Příslušné jazyky	Podporovaná verze
CS4032, BC37057	C# a Visual Basic	Visual Studio 2017 a novější

Viz také

• Rychlé akce