Typowe szybkie akcje

Dotyczy:yesnoVisual Studio Visual Studio Code Visual Studio dla komputerów Mac no

Sekcje w tym temacie zawierają listę niektórych typowych szybkich akcji, które mają zastosowanie zarówno do języka C#, jak i Visual Basic kodu. Te akcje to poprawki kodu dla diagnostyki kompilatora lub wbudowane analizatory .NET Compiler Platform w Visual Studio.

Akcje, które naprawiają błędy

Szybkie akcje w tej sekcji naprawiają błędy w kodzie, które mogłyby spowodować niepowodzenie kompilacji. Gdy szybkie akcje są dostępne do naprawienia błędu w wierszu kodu, ikona wyświetlana na marginesie lub poniżej czerwonego wywiążka jest żarówką z czerwonym "x" na nim.

Quick Actions error icon and menu

Popraw błędnie napisany symbol lub słowo kluczowe

Jeśli przypadkowo przegapisz typ lub słowo kluczowe w Visual Studio, ta szybka akcja automatycznie ją poprawi. Te elementy zostaną wyświetlone w menu żarówki jako "Zmień< błędnie napisane słowo>" na "<poprawne słowo>". Przykład:

// Before
private viod MyMethod()
{
}

// Change 'viod' to 'void'

// After
private void MyMethod()
{
}
Identyfikator błędu Odpowiednie języki
CS0103, BC30002 C# i Visual Basic

Rozwiązywanie konfliktu scalania git

Te szybkie akcje umożliwiają rozwiązywanie konfliktów scalania git przez "podjęcie zmiany", co powoduje usunięcie powodującego konflikt kodu i znaczników.

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

    }
}

// Take changes from 'HEAD'

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

    }
}
Identyfikator błędu Odpowiednie języki Obsługiwana wersja
CS8300, BC37284 C# i Visual Basic Visual Studio 2017 w wersji 15.3 lub nowszej

Akcje, które usuwają niepotrzebny kod

Usuwanie niepotrzebnych metod użycia/importów

Polecenie Remove Unnecessary Usings/Import Quick Action usuwa wszelkie nieużywane using dyrektywy i Import dla bieżącego pliku. Po wybraniu tego elementu zostaną usunięte nieużywane importy przestrzeni nazw.

Odpowiednie języki Obsługiwana wersja
C# i Visual Basic Visual Studio 2015 i nowszych

Usuń niepotrzebne rzutowanie

Jeśli rzutujesz typ na inny typ, który nie wymaga rzutowania, element Usuń niepotrzebne rzutowanie szybkiej akcji usuwa niepotrzebne rzutowanie.

// before
int number = (int)3;

// Remove Unnecessary Cast

// after
int number = 3;
Identyfikator diagnostyczny Odpowiednie języki Obsługiwana wersja
IDE0004 C# i Visual Basic Visual Studio 2015 i nowszych

Usuwanie nieużywanych zmiennych

Ta szybka akcja umożliwia usunięcie zmiennych, które zostały zadeklarowane, ale nigdy nie były używane w kodzie.

// Before
public MyMethod()
{
    var unused = 8;
    var used = 1;
    return DoStuff(used);
}

// Remove unused variables

// After
public MyMethod()
{
    var used = 1;
    return DoStuff(used);
}
Identyfikator diagnostyczny Odpowiednie języki Obsługiwana wersja
CS0219, BC42024 C# i Visual Basic Visual Studio 2017 w wersji 15.3 lub nowszej

Usuwanie typu z wyrażenia wartości domyślnej

Ta szybka akcja usuwa typ wartości z wyrażenia wartości domyślnej i używa domyślnego literału , gdy kompilator może wywnioskować typ wyrażenia.

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

// Simplify default expression

// After
void DoWork(CancellationToken cancellationToken = default) { ... }
Identyfikator diagnostyczny Odpowiednie języki Obsługiwana wersja
IDE0034 C# 7.1+ Visual Studio 2017 w wersji 15.3 lub nowszej

Akcje, które dodają brakujący kod

Dodawanie metod using/import dla typów w zestawach referencyjnych, pakietach NuGet lub innych typach w rozwiązaniu

Użycie typów znajdujących się w innych projektach w rozwiązaniu spowoduje automatyczne wyświetlenie szybkiej akcji, jednak inne elementy muszą być włączone na karcie Edytor tekstów > Opcje > narzędzi > C# lub Visual Basic > zaawansowane:

Użycie typów znajdujących się w innych projektach w rozwiązaniu spowoduje automatyczne wyświetlenie szybkiej akcji, jednak inne osoby muszą być włączone na karcie Edytor tekstów > Opcje > narzędzi > C# lub Podstawowa>:

  • Sugerowanie użycia/importowania typów w zestawach referencyjnych
  • Sugerowanie użycia/importowania typów w pakietach NuGet

Po włączeniu, jeśli używasz typu w przestrzeni nazw, która nie jest obecnie importowana, ale istnieje w zestawie odniesienia lub NuGet pakiecie, zostanie utworzona dyrektywa using lub import.

// Before
Debug.WriteLine("Hello");

// using System.Diagnostics;

// After
using System.Diagnostics;

Debug.WriteLine("Hello");
Identyfikator diagnostyczny Odpowiednie języki
CS0103, BC30451 C# i Visual Basic

Dodaj brakujące przypadki/przypadek domyślny/oba

Podczas tworzenia switch instrukcji w języku C# lub Select Case instrukcji w Visual Basic można użyć akcji kodu, aby automatycznie dodać brakujące elementy przypadku, domyślną instrukcję przypadku lub obie te instrukcje.

Rozważ następujące wyliczenie i pustą switch instrukcję lub Select Case :

enum MyEnum
{
    Item1,
    Item2,
    Item3
}

...

MyEnum myEnum = MyEnum.Item1;

switch(myEnum)
{
}

Użycie opcji Dodaj obie szybkie akcje wypełnia brakujące przypadki i dodaje przypadek domyślny:

switch(myEnum)
{
    case MyEnum.Item1:
        break;
    case MyEnum.Item2:
        break;
    case MyEnum.Item3:
        break;
    default:
        break;
}
Identyfikator diagnostyczny Odpowiednie języki Obsługiwana wersja
IDE0010 C# i Visual Basic Visual Studio 2017 w wersji 15.3 lub nowszej

Dodawanie sprawdzania wartości null dla parametrów

Ta szybka akcja umożliwia dodanie ewidencjonowania w kodzie w celu sprawdzenia, czy parametr ma wartość 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));
    }
}
Odpowiednie języki Obsługiwana wersja
C# i Visual Basic Visual Studio 2017 w wersji 15.3 lub nowszej

Dodaj nazwę 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);
Odpowiednie języki Obsługiwana wersja
C# i Visual Basic Visual Studio 2017 w wersji 15.3 lub nowszej

Dodawanie nawiasów klamrowych

Nawiasy klamrowe Dodaj szybkie działanie opakowuje nawiasy klamrowe wokół instrukcji jednowierszowych if .

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

// Add braces

// After
if (true)
{
    return "hello,world";
}
Identyfikator diagnostyczny Odpowiednie języki Obsługiwana wersja
IDE0011 C# Visual Studio 2017 i nowsze

Dodawanie modyfikatorów i określanie ich kolejności

Te szybkie akcje ułatwiają organizowanie modyfikatorów, umożliwiając sortowanie istniejących i dodawanie brakujących modyfikatorów ułatwień dostępu.

// 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;
Identyfikator diagnostyczny Odpowiednie języki Obsługiwana wersja
IDE0036 C# i Visual Basic Visual Studio 2017 w wersji 15.5 lub nowszej
IDE0040 C# i Visual Basic Visual Studio 2017 w wersji 15.5 lub nowszej

Przekształcenia kodu

Konwertowanie konstrukcji "if" na "switch"

Ta szybka akcja umożliwia konwersję konstrukcji if-then-else na konstrukcję przełącznika .

// 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;
}
Odpowiednie języki Obsługiwana wersja
C# i Visual Basic Visual Studio 2017 w wersji 15.3 lub nowszej

Konwertowanie na ciąg interpolowany

Ciągi interpolowane to prosty sposób wyrażania ciągów ze zmiennymi osadzonymi, podobnie jak metoda String.Format . Ta szybka akcja rozpoznaje przypadki, w których ciągi są łączone lub przy użyciu funkcji String.Format, a następnie zmienia użycie na ciąg interpolowany.

// 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";
Odpowiednie języki Obsługiwana wersja
C# 6.0+ i Visual Basic 14+ Visual Studio 2017 i nowsze

Używanie inicjatorów obiektów

Ta szybka akcja umożliwia używanie inicjatorów obiektów zamiast wywoływania konstruktora i używania dodatkowych wierszy instrukcji przypisania.

// Before
var c = new Customer();
c.Age = 21;

// Object initialization can be simplified

// After
var c = new Customer() { Age = 21 };
Identyfikator diagnostyczny Odpowiednie języki Obsługiwana wersja
IDE0017 C# i Visual Basic Visual Studio 2017 i nowsze

Używanie inicjatorów kolekcji

Ta szybka akcja umożliwia używanie inicjatorów kolekcji , a nie wielu wywołań metody Add klasy.

// 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 };
Identyfikator diagnostyczny Odpowiednie języki Obsługiwana wersja
IDE0028 C# i Visual Basic Visual Studio 2017 i nowsze

Konwertowanie właściwości automatycznej na pełną właściwość

Ta szybka akcja umożliwia przekonwertowanie właściwości automatycznej na pełną właściwość i na odwrót.

// Before
private int MyProperty { get; set; }

// Convert to full property

// After
private int MyProperty
{
    get { return _myProperty; }
    set { _myProperty = value; }
}
Odpowiednie języki Obsługiwana wersja
C# i Visual Basic Visual Studio 2017 w wersji 15.5 lub nowszej

Konwertowanie treści bloku na składową typu wyrażenie-bodied

Ta szybka akcja umożliwia konwertowanie ciał blokowych na składowe wyrażeń dla metod, konstruktorów, operatorów, właściwości, indeksatorów i metod dostępu.

//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);
}
Identyfikator diagnostyczny Odpowiednie języki Obsługiwana wersja
IDE0021-27 C# 6.0+ Visual Studio 2017 i nowsze

Konwertowanie funkcji anonimowej na funkcję lokalną

Ta szybka akcja konwertuje funkcje anonimowe na funkcje lokalne.

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

Konwertowanie wartości "ReferenceEquals" na wartość "is null"

Identyfikator diagnostyczny Odpowiednie języki Obsługiwana wersja
IDE0041 C# 7.0+ Visual Studio 2017 w wersji 15.5 lub nowszej

Ta szybka akcja sugeruje użycie dopasowywania wzorców zamiast ReferenceEquals wzorca kodowania, jeśli jest to możliwe.

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

// Use 'is null' check

// After
var value = "someString";
if (value is null)
{
    return;
}
Identyfikator diagnostyczny Odpowiednie języki Obsługiwana wersja
IDE0039 C# 7.0+ Visual Studio 2017 w wersji 15. i nowsze

Wprowadzanie dopasowania do wzorca

Ta szybka akcja sugeruje użycie dopasowania wzorca z rzutami i sprawdzaniem wartości null w języku 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)
{
    ...
}
Identyfikator diagnostyczny Odpowiednie języki Obsługiwana wersja
IDE0020 C# 7.0+ Visual Studio 2017 i nowsze
IDE0019 C# 7.0+ Visual Studio 2017 i nowsze

Zmiana podstawy literałów liczbowych

Ta szybka akcja umożliwia przekonwertowanie literału liczbowego z jednego podstawowego systemu liczbowego na inny. Można na przykład zmienić liczbę na szesnastkowe lub na format binarny.

// Before
int countdown = 2097152;

// Convert to hex

// After
int countdown = 0x200000;
Odpowiednie języki Obsługiwana wersja
C# 7.0+ i Visual Basic 14+ Visual Studio 2017 w wersji 15.3 lub nowszej

Wstawianie separatorów cyfr do literałów

Ta szybka akcja umożliwia dodawanie znaków separatora do wartości literałów.

// Before
int countdown = 1000000;

// Separate thousands

// After
int countdown = 1_000_000;
Odpowiednie języki Obsługiwana wersja
C# 7.0+ i Visual Basic 14+ Visual Studio 2017 w wersji 15.3 lub nowszej

Używanie jawnych nazw krotek

Ta szybka akcja identyfikuje obszary, w których można używać jawnej nazwy krotki, a nie Item1, Item2 itp.

// 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;
Identyfikator diagnostyczny Odpowiednie języki Obsługiwana wersja
IDE0033 C# 7.0+ i Visual Basic 15+ Visual Studio 2017 i nowsze

Używanie wywnioskowanych nazw

Ta szybka akcja wskazuje, kiedy można uprościć kod w celu używania wywnioskowanych nazw składowych w typach anonimowych lub wywnioskowanych nazw elementów w krotkach.

// 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);
Identyfikator diagnostyczny Odpowiednie języki Obsługiwana wersja
IDE0037 C# Visual Studio 2017 w wersji 15.5 lub nowszej
IDE0037 C# 7.1+ Visual Studio 2017 w wersji 15.5 lub nowszej

Dekonstrukcja krotki

Ta szybka akcja umożliwia dekonstrukcję deklaracji zmiennych krotki.

// 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}");
Identyfikator diagnostyczny Odpowiednie języki Obsługiwana wersja
IDE0042 C# 7.0+ Visual Studio 2017 w wersji 15.5 lub nowszej

Make, metoda synchroniczna

W przypadku używania słowa kluczowego async lub Async w metodzie należy oczekiwać, że wewnątrz tej metody await jest również używane słowo kluczowe or Await . Jeśli jednak tak nie jest, zostanie wyświetlona szybka akcja, która powoduje, że metoda jest synchroniczna przez usunięcie słowa kluczowego async lub Async i zmianę zwracanego typu. Użyj opcji Synchronicznej metody Make z menu Szybkie akcje.

// Before
async Task<int> MyAsyncMethod()
{
    return 3;
}

// Make method synchronous

// After
int MyAsyncMethod()
{
    return 3;
}
Identyfikator błędu Odpowiednie języki
CS1998, BC42356 C# i Visual Basic

Asynchroniczna metoda make

W przypadku używania await słowa kluczowego lub Await wewnątrz metody oczekiwano, że metoda jest oznaczona za pomocą słowa kluczowego async lub Async . Jeśli jednak tak nie jest, zostanie wyświetlona szybka akcja, która sprawia, że metoda jest asynchroniczna. Użyj opcji Asynchronicznej metody make/funkcji z menu Szybkie akcje.

// Before
int MyAsyncMethod()
{
    return await Task.Run(...);
}

// Make method asynchronous

// After
async Task<int> MyAsyncMethod()
{
    return await Task.Run(...);
}
Identyfikator błędu Odpowiednie języki Obsługiwana wersja
CS4032, BC37057 C# i Visual Basic Visual Studio 2017 i nowsze

Zobacz też