Typowe szybkie akcje

W sekcjach w tym temacie wymieniono niektóre typowe szybkie akcje , które mają zastosowanie zarówno w kodzie C#, jak i Visual Basic. Te akcje to poprawki kodu dla diagnostyki kompilatora lub wbudowanych analizatorów platformy kompilatora .NET w programie 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.

Poprawianie błędnie napisanego symbolu lub słowa kluczowego

Jeśli przypadkowo przegapisz typ lub słowo kluczowe w programie Visual Studio, ta szybka akcja automatycznie go poprawi. Te elementy będą widoczne w menu żarówki jako "Zmień< błędnie napisane słowo>" na "<poprawne słowo>". Na przykład:

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

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 "zmianę", która usuwa kod powodujący konflikt i znaczniki.

// 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	Program Visual Studio 2017 w wersji 15.3 lub nowszej

Akcje, które usuwają niepotrzebny kod

Usuwanie niepotrzebnych operacji/importów

Polecenie Usuń niepotrzebne użycie/ Import Szybkie działanie usuwa wszystkie nieużywane using dyrektywy i Import dla bieżącego pliku. Po wybraniu tego elementu nieużywane importy przestrzeni nazw zostaną usunięte.

Usuń niepotrzebne rzutowanie

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

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

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	Program Visual Studio 2017 w wersji 15.3 lub nowszej

Usuń typ 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+	Program Visual Studio 2017 w wersji 15.3 lub nowszej

Akcje, które dodają brakujący kod

Dodawanie elementów 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 muszą być włączone z poziomu karty Narzędzia > Opcje > Edytor > tekstu C# lub Visual Basic > Advanced :

• Sugerowanie użycia/importów dla 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 pakiecie NuGet, zostanie utworzona dyrektywa using lub 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")

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 języku Visual Basic można użyć akcji kodu, aby automatycznie dodać brakujące elementy sprawy, domyślną instrukcję przypadku lub obie te elementy.

Rozważ następujące wyliczenie i pustą switch instrukcję lub 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

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

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

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

Dodawanie nawiasów klamrowych

Polecenie Dodaj nawiasy klamrowe 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#	Program Visual Studio 2017 lub nowszy

Dodawanie i porządkowanie modyfikatorów

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	Program Visual Studio 2017 w wersji 15.5 lub nowszej
IDE0040	C# i Visual Basic	Program Visual Studio 2017 w wersji 15.5 lub nowszej

Przekształcenia kodu

Konwertowanie konstrukcji "if" na "switch"

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

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

Odpowiednie języki	Obsługiwana wersja
C# i Visual Basic	Program Visual Studio 2017 w wersji 15.3 lub nowszej

Konwertowanie na ciąg interpolowany

Ciągi interpolowane są łatwym sposobem wyrażania ciągów ze zmiennymi osadzonymi, podobnie jak w przypadku metody String.Format . Ta szybka akcja rozpoznaje przypadki, w których ciągi są łączone lub przy użyciu ciągu String.Format, a następnie zmienia użycie na ciąg interpolowany.

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"

Odpowiednie języki	Obsługiwana wersja
C# 6.0+ i Visual Basic 14+	Program Visual Studio 2017 lub nowszy

Używanie inicjatorów obiektów

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

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}

Identyfikator diagnostyczny	Odpowiednie języki	Obsługiwana wersja
IDE0017	C# i Visual Basic	Program Visual Studio 2017 lub nowszy

Używanie inicjatorów kolekcji

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

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}

Identyfikator diagnostyczny	Odpowiednie języki	Obsługiwana wersja
IDE0028	C# i Visual Basic	Program Visual Studio 2017 lub nowszy

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

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

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

Odpowiednie języki	Obsługiwana wersja
C# i Visual Basic	Program Visual Studio 2017 w wersji 15.5 lub nowszej

Konwertowanie treści bloku na składową wyrażeń

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+	Program Visual Studio 2017 lub nowszy

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+	Program Visual Studio 2017 w wersji 15.5 lub nowszej

Ta szybka akcja sugeruje użycie dopasowywania wzorców, a nie 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 wzorca

Ta szybka akcja sugeruje użycie dopasowywania 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+	Program Visual Studio 2017 lub nowszy
IDE0019	C# 7.0+	Program Visual Studio 2017 lub nowszy

Zmiana podstawy literałów liczbowych

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

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

Odpowiednie języki	Obsługiwana wersja
C# 7.0+ i Visual Basic 14+	Program 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.

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

Odpowiednie języki	Obsługiwana wersja
C# 7.0+ i Visual Basic 14+	Program 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.

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

Identyfikator diagnostyczny	Odpowiednie języki	Obsługiwana wersja
IDE0033	C# 7.0+ i Visual Basic 15+	Program Visual Studio 2017 lub nowszy

Używanie wywnioskowanych nazw

Ta szybka akcja wskazuje, kiedy można uprościć kod do 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#	Program Visual Studio 2017 w wersji 15.5 lub nowszej
IDE0037	C# 7.1+	Program 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+	Program Visual Studio 2017 w wersji 15.5 lub nowszej

Wykonaj synchroniczną metodę

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

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

Identyfikator błędu	Odpowiednie języki
CS1998, BC42356	C# i Visual Basic

Make, metoda asynchroniczna

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 Make method/Function z menu Szybkie akcje.

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

Identyfikator błędu	Odpowiednie języki	Obsługiwana wersja
CS4032, BC37057	C# i Visual Basic	Program Visual Studio 2017 lub nowszy

Zobacz też

• Szybkie akcje