Häufige schnelle Aktionen

Die Abschnitte in diesem Thema enthalten einige der häufig vorkommenden Schnellen Aktionen, die sowohl für C#- als auch für Visual Basic-Code gültig sind. Diese Aktionen stellen Codefehlerbehebungen für Compilerdiagnosen oder die integrierten .NET Compiler Platform Analyzer in Visual Studio dar.

Aktionen, die Fehler korrigieren

Über die schnellen Aktionen in diesem Abschnitt werden Fehler in Code behoben, durch die der Build fehlschlagen würde. Wenn schnelle Aktionen zur Behebung eines Fehlers auf einer Codezeile verfügbar sind, wird am Rand oder unterhalb der roten Wellenlinie eine Glühbirne mit einem roten „x“ angezeigt.

Richtige falsch geschriebenes Symbol oder Schlüsselwort

Wenn Sie versehentlich einen Typ oder ein Schlüsselwort in Visual Studio falsch schreiben, korrigiert diese schnelle Aktion diesen Fehler für Sie. Diese Elemente werden im Fehlerbehebungsmenü als „<Falsch geschriebenes Wort> in <richtiges Wort> ändern“ 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	Anzuwendende Sprachen
CS0103, BC30002	C# und Visual Basic

Lösen von Git-Mergekonflikten

Diese schnellen Aktionen ermöglichen das Auflösen von Mergekonflikten durch das „Vornehmen einer Änderung“, wodurch der in Konflikt stehende Code und die Marker entfernt werden.

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

    }
}

// Take changes from 'HEAD'

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

    }
}

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

Aktionen, die nicht benötigten Code entfernen

Nicht benötigte Using- und Import-Anweisungen entfernen

Die schnelle Aktion Nicht benötigte Using-/Import-Anweisungen entfernen entfernt jede nicht benötigte using- und Import-Anweisung aus der aktuellen Datei. Wenn Sie dieses Element auswählen, werden nicht benötigte import-Anweisungen des Namespaces entfernt.

Nicht benötigte Umwandlung entfernen

Wenn Sie einen Typ in einen anderen Typ umwandeln, der keine Umwandlung benötigt, entfernt das Element der schnellen Aktion Remove Unnecessary Cast (Nicht benötigte Umwandlung entfernen) die nicht benötigte 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

Entfernen nicht verwendeter Variablen

Diese schnelle Aktion ermöglicht Ihnen das Entfernen von Variablen, die zwar 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	Anzuwendende Sprachen	Unterstützte Version
CS0219, BC42024	C# und Visual Basic	Visual Studio 2017, Version 15.3 und höher

Entfernen des Typs aus dem default-Wertausdruck

Diese schnelle Aktion 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	Anzuwendende 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 Using- und Import-Anweisungen für Typen in Verweisassemblys, NuGet-Paketen oder anderen Typen in Ihrer Projektmappe

Using-Typen in anderen Projekten in Ihrer Projektmappe zeigen die Schnellaktion automatisch an, für alle anderen Typen müssen sie auf der Registerkarte Tools > Optionen > Text-Editor > C# oder Visual Basic > Erweitert aktiviert werden:

• Usings/Imports für Typen in Verweisassemblys vorschlagen
• Usings/Imports für Typen in NuGet-Paketen vorschlagen

Wenn dies aktiviert ist, wird die using- oder import-Anweisung erstellt, wenn Sie einen Typ in einem Namespace verwenden, der zu diesem Zeitpunkt nicht importiert ist, aber in einer Verweisassembly oder einem NuGet-Paket vorhanden ist.

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	Anzuwendende Sprachen
CS0103, BC30451	C# und Visual Basic

Fügen Sie fehlende Fälle/einen Standardfall/beides hinzu

Wenn Sie eine switch-Anweisung in C# oder eine Select Case-Anweisung in Visual Basic erstellen, können Sie mit einer Codeaktion automatisch fehlende Fallelemente, eine Standardfallanweisung oder beides hinzufügen.

Betrachten Sie die folgende Enumeration und die leere Anweisung switch oder 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

Mithilfe der schnellen Aktion Beide hinzufügen werden fehlende Fälle ausgefüllt, und ein Standardfall wird hinzugefügt:

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	Anzuwendende Sprachen	Unterstützte Version
IDE0010	C# und Visual Basic	Visual Studio 2017, Version 15.3 und höher

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

Diese schnelle Aktion ermöglicht Ihnen das Hinzufügen einer Prüfung zu Ihrem Code, um zu ermitteln, 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));
    }
}

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

Hinzufügen des Argumentnamens

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

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

Hinzufügen von geschweiften Klammern

Die schnelle Aktion „Geschweifte Klammern hinzufügen“ umschließt einzeilige if-Anweisungen mit geschweiften Klammern.

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

// Add braces

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

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

Hinzufügen und Sortieren von Modifizierern

Diese schnellen Aktionen unterstützen Sie beim Organisieren von Modifizieren, indem es Ihnen ermöglicht wird, vorhandene Zugriffsmodifizierer zu sortieren und fehlende hinzuzufügen.

// 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	Anzuwendende 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 von if-Konstrukten in switch-Konstrukte

Mit dieser schnellen Aktionen 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

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

Konvertieren in eine interpolierte Zeichenfolge

Interpolierte Zeichenfolgen sind eine einfache Möglichkeit, Zeichenfolgen mit eingebetteten Variablen auszudrücken, ähnlich wie mit der String.Format -Methode. Diese schnelle Aktion erkennt Fälle, in denen Zeichenfolgen verkettet sind oder String.Format verwenden, und ändert die Verwendung in eine interpolierte Zeichenfolge.

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"

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

Verwenden des Objektinitialisierers

Durch diese Schnellaktion können Sie den Objektinitialisierer verwenden, anstatt den Konstruktor aufzurufen. Dadurch müssen Sie keine zusätzlichen Zeilen mit Zuweisungsanweisungen erstellen.

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	Anzuwendende Sprachen	Unterstützte Version
IDE0017	C# und Visual Basic	Visual Studio 2017 und höher

Verwenden des Auflistungsinitialisierers

Durch diese schnelle Aktion können Sie den Auflistungsinitialisierer statt mehrerer Aufrufe der Add-Methode Ihrer 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	Anzuwendende Sprachen	Unterstützte Version
IDE0028	C# und Visual Basic	Visual Studio 2017 und höher

Konvertieren der Auto-Eigenschaft in eine vollständige Eigenschaft

Durch diese schnelle Aktion können Sie eine Auto-Eigenschaft in eine vollständige Eigenschaft (und umgekehrt) konvertieren.

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

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

Konvertieren des Blocktexts in Ausdruckskörpermembers

Durch diese schnelle Aktion können Sie Blocktexte in Ausdruckskörpermembers für Methoden, Konstruktoren, Operatoren, Eigenschaften, Indexer und Accessoren 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	Anzuwendende Sprachen	Unterstützte Version
IDE0021-27	C# 6.0 und höher	Visual Studio 2017 und höher

Konvertieren von anonymen Funktionen in lokale Funktionen

Diese schnelle Aktion konvertiert anonyme Funktionen in lokale Funktionen.

// 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	Anzuwendende Sprachen	Unterstützte Version
IDE0041	C# 7.0 und höher	Visual Studio 2017, Version 15.5 und höher

Diese schnelle Aktion schlägt nach Möglichkeit die Verwendung des Musterabgleichs statt dem ReferenceEquals-Codierungsmuster vor.

// 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	Anzuwendende Sprachen	Unterstützte Version
IDE0039	C# 7.0 und höher	Visual Studio 2017, Version 15 und höher

Einführen des Musterabgleichs

Diese schnelle Aktion schlägt die Verwendung des Musterabgleichs mit Umwandlungen und NULL-Überprü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	Anzuwendende Sprachen	Unterstützte Version
IDE0020	C# 7.0 und höher	Visual Studio 2017 und höher
IDE0019	C# 7.0 und höher	Visual Studio 2017 und höher

Ändern der Basis für numerische Literale

Mithilfe dieser schnellen Aktion können Sie ein numerisches Literal von einem numerischen Basissystem in ein anderes konvertieren. Beispielsweise können Sie eine Zahl in das hexadezimale oder binäre Format ä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

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

Einfügen von Zifferntrennzeichen in Literale

Mithilfe dieser schnellen Aktion können Sie Zifferntrennzeichen in Literale einfü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

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

Verwenden expliziter Tupelnamen

Diese schnelle Aktion identifiziert Bereiche, in denen Tupelnamen statt Item1, Item2 usw. verwendet werden können.

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	Anzuwendende Sprachen	Unterstützte Version
IDE0033	C# 7.0 und höher und Visual Basic 15 und höher	Visual Studio 2017 und höher

Verwenden von abgeleiteten Namen

Diese schnelle Aktion zeigt auf, wenn der Code vereinfacht werden kann, damit abgeleitete Membernamen in anonymen Typen oder abgeleitete Elementnamen in Tupeln verwendet werden.

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

Durch diese schnelle Aktion können Sie Variablendeklarationen von Tupeln dekonstruieren.

// 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	Anzuwendende Sprachen	Unterstützte Version
IDE0042	C# 7.0 und höher	Visual Studio 2017, Version 15.5 und höher

Methode als synchron deklarieren

Wenn Sie das Schlüsselwort async oder Async für eine Methode verwenden, wird erwartet, dass das Schlüsselwort await oder Await ebenfalls in der Methode verwendet wird. Sollte dies nicht der Fall sein, erscheint eine schnelle Aktion, die die Methode als synchron deklariert, indem das Schlüsselwort async oder Async entfernt und der Rückgabetyp geändert wird. Verwenden Sie die Option Make Method Synchronous (Methode als synchron deklarieren) aus dem Menü für 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	Anzuwendende Sprachen
CS1998, BC42356	C# und Visual Basic

Methode als asynchron deklarieren

Wenn Sie das Schlüsselwort await oder Await innerhalb einer Methode verwenden, wird erwartet, dass die Methode mit dem Schlüsselwort async oder Async gekennzeichnet ist. Sollte dies allerdings nicht der Fall sein, wird eine Schnellaktion angezeigt, die die Methode als asynchron deklariert. Verwenden Sie die Option Make method/Function asynchronous (Methode/Funktion als asynchron deklarieren) aus dem Menü für 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	Anzuwendende Sprachen	Unterstützte Version
CS4032, BC37057	C# und Visual Basic	Visual Studio 2017 und höher

Weitere Informationen

• Schnelle Aktionen