Allgemeine schnelle Aktionen

In den Abschnitten in diesem Thema sind einige der allgemeinen Schnellaktionen aufgeführt, die sowohl für C#- als auch für Visual Basic-Code gelten. Bei diesen Aktionen handelt es sich um Codefixes für die Compilerdiagnose oder die integrierten .NET Compiler Platform Analyzers in Visual Studio.

Aktionen, die Fehler beheben

Die Schnellaktionen in diesem Abschnitt beheben Fehler im Code, der dazu führen würde, dass ein Build fehlschlägt. Wenn Schnelle Aktionen verfügbar sind, um einen Fehler in einer Codezeile zu beheben, ist das Symbol, das am Rand oder unter der roten Wellenlinie angezeigt wird, eine Glühbirne mit einem roten "x" darauf.

Falsch geschriebenes Symbol oder Schlüsselwort korrigieren

Wenn Sie in Visual Studio versehentlich einen Typ oder ein Schlüsselwort falsch geschrieben haben, wird dieser Schnellaktion automatisch korrigiert. Diese Elemente werden im Glühbirnenmenü als "<Falsch geschriebenes Wort ändern" in "<Richtiges Wort>>" angezeigt. Beispiel:

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

Fehler-ID	Anwendbare Sprachen
CS0103, BC30002	C# und Visual Basic

Konflikt beim Zusammenführen von Git beheben

Mit diesen Schnellaktionen können Sie Git-Zusammenführungskonflikte lösen, indem Sie "eine Änderung ausführen", wodurch der konfliktierende Code und die Markierungen entfernt werden.

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

    }
}

// Take changes from 'HEAD'

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

    }
}

Fehler-ID	Anwendbare Sprachen	Unterstützte Version
CS8300, BC37284	C# und Visual Basic	Visual Studio 2017, Version 15.3 und höher

Aktionen, die unnötigen Code entfernen

Entfernen unnötiger Verwendungen/Importe

Mit der Schnellaktion "Unnötige Verwendungen/Importe entfernen " werden alle nicht verwendeten using Und Import Direktiven für die aktuelle Datei entfernt. Wenn Sie dieses Element auswählen, werden nicht verwendete Namespaceimporte entfernt.

Nicht benötigte Umwandlung entfernen

Wenn Sie einen Typ in einen anderen Typ umwandeln, der keine Umwandlung erfordert, entfernt das Element "Unnötige Umwandlungsschnellaktion entfernen" die unnötige Umwandlung.

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

Nicht verwendete Variablen entfernen

Mit dieser Schnellaktion können Sie Variablen entfernen, die deklariert, aber nie in Ihrem Code verwendet wurden.

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

// Remove unused variables

// After
public MyMethod()
{
    var used = 1;
    return DoStuff(used);
}

Diagnose-ID	Anwendbare Sprachen	Unterstützte Version
CS0219, BC42024	C# und Visual Basic	Visual Studio 2017, Version 15.3 und höher

Entfernen des Typs aus dem Standardwertausdruck

Diese Schnellaktion entfernt den Werttyp aus einem Standardwertausdruck und verwendet das Standardliteral , wenn der Compiler den Typ des Ausdrucks ableiten kann.

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

// Simplify default expression

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

Diagnose-ID	Anwendbare Sprachen	Unterstützte Version
IDE0034	C# 7.1+	Visual Studio 2017, Version 15.3 und höher

Aktionen, die fehlenden Code hinzufügen

Hinzufügen von Verwendungs-/Importen für Typen in Referenzassemblys, NuGet-Paketen oder anderen Typen in Ihrer Lösung

Wenn Sie Typen in anderen Projekten in Ihrer Projektmappe verwenden, wird die Schnellaktion automatisch angezeigt, die anderen müssen jedoch über die Registerkarte "Extras > Optionen > Text Editor > C# oder Visual Basic > Advanced " aktiviert werden:

• Vorschlagen von Verwendungen/Importen für Typen in Referenzassemblys
• Vorschlagen von Verwendungen/Importen für Typen in NuGet-Paketen

Wenn Sie einen Typ in einem Namespace verwenden, der derzeit nicht importiert wird, aber in einer Referenzassembly oder einem NuGet-Paket vorhanden ist, wird die Using- oder Importdirektive erstellt.

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")

Diagnose-ID	Anwendbare Sprachen
CS0103, BC30451	C# und Visual Basic

Fehlende Fälle/Standardfall hinzufügen/beides

Beim Erstellen einer switch Anweisung in C# oder Select Case Anweisung in Visual Basic können Sie eine Codeaktion verwenden, um automatisch fehlende Fallelemente, eine Standardfall-Anweisung oder beides hinzuzufügen.

Betrachten Sie die folgende Aufzählung und leere switch oder Select Case Anweisung:

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

Die Verwendung der Schnellaktion "Beide hinzufügen" füllt fehlende Fälle aus und fügt einen Standardfall hinzu:

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

Diagnose-ID	Anwendbare Sprachen	Unterstützte Version
IDE0010	C# und Visual Basic	Visual Studio 2017, Version 15.3 und höher

Hinzufügen von NULL-Überprüfungen für Parameter

Mit dieser Schnellaktion können Sie ihrem Code eine Überprüfung hinzufügen, um festzustellen, ob ein Parameter null ist.

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

Anwendbare Sprachen	Unterstützte Version
C# und Visual Basic	Visual Studio 2017, Version 15.3 und höher

Argumentname hinzufügen

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

Anwendbare Sprachen	Unterstützte Version
C# und Visual Basic	Visual Studio 2017, Version 15.3 und höher

Hinzufügen von geschweiften Klammern

Die Klammern "Schnelle Aktion hinzufügen" umschließt geschweifte Klammern um einzeilige if Anweisungen.

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

// Add braces

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

Diagnose-ID	Anwendbare Sprachen	Unterstützte Version
IDE0011	C#	Visual Studio 2017 und höher

Hinzufügen und Bestellen von Modifizierern

Diese Schnellaktionen helfen beim Organisieren von Modifizierern, indem Sie vorhandene und fehlende Barrierefreiheitsmodifizierer sortieren und hinzufügen können.

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

Diagnose-ID	Anwendbare Sprachen	Unterstützte Version
IDE0036	C# und Visual Basic	Visual Studio 2017, Version 15.5 und höher
IDE0040	C# und Visual Basic	Visual Studio 2017, Version 15.5 und höher

Codetransformationen

Konvertieren des "if"-Konstrukts in "switch"

Mit dieser Schnellaktion können Sie ein if-then-else-Konstrukt in ein Switch-Konstrukt konvertieren.

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

Anwendbare Sprachen	Unterstützte Version
C# und Visual Basic	Visual Studio 2017, Version 15.3 und höher

In interpolierte Zeichenfolge konvertieren

Interpolierte Zeichenfolgen sind eine einfache Möglichkeit, Zeichenfolgen mit eingebetteten Variablen auszudrücken, ähnlich der String.Format-Methode . Mit dieser Schnellaktion werden Fälle erkannt, in denen Zeichenfolgen verkettet oder string.Format verwendet werden, und die Verwendung in eine interpolierte Zeichenfolge ändert.

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"

Anwendbare Sprachen	Unterstützte Version
C# 6.0+ und Visual Basic 14+	Visual Studio 2017 und höher

Verwenden des Objektinitialisierers

Mit dieser Schnellaktion können Sie Objektinitialisierer anstelle des Aufrufs des Konstruktors und zusätzliche Zuweisungsanweisungen verwenden.

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}

Diagnose-ID	Anwendbare Sprachen	Unterstützte Version
IDE0017	C# und Visual Basic	Visual Studio 2017 und höher

Verwenden des Auflistungsinitialisierers

Mit dieser Schnellaktion können Sie Sammlungsinitialisierer anstelle mehrerer Aufrufe der Add Klasse verwenden.

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}

Diagnose-ID	Anwendbare Sprachen	Unterstützte Version
IDE0028	C# und Visual Basic	Visual Studio 2017 und höher

Automatische Eigenschaft in vollständige Eigenschaft konvertieren

Mit dieser Schnellaktion können Sie eine automatische Eigenschaft in eine vollständige Eigenschaft konvertieren und umgekehrt.

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

Anwendbare Sprachen	Unterstützte Version
C# und Visual Basic	Visual Studio 2017, Version 15.5 und höher

Konvertieren des Blockkörpers in Ausdruckskörper

Mit dieser Schnellaktion können Sie Blockkörper für Methoden, Konstruktoren, Operatoren, Eigenschaften, Indexer und Accessoren in Ausdruckskörper konvertieren.

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

Diagnose-ID	Anwendbare Sprachen	Unterstützte Version
IDE0021-27	C# 6.0+	Visual Studio 2017 und höher

Anonyme Funktion in lokale Funktion konvertieren

Mit dieser Schnellaktion werden anonyme Funktionen in lokale Funktionen konvertiert.

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

Konvertieren von 'ReferenceEquals' in 'is null'

Diagnose-ID	Anwendbare Sprachen	Unterstützte Version
IDE0041	C# 7.0+	Visual Studio 2017, Version 15.5 und höher

Diese schnelle Aktion schlägt die Verwendung des Musterabgleichs anstelle des ReferenceEquals Codierungsmusters vor, sofern möglich.

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

// Use 'is null' check

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

Diagnose-ID	Anwendbare Sprachen	Unterstützte Version
IDE0039	C# 7.0+	Visual Studio 2017, Version 15. und höher

Musterabgleich einführen

Diese Schnelle Aktion schlägt die Verwendung des Musterabgleichs mit Umwandlungen und NULL-Prüfungen in C# vor.

// 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)
{
    ...
}

Diagnose-ID	Anwendbare Sprachen	Unterstützte Version
IDE0020	C# 7.0+	Visual Studio 2017 und höher
IDE0019	C# 7.0+	Visual Studio 2017 und höher

Ändern der Basis für numerische Literale

Mit dieser Schnellaktion können Sie ein numerisches Literal aus einem Basis-numerischen System in ein anderes konvertieren. Sie können z. B. eine Zahl in hexadezimales oder binärformat ändern.

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

Anwendbare Sprachen	Unterstützte Version
C# 7.0+ und Visual Basic 14+	Visual Studio 2017, Version 15.3 und höher

Einfügen von Zifferntrennzeichen in Literale

Mit dieser Schnellaktion können Sie Trennzeichen zu Literalwerten hinzufügen.

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

Anwendbare Sprachen	Unterstützte Version
C# 7.0+ und Visual Basic 14+	Visual Studio 2017, Version 15.3 und höher

Verwenden expliziter Tupelnamen

Diese Schnelle Aktion identifiziert Bereiche, in denen der explizite Tupelname anstelle von Element1, Element2 usw. verwendet werden kann.

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

Diagnose-ID	Anwendbare Sprachen	Unterstützte Version
IDE0033	C# 7.0+ und Visual Basic 15+	Visual Studio 2017 und höher

Verwenden von abgeleiteten Namen

Diese Schnellaktion weist darauf hin, dass Code vereinfacht werden kann, um abgeleitete Membernamen in anonymen Typen oder abgeleitete Elementnamen in Tupeln zu verwenden.

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

Diagnose-ID	Anwendbare Sprachen	Unterstützte Version
IDE0037	C#	Visual Studio 2017, Version 15.5 und höher
IDE0037	C# 7.1+	Visual Studio 2017, Version 15.5 und höher

Dekonstruieren der Tupeldeklaration

Diese Schnelle Aktion ermöglicht das Decodieren von Tupelvariablendeklarationen.

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

Diagnose-ID	Anwendbare Sprachen	Unterstützte Version
IDE0042	C# 7.0+	Visual Studio 2017, Version 15.5 und höher

Make-Methode synchron

Bei Verwendung des Schlüsselworts oder Async des async Schlüsselworts für eine Methode wird davon ausgegangen, dass innerhalb dieser Methode auch das Schlüsselwort oder Await das await Schlüsselwort verwendet wird. Wenn dies jedoch nicht der Fall ist, wird eine Schnellaktion angezeigt, die die Methode synchron macht, indem sie das Schlüsselwort oder Async das async Schlüsselwort entfernt und den Rückgabetyp ändert. Verwenden Sie die synchrone Option "Methode erstellen " im Menü "Schnelle Aktionen".

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

Fehler-ID	Anwendbare Sprachen
CS1998, BC42356	C# und Visual Basic

Make-Methode asynchron

Bei Verwendung des Schlüsselworts oder Await des await Schlüsselworts innerhalb einer Methode wird erwartet, dass die Methode mit dem Schlüsselwort oder dem async Schlüsselwort Async markiert ist. Wenn dies jedoch nicht der Fall ist, wird eine Schnellaktion angezeigt, die die Methode asynchron macht. Verwenden Sie die asynchrone Option "Methode/Funktion erstellen " im Menü "Schnelle Aktionen".

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

Fehler-ID	Anwendbare Sprachen	Unterstützte Version
CS4032, BC37057	C# und Visual Basic	Visual Studio 2017 und höher

Siehe auch

• Schnellaktionen