C# Quick Actions und Refactorings

Visual Studio Code bietet Ihnen viele Möglichkeiten, Ihren Quellcode zu refaktorieren, sowie Quick Fixes, um Code zu generieren und Probleme während der Codierung zu beheben. Um darauf zuzugreifen, klicken Sie auf das Symbol der 'Glühbirne', das erscheint, oder verwenden Sie den Befehl Quick Fix ⌘. (Windows, Linux Ctrl+.), um eine Liste von Quick Fixes und Refactoring-Optionen anzuzeigen. Sie können auch mit der rechten Maustaste auf den Editor klicken und Refactor ⌃⇧R (Windows, Linux Ctrl+Shift+R) auswählen, um nur Refactoring-Optionen anzuzeigen.

Unterstützte Refactorings und Quick Fixes

• await hinzufügen
• Konstruktorparameter aus Mitgliedern hinzufügen
• DebuggerDisplay-Attribut hinzufügen
• Expliziten Cast hinzufügen
• Dateiheader hinzufügen
• Fehlende usings / Imports hinzufügen
• Benannten Argument hinzufügen
• Anonymen Typ in Klasse konvertieren
• Zwischen Auto-Property und voller Property konvertieren
• Zwischen direktem Cast und as-Ausdruck konvertieren
• Zwischen for-Schleife und foreach-Anweisung konvertieren
• Zwischen Get-Methode und Property konvertieren
  • Get-Methode in Property konvertieren
  • Property in Get-Methode konvertieren
• Zwischen if- und switch-Anweisungen konvertieren
• Zwischen regulärem String und verbatim String konvertieren
• Klasse in Record konvertieren
• Lokale Funktion in Methode konvertieren
• Numerisches Literal in Hexadezimal-, Dezimal- oder Binärzahl konvertieren
• Platzhalter in interpolierten String konvertieren
• Regulären String in interpolierten String konvertieren
• Tuple in Struct konvertieren
• Feld kapseln
• Vergleichsoperatoren generieren
• Standardkonstruktoren generieren
• Parameter generieren
• Alle Member explizit implementieren
• Alle Member implizit implementieren
• Methode inline
• Temporäre Variable inline
• Lokale Variable für Ausdruck einführen
• Parameter einführen
• using-Anweisung einführen
• Bedingte Ausdrücke und logische Operationen invertieren
• if invertieren
• Member statisch machen
• Deklaration nahe Referenz verschieben
• Typ in passende Datei verschieben
• for-Anweisung umkehren
• if-Anweisungen aufteilen oder zusammenführen
• Expliziten Typ verwenden
• Impliziten Typ verwenden
• Lambda-Ausdruck oder Block-Body verwenden
• Rekursive Muster verwenden
• Wrap, Einrücken und Ausrichten von Refactorings
  • Aufrufkette umschließen und ausrichten
  • Parameter oder Argumente umschließen, einrücken und ausrichten
  • Binäre Ausdrücke umschließen

await hinzufügen

Was: Fügt das Schlüsselwort await zu einem Funktionsaufruf hinzu.

Wann: Wenn Sie eine Funktion innerhalb einer asynchronen Methode aufrufen.

Anleitung

1. Setzen Sie den Cursor auf den Funktionsaufruf (wird höchstwahrscheinlich rot unterstrichen sein).
2. Drücken Sie ⌘. (Windows, Linux Ctrl+.), um das Menü Quick Actions and Refactorings zu öffnen.
3. Wählen Sie await hinzufügen.

Konstruktorparameter aus Mitgliedern hinzufügen

Was: Generiert einen neuen Konstruktor mit Parametern, basierend auf ausgewählten Klassenmitgliedern.

Wann: Sie führen einen neuen Konstruktor ein und möchten ihn automatisch mit allen korrekten Parametern deklarieren.

Warum: Sie könnten den Konstruktor vor der Verwendung deklarieren, aber diese Funktion generiert ihn automatisch.

Anleitung

1. Heben Sie die Klassenmitglieder hervor, die Sie als Parameter im Konstruktor hinzufügen möchten.
2. Drücken Sie ⌘. (Windows, Linux Ctrl+.), um das Menü Quick Actions and Refactorings zu öffnen.
3. Wählen Sie Konstruktor (<Typ des Mitglieds>, <Typ des Mitglieds>, <usw.>) generieren.

DebuggerDisplay-Attribut hinzufügen

Was: Das DebuggerDisplay-Attribut steuert, wie ein Objekt, eine Eigenschaft oder ein Feld in den Variablenfenstern des Debuggers angezeigt wird.

Wann: Sie möchten Eigenschaften im Debugger programmgesteuert in Ihrem Code anheften.

Warum: Das Anheften von Eigenschaften ermöglicht es Ihnen, Objekte schnell anhand ihrer Eigenschaften zu inspizieren, indem diese Eigenschaft an den Anfang der Eigenschaftsliste des Objekts im Debugger verschoben wird.

Anleitung

1. Setzen Sie Ihren Cursor auf einen Typ, Delegaten, eine Eigenschaft oder ein Feld.
2. Drücken Sie ⌘. (Windows, Linux Ctrl+.), um das Menü Quick Actions and Refactorings zu öffnen, und wählen Sie DebuggerDisplay-Attribut hinzufügen.
3. Das DebuggerDisplay-Attribut wird zusammen mit einer automatischen Methode hinzugefügt, die den Standard-ToString() zurückgibt.

Expliziten Cast hinzufügen

Was: Ermöglicht das automatische Hinzufügen eines expliziten Casts zu einem Ausdruck, basierend auf der Verwendung.

Wann: Sie müssen einen expliziten Cast zu einem Ausdruck hinzufügen und möchten ihn automatisch korrekt zuweisen.

Warum: Sie könnten einen expliziten Cast manuell zu einem Ausdruck hinzufügen, aber diese Funktion fügt ihn automatisch basierend auf dem Code-Kontext hinzu.

Anleitung

1. Platzieren Sie Ihren Cursor auf dem Fehler.
2. Drücken Sie ⌘. (Windows, Linux Ctrl+.), um das Menü Quick Actions and Refactorings zu öffnen.
3. Wählen Sie Expliziten Cast hinzufügen.

Dateiheader hinzufügen

Was: Fügt Dateiheader zu vorhandenen Dateien, Projekten und Lösungen hinzu, die ein EditorConfig verwenden.

Wann: Sie möchten einfach einen Dateiheader zu Dateien, Projekten und Lösungen hinzufügen.

Warum: Ihr Team verlangt von Ihnen, einen Dateiheader für Urheberrechtszwecke einzufügen.

Anleitung

1. Fügen Sie Ihrem Projekt oder Ihrer Lösung ein EditorConfig hinzu, falls Sie noch keins haben.
2. Fügen Sie die folgende Regel zu Ihrer EditorConfig-Datei hinzu: file_header_template.
3. Setzen Sie den Wert der Regel gleich dem Header-Text, den Sie anwenden möchten. Sie können {fileName} als Platzhalter für den Dateinamen verwenden.
4. Setzen Sie Ihren Cursor in die erste Zeile einer beliebigen C#-Datei.
5. Drücken Sie ⌘. (Windows, Linux Ctrl+.), um das Menü Quick Actions and Refactorings zu öffnen.
6. Wählen Sie Dateiheader hinzufügen.

Fehlende usings / Imports hinzufügen

Was: Ermöglicht das sofortige Hinzufügen der notwendigen Importe oder using-Direktiven für kopierten und eingefügten Code.

Wann: Es ist üblich, Code von verschiedenen Stellen in Ihrem Projekt oder anderen Quellen zu kopieren und in neuen Code einzufügen. Diese Quick Action findet fehlende Import-Direktiven für kopierten und eingefügten Code und fordert Sie dann auf, diese hinzuzufügen. Diese Codekorrektur kann auch Referenzen von Projekt zu Projekt hinzufügen.

Warum: Da die Quick Action automatisch notwendige Importe hinzufügt, müssen Sie die using-Direktiven, die Ihr Code benötigt, nicht manuell kopieren.

Anleitung

1. Kopieren Sie Code aus einer Datei und fügen Sie ihn in eine neue ein, ohne die notwendigen using-Direktiven einzufügen. Der resultierende Fehler wird von einer Codekorrektur begleitet, die die fehlenden using-Direktiven hinzufügt.
2. Drücken Sie ⌘. (Windows, Linux Ctrl+.), um das Menü Quick Actions and Refactorings zu öffnen.
3. Wählen Sie Using <Ihre Referenz>, um die fehlende Referenz hinzuzufügen.

Benannten Argument hinzufügen

Was: Hängt ein benanntes Argument an den angegebenen Parameterwert in einem Funktionsaufruf an.

Wann: Wenn Sie eine Methode mit vielen Parametern haben, können Sie benannte Argumente hinzufügen, um Ihren Code leserlicher zu machen.

Anleitung

1. Setzen Sie Ihren Cursor in einen Parameter innerhalb Ihres Funktionsaufrufs.
2. Drücken Sie ⌘. (Windows, Linux Ctrl+.), um das Menü Quick Actions and Refactorings zu öffnen.
3. Wählen Sie Argumentname <Parametername> hinzufügen.

Anonymen Typ in Klasse konvertieren

Was: Konvertiert einen anonymen Typ in eine Klasse.

Wann: Sie haben einen anonymen Typ, den Sie in einer Klasse weiterentwickeln möchten.

Warum: Anonyme Typen sind nützlich, wenn Sie sie nur lokal verwenden. Wenn Ihr Code wächst, ist es schön, eine einfache Möglichkeit zu haben, sie in eine Klasse zu übertragen.

Anleitung

1. Setzen Sie Ihren Cursor auf einen anonymen (var) Typ.
2. Drücken Sie ⌘. (Windows, Linux Ctrl+.), um das Menü Quick Actions and Refactorings zu öffnen.
3. Wählen Sie In Klasse konvertieren.

Zwischen Auto-Property und voller Property konvertieren

Was: Konvertiert zwischen einer automatisch implementierten Property und einer vollen Property.

Wann: Die Logik der Property hat sich geändert.

Warum: Sie können manuell zwischen einer automatisch implementierten Property und einer vollen Property konvertieren, aber diese Funktion erledigt die Arbeit automatisch für Sie.

Anleitung

1. Setzen Sie Ihren Cursor auf den Namen der Property.
2. Drücken Sie ⌘. (Windows, Linux Ctrl+.), um das Menü Quick Actions and Refactorings zu öffnen.
3. Wählen Sie eine der folgenden zwei Optionen

Wählen Sie In volle Property konvertieren.

Wählen Sie Auto-Property verwenden.

Zwischen direktem Cast und 'as'-Ausdruck konvertieren

Was: Konvertiert eine Variable zwischen einem regulären Cast und einem Try-Cast mit dem as-Schlüsselwort.

Wann: Wenn Sie erwarten, dass der Cast unter bestimmten Umständen fehlschlägt (as), oder wenn Sie nie erwarten, dass der Cast fehlschlägt (direkter Cast).

Anleitung

1. Setzen Sie Ihren Cursor auf die Variable.
2. Drücken Sie ⌘. (Windows, Linux Ctrl+.), um das Menü Quick Actions and Refactorings zu öffnen.
3. Wählen Sie eine der folgenden zwei Optionen

Wählen Sie Zu Cast ändern.

Wählen Sie Zu as-Ausdruck ändern.

Zwischen for-Schleife und foreach-Anweisung konvertieren

Was: Wenn Sie eine for-Schleife in Ihrem Code haben, können Sie dieses Refactoring verwenden, um sie in eine foreach-Anweisung zu konvertieren.

Warum: Gründe, warum Sie eine for-Schleife in eine foreach-Anweisung konvertieren möchten, sind:

• Sie verwenden die lokale Schleifenvariable innerhalb der Schleife nicht außer als Index zum Zugriff auf Elemente.
• Sie möchten Ihren Code vereinfachen und die Wahrscheinlichkeit von Logikfehlern in den Initialisierer-, Bedingungs- und Iteratorabschnitten reduzieren.

Gründe, warum Sie eine foreach-Anweisung in eine for-Schleife konvertieren möchten, sind:

• Sie möchten die lokale Schleifenvariable innerhalb der Schleife für mehr als nur den Zugriff auf das Element verwenden.
• Sie iterieren durch ein mehrdimensionales Array und möchten mehr Kontrolle über die Array-Elemente haben.

Anleitung

1. Setzen Sie Ihren Cursor auf das Schlüsselwort foreach oder for.
2. Drücken Sie ⌘. (Windows, Linux Ctrl+.), um das Menü Quick Actions and Refactorings zu öffnen.
3. Wählen Sie eine der folgenden zwei Optionen

Wählen Sie Zu for konvertieren.

Wählen Sie Zu foreach konvertieren.

Zwischen Get-Methode und Property konvertieren

Get-Methode in Property konvertieren

Was: Ermöglicht die Konvertierung einer Get-Methode in eine Property (und optional Ihre Set-Methode).

Wann: Sie haben eine Get-Methode, die keine Logik enthält.

Anleitung

1. Setzen Sie Ihren Cursor auf den Namen Ihrer Get-Methode.
2. Drücken Sie ⌘. (Windows, Linux Ctrl+.), um das Menü Quick Actions and Refactorings zu öffnen.
3. (Optional) Wenn Sie eine Set-Methode haben, können Sie zu diesem Zeitpunkt auch Ihre Set-Methode konvertieren. Wählen Sie <Name der Get-Methode oder Set-Methode> durch Property ersetzen.

Property in Get-Methode konvertieren

Was: Ermöglicht die Konvertierung einer Property in eine Get-Methode.

Wann: Sie haben eine Property, die mehr beinhaltet als nur das sofortige Setzen und Abrufen eines Wertes.

Anleitung

1. Setzen Sie Ihren Cursor auf den Namen Ihrer Get-Methode.
2. Drücken Sie ⌘. (Windows, Linux Ctrl+.), um das Menü Quick Actions and Refactorings zu öffnen.
3. Wählen Sie <Name der Property> durch Methode ersetzen.

Zwischen if- und switch-Anweisungen konvertieren

Was: Konvertiert eine if-Anweisung in eine switch-Anweisung oder in den switch-Ausdruck von C# 8.0.

Wann: Sie möchten eine if-Anweisung in eine switch-Anweisung oder einen switch-Ausdruck und umgekehrt konvertieren.

Warum: Wenn Sie eine if-Anweisung verwenden, ermöglicht dieses Refactoring einen einfachen Übergang zu switch-Anweisungen oder switch-Ausdrücken.

Anleitung

1. Setzen Sie Ihren Cursor auf das Schlüsselwort if.
2. Drücken Sie ⌘. (Windows, Linux Ctrl+.), um das Menü Quick Actions and Refactorings zu öffnen.
3. Wählen Sie aus den folgenden Optionen

Wählen Sie In switch-Anweisung konvertieren.

Wählen Sie In switch-Ausdruck konvertieren.

Wählen Sie In if-Anweisung konvertieren.

Zwischen regulärem String und verbatim String konvertieren

Was: Ermöglicht die Konvertierung zwischen regulären String- und verbatim String-Literalen.

Wann: Sie möchten entweder Platz sparen oder mehr Klarheit in Ihrem Code schaffen.

Warum: Das Konvertieren eines verbatim String-Literals in ein reguläres String-Literal kann Platz sparen. Das Konvertieren eines regulären String-Literals in ein verbatim String-Literal kann mehr Klarheit schaffen.

Anleitung

1. Setzen Sie Ihren Cursor auf das reguläre String- oder verbatim String-Literal.
2. Drücken Sie ⌘. (Windows, Linux Ctrl+.), um das Menü Quick Actions and Refactorings zu öffnen.
3. Wählen Sie aus einer der folgenden Optionen

Wählen Sie In regulären String konvertieren.

Wählen Sie In verbatim String konvertieren.

Klasse in Record konvertieren

Was: Konvertiert Ihre Klasse in einen C#-Record.

Wann: Wenn Sie Ihre Klasse schnell in einen Record ändern möchten, der für die Speicherung von Daten und Unveränderlichkeit maßgeschneidert ist.

Anleitung

1. Setzen Sie Ihren Cursor auf den Klassennamen.
2. Drücken Sie ⌘. (Windows, Linux Ctrl+.), um das Menü Quick Actions and Refactorings zu öffnen.
3. Wählen Sie In Positions-Record konvertieren.

Lokale Funktion in Methode konvertieren

Was: Konvertiert eine lokale Funktion in eine Methode.

Wann: Sie haben eine lokale Funktion, die Sie außerhalb Ihres aktuellen lokalen Kontexts definieren möchten.

Warum: Sie möchten eine lokale Funktion in eine Methode konvertieren, damit Sie sie außerhalb Ihres lokalen Kontexts aufrufen können. Möglicherweise möchten Sie in eine Methode konvertieren, wenn Ihre lokale Funktion zu lang wird. Wenn Sie die Funktion in einer separaten Methode definieren, ist Ihr Code leichter zu lesen.

Anleitung

1. Setzen Sie Ihren Cursor in die lokale Funktion.
2. Drücken Sie ⌘. (Windows, Linux Ctrl+.), um das Menü Quick Actions and Refactorings zu öffnen.
3. Wählen Sie In Methode konvertieren.

Numerisches Literal in Hexadezimal-, Dezimal- oder Binärzahl konvertieren

Was: Konvertiert eine Zahl zwischen einer Hexadezimal-, Binär- oder Dezimalzahl.

Wann: Verwenden Sie, wenn Sie eine Zahl automatisch in die gewünschte Basis konvertieren möchten, ohne die Konvertierung manuell berechnen zu müssen.

Anleitung

1. Setzen Sie Ihren Cursor auf das numerische Literal.
2. Drücken Sie ⌘. (Windows, Linux Ctrl+.), um das Menü Quick Actions and Refactorings zu öffnen.
3. Wählen Sie eine der folgenden Optionen

Wählen Sie In Dezimalzahl konvertieren.

Wählen Sie In Hexadezimalzahl konvertieren.

Wählen Sie In Binärzahl konvertieren.

Platzhalter in interpolierten String konvertieren

Was: Konvertiert einen mit String.Format formatierten Ergebnisstring (oder Platzhalter) in einen interpolierten String.

Wann: Verwenden Sie, wenn Sie schnell einen interpolierten String erhalten möchten.

Warum: Interpolierte Strings können Ihnen eine leserlichere Version von String.Format bieten und Ihnen den direkten Zugriff auf Ihren Variablennamen ermöglichen.

Anleitung

1. Setzen Sie Ihren Cursor auf den String.Format-Platzhalter.
2. Drücken Sie ⌘. (Windows, Linux Ctrl+.), um das Menü Quick Actions and Refactorings zu öffnen.
3. Wählen Sie In interpolierten String konvertieren.

Regulären String in interpolierten String konvertieren

Was: Ändert einen regulären String in einen interpolierten String.

Wann: Verwenden Sie, wenn Sie Ihren Code aufräumen und leserlicher machen möchten.

Anleitung

1. Setzen Sie Ihren Cursor auf den String, den Sie konvertieren möchten.
2. Drücken Sie ⌘. (Windows, Linux Ctrl+.), um das Menü Quick Actions and Refactorings zu öffnen.
3. Wählen Sie In interpolierten String konvertieren.

Tuple in Struct konvertieren

Was: Konvertiert Ihr Tuple in ein struct

Wann: Verwenden Sie, wenn Sie Ihr Tuple schnell in ein struct ändern und feste Daten haben möchten, auf die Sie mehrmals zugreifen möchten.

Anleitung

1. Setzen Sie Ihren Cursor auf das Tuple.

2. Drücken Sie ⌘. (Windows, Linux Ctrl+.), um das Menü Quick Actions and Refactorings zu öffnen.

3. Wählen Sie eine der folgenden Optionen

   • Wählen Sie In struct konvertieren -> Verwendungen im enthaltenden Member aktualisieren
   • Wählen Sie In struct konvertieren -> Verwendungen im enthaltenden Typ aktualisieren
   • Wählen Sie In struct konvertieren -> Verwendungen im enthaltenden Projekt aktualisieren
   • Wählen Sie In struct konvertieren -> Verwendungen in abhängigen Projekten aktualisieren

Feld kapseln

Was: Ermöglicht die Umwandlung eines Feldes in eine Property und die Aktualisierung aller Verwendungen dieses Feldes, um die neu erstellte Property zu verwenden.

Wann: Sie möchten ein Feld in eine Property verschieben und alle Referenzen auf dieses Feld aktualisieren.

Warum: Sie möchten anderen Klassen Zugriff auf ein Feld gewähren, aber nicht, dass diese Klassen direkten Zugriff haben. Indem Sie das Feld in eine Property einhüllen, könnten Sie beispielsweise Code schreiben, um den zugewiesenen Wert zu überprüfen.

Anleitung

1. Setzen Sie Ihren Cursor in den Namen des Feldes, das Sie kapseln möchten.
2. Drücken Sie ⌘. (Windows, Linux Ctrl+.), um das Menü Quick Actions and Refactorings zu öffnen.
3. Wählen Sie eine der folgenden Optionen

Wählen Sie Feld kapseln: <Feldname> (und Property verwenden).

Wählen Sie Feld kapseln: <Feldname> (aber Feld weiter verwenden).

Vergleichsoperatoren generieren

Was: Ermöglicht die Generierung von Vergleichsoperatoren für Typen, die IComparable implementieren.

Wann: Wenn Sie einen Typ haben, der IComparable implementiert, fügen wir automatisch die Vergleichsoperatoren hinzu.

Warum: Wenn Sie einen Werttyp implementieren, sollten Sie in Erwägung ziehen, die Equals-Methode zu überschreiben, um eine höhere Leistung als bei der Standardimplementierung der Equals-Methode von ValueType zu erzielen.

Anleitung

1. Setzen Sie Ihren Cursor entweder innerhalb der Klasse oder auf das IComparable-Schlüsselwort.
2. Drücken Sie ⌘. (Windows, Linux Ctrl+.), um das Menü Quick Actions and Refactorings zu öffnen.
3. Wählen Sie Vergleichsoperatoren generieren aus dem Dropdown-Menü.

Standardkonstruktoren generieren

Was: Ermöglicht das sofortige Generieren des Codes für einen neuen Standardkonstruktor in einer Klasse.

Wann: Sie führen einen neuen Standardkonstruktor ein und möchten ihn automatisch korrekt deklarieren.

Warum: Sie könnten den Konstruktor vor der Verwendung deklarieren, aber diese Funktion generiert ihn automatisch.

Anleitung

1. Setzen Sie Ihren Cursor auf den Klassennamen.
2. Drücken Sie ⌘. (Windows, Linux Ctrl+.), um das Menü Quick Actions and Refactorings zu öffnen.
3. Wählen Sie Konstruktor <Klassenname>() generieren.

Parameter generieren

Was: Generiert automatisch einen Methodenparameter.

Wann: Sie referenzieren eine Variable in einer Methode, die im aktuellen Kontext nicht existiert, und erhalten einen Fehler. Sie können als Codekorrektur einen Parameter generieren.

Warum: Sie können eine Methodensignatur schnell ändern, ohne den Kontext zu verlieren.

Anleitung

1. Setzen Sie Ihren Cursor auf den Variablennamen.
2. Drücken Sie ⌘. (Windows, Linux Ctrl+.), um das Menü Quick Actions and Refactorings zu öffnen.
3. Wählen Sie Parameter generieren.

Alle Member explizit implementieren

Was: Definiert die Methoden Ihrer Schnittstelle explizit in einer Klasse. Eine explizite Schnittstellenimplementierung ist ein Klassenmitglied, das nur über die angegebene Schnittstelle aufgerufen wird.

Wann: Verwenden Sie, wenn

• Sie nicht möchten, dass dieselbe Implementierung für mehrere Schnittstellen aufgerufen wird.
• Sie Fälle lösen möchten, in denen zwei Schnittstellen jeweils unterschiedliche Member mit demselben Namen deklarieren, z. B. eine Eigenschaft und eine Methode.

Anleitung

1. Setzen Sie Ihren Cursor auf eine Schnittstelle, die in einer Klasse implementiert wird.
2. Drücken Sie ⌘. (Windows, Linux Ctrl+.), um das Menü Quick Actions and Refactorings zu öffnen.
3. Wählen Sie Alle Member explizit implementieren

Alle Member implizit implementieren

Was: Definiert die Methoden Ihrer Schnittstelle implizit in einer Klasse. Eine implizite Schnittstellenimplementierung liegt vor, wenn die Methoden und Eigenschaften einer Schnittstelle direkt als öffentliche Methoden zur Klasse hinzugefügt werden.

Anleitung

1. Setzen Sie Ihren Cursor auf eine Schnittstelle, die in einer Klasse implementiert wird.
2. Drücken Sie ⌘. (Windows, Linux Ctrl+.), um das Menü Quick Actions and Refactorings zu öffnen.
3. Wählen Sie Schnittstelle implementieren

Methode inline

Was: Inline-Methoden-Refactoring.

Wann: Sie möchten die Verwendungen einer statischen Methode, einer Instanzmethode und einer Erweiterungsmethode innerhalb eines einzelnen Statement-Bodys ersetzen, mit der Option, die ursprüngliche Methodendeklaration zu entfernen.

Warum: Dieses Refactoring bietet eine klarere Syntax.

Anleitung

1. Setzen Sie Ihren Cursor auf die Verwendung der Methode.
2. Drücken Sie ⌘. (Windows, Linux Ctrl+.), um das Menü Quick Actions and Refactorings zu öffnen.
3. Wählen Sie aus einer der folgenden Optionen

Wählen Sie <Vollqualifizierter Methodenname> inline, um die Inline-Methodendeklaration zu entfernen.

Wählen Sie Inline und <Vollqualifizierter Methodenname> behalten, um die ursprüngliche Methodendeklaration beizubehalten.

Temporäre Variable inline

Was: Ermöglicht das Entfernen einer temporären Variable und deren Ersetzung durch ihren Wert.

Wann: Die Verwendung der temporären Variable erschwert das Verständnis des Codes.

Warum: Das Entfernen einer temporären Variable kann den Code leichter lesbar machen.

Anleitung

1. Setzen Sie Ihren Cursor in die temporäre Variable, die inline erstellt werden soll.
2. Drücken Sie ⌘. (Windows, Linux Ctrl+.), um das Menü Quick Actions and Refactorings zu öffnen.
3. Wählen Sie Temporäre Variable inline.

Lokale Variable für Ausdruck einführen

Was: Ermöglicht das sofortige Generieren einer lokalen Variable, um einen vorhandenen Ausdruck zu ersetzen.

Wann: Sie haben Code, der leicht wiederverwendet werden könnte, wenn er in einer lokalen Variable wäre.

Warum: Sie könnten den Code mehrmals kopieren und einfügen, um ihn an verschiedenen Stellen zu verwenden. Es wäre jedoch besser, die Operation einmal durchzuführen, das Ergebnis in einer lokalen Variable zu speichern und die lokale Variable durchgängig zu verwenden.

Anleitung

1. Setzen Sie Ihren Cursor auf den Ausdruck, den Sie einer neuen lokalen Variable zuweisen möchten.
2. Drücken Sie ⌘. (Windows, Linux Ctrl+.), um das Menü Quick Actions and Refactorings zu öffnen.
3. Wählen Sie aus den folgenden Optionen

Wählen Sie Lokal einführen -> Lokal für <Ausdruck> einführen

Wählen Sie Lokal einführen -> Lokal für alle Vorkommen von <Ausdruck> einführen

Parameter einführen

Was: Ermöglicht das sofortige Generieren eines neuen Parameters, um einen vorhandenen Ausdruck zu ersetzen.

Wann: Sie haben Code, der leicht wiederverwendet werden könnte, wenn er als Parameter wäre.

Warum: Sie könnten den Code mehrmals kopieren und einfügen, um ihn an verschiedenen Stellen zu verwenden. Es wäre jedoch besser, die Operation einmal durchzuführen, das Ergebnis in einem Parameter zu speichern und den Parameter durchgängig zu verwenden.

Anleitung

1. Setzen Sie Ihren Cursor auf den Ausdruck, den Sie einem neuen Parameter zuweisen möchten.
2. Drücken Sie ⌘. (Windows, Linux Ctrl+.), um das Menü Quick Actions and Refactorings zu öffnen.
3. Wählen Sie aus den folgenden Optionen

Wählen Sie Parameter für <Ausdruck> einführen -> und Aufrufstellen direkt aktualisieren

Wählen Sie Parameter für <Ausdruck> einführen -> in extrahierte Methode

Wählen Sie Parameter für <Ausdruck> einführen -> in neue Überladung

using-Anweisung einführen

Was: Fügt eine using-Anweisung / einen Codeblock zu Ihrer IDisposable-Instanz hinzu.

Wann: Sie haben eine IDisposable-Instanz, die Sie korrekt erworben, verwendet und entsorgt haben möchten.

Anleitung

1. Setzen Sie Ihren Cursor auf den Ausdruck, den Sie einem neuen Parameter zuweisen möchten.
2. Drücken Sie ⌘. (Windows, Linux Ctrl+.), um das Menü Quick Actions and Refactorings zu öffnen.
3. Wählen Sie using-Anweisung einführen.

Bedingte Ausdrücke und logische Operationen invertieren

Was: Ermöglicht das Invertieren eines bedingten Ausdrucks oder eines bedingten and \ or-Operators.

Wann: Sie haben einen bedingten Ausdruck oder einen bedingten and \ or-Operator, der besser verstanden würde, wenn er invertiert wäre.

Warum: Das Invertieren eines Ausdrucks oder eines bedingten and \ or-Operators von Hand kann viel länger dauern und möglicherweise Fehler verursachen. Diese Codekorrektur hilft Ihnen, dieses Refactoring automatisch durchzuführen.

Anleitung

1. Setzen Sie Ihren Cursor in einen bedingten Ausdruck oder einen bedingten and \ or-Operator.
2. Drücken Sie ⌘. (Windows, Linux Ctrl+.), um das Menü Quick Actions and Refactorings zu öffnen.
3. Wählen Sie Bedingung invertieren oder && durch || ersetzen

If invertieren

Was: Ermöglicht das Invertieren einer if- oder if else-Anweisung, ohne die Bedeutung des Codes zu ändern.

Wann: Wenn Sie eine if- oder if else-Anweisung haben, die besser verstanden würde, wenn sie invertiert wäre.

Warum: Das Invertieren einer if- oder if else-Anweisung von Hand kann viel länger dauern und möglicherweise Fehler verursachen. Diese Codekorrektur hilft Ihnen, dieses Refactoring automatisch durchzuführen.

Anleitung

1. Setzen Sie Ihren Cursor in eine if- oder if else-Anweisung.
2. Drücken Sie ⌘. (Windows, Linux Ctrl+.), um das Menü Quick Actions and Refactorings zu öffnen.
3. Wählen Sie if invertieren.

Member statisch machen

Was: Member statisch machen.

Wann: Sie möchten, dass ein nicht-statisches Mitglied statisch ist.

Warum: Statische Member verbessern die Lesbarkeit: Zu wissen, dass bestimmter Code isoliert ist, erleichtert das Verstehen, erneute Lesen und Wiederverwenden.

Anleitung

1. Setzen Sie Ihren Cursor auf den Mitgliedsnamen.
2. Drücken Sie ⌘. (Windows, Linux Ctrl+.), um das Menü Quick Actions and Refactorings zu öffnen.
3. Wählen Sie Statisch machen.

Deklaration nahe Referenz verschieben

Was: Ermöglicht das Verschieben von Variablendeklarationen näher an ihre Verwendung.

Wann: Sie haben Variablendeklarationen, die sich in einem engeren Geltungsbereich befinden können.

Warum: Sie könnten es so belassen, wie es ist, aber das kann zu Lesbarkeitsproblemen oder Informationsverdeckung führen. Dies ist eine Gelegenheit zum Refactoring, um die Lesbarkeit zu verbessern.

Anleitung

1. Setzen Sie Ihren Cursor in die Variablendeklaration.
2. Drücken Sie ⌘. (Windows, Linux Ctrl+.), um das Menü Quick Actions and Refactorings zu öffnen.
3. Wählen Sie Deklaration nahe Referenz verschieben.

Typ in passende Datei verschieben

Was: Ermöglicht das Verschieben des ausgewählten Typs in eine separate Datei mit demselben Namen.

Wann: Sie haben mehrere Klassen, Strukturen, Schnittstellen usw. in derselben Datei, die Sie trennen möchten.

Warum: Das Platzieren mehrerer Typen in derselben Datei kann das Auffinden dieser Typen erschweren. Durch das Verschieben von Typen in Dateien mit demselben Namen wird der Code leserlicher und einfacher zu navigieren.

Anleitung

1. Setzen Sie den Cursor in den Namen des Typs, an dem er definiert ist.
2. Drücken Sie ⌘. (Windows, Linux Ctrl+.), um das Menü Quick Actions and Refactorings zu öffnen.
3. Wählen Sie Typ in <typename>.cs verschieben.

for-Anweisung umkehren

Was: Ermöglicht das Invertieren einer for-Anweisung.

Wann: Verwenden Sie, wenn Sie die Bedeutung einer for-Anweisung und ihre Iterationsweise umkehren möchten.

Warum: Das manuelle Invertieren einer for-Anweisung kann viel länger dauern und möglicherweise Fehler verursachen. Diese Codekorrektur hilft Ihnen, dieses Refactoring automatisch durchzuführen.

Anleitung

1. Setzen Sie Ihren Cursor in die for-Anweisung.
2. Drücken Sie ⌘. (Windows, Linux Ctrl+.), um das Menü Quick Actions and Refactorings zu öffnen.
3. Wählen Sie for-Anweisung umkehren.

if-Anweisungen aufteilen oder zusammenführen

Was: if-Anweisungen aufteilen oder zusammenführen.

Wann: Sie möchten eine if-Anweisung, die die Operatoren && oder || verwendet, in eine verschachtelte if-Anweisung aufteilen oder eine if-Anweisung mit einer äußeren if-Anweisung zusammenführen.

Warum: Es ist eine Frage des Stilpräferenzen.

Anleitung

Wenn Sie die if-Anweisung aufteilen möchten

1. Setzen Sie Ihren Cursor in die if-Anweisung neben dem &&- oder ||-Operator.
2. Drücken Sie ⌘. (Windows, Linux Ctrl+.), um das Menü Quick Actions and Refactorings zu öffnen.
3. Wählen Sie In verschachtelte if-Anweisungen aufteilen.

Wenn Sie die innere if-Anweisung mit der äußeren if-Anweisung zusammenführen möchten

1. Setzen Sie Ihren Cursor auf das Schlüsselwort der inneren if.
2. Drücken Sie ⌘. (Windows, Linux Ctrl+.), um das Menü Quick Actions and Refactorings zu öffnen.
3. Wählen Sie Mit verschachtelter if-Anweisung zusammenführen.

Expliziten Typ verwenden

Was: Verwenden Sie dieses Refactoring, um var in einer lokalen Variablendeklaration durch einen expliziten Typ zu ersetzen.

Warum: Um die Lesbarkeit des Codes zu verbessern oder wenn Sie die Variable nicht bei der Deklaration initialisieren möchten.

Allerdings muss var verwendet werden, wenn eine Variable mit einem anonymen Typ initialisiert wird und die Eigenschaften des Objekts später abgerufen werden. Weitere Informationen finden Sie unter Implizit typisierte lokale Variablen (C#).

Anleitung

1. Setzen Sie den Cursor auf das Schlüsselwort var.
2. Drücken Sie ⌘. (Windows, Linux Ctrl+.), um das Menü Quick Actions and Refactorings zu öffnen.
3. Wählen Sie Expliziten Typ anstelle von var verwenden.

Impliziten Typ verwenden

Was: Verwenden Sie dieses Refactoring, um einen expliziten Typ in einer lokalen Variablendeklaration durch var zu ersetzen.

Warum: Um Ihren persönlichen Codierkonventionen zu entsprechen und weniger Code anzuzeigen. Var muss verwendet werden, wenn eine Variable mit einem anonymen Typ initialisiert wird und die Eigenschaften des Objekts später abgerufen werden. Weitere Informationen finden Sie unter Implizit typisierte lokale Variablen (C#).

Anleitung

1. Setzen Sie den Cursor auf das Schlüsselwort des expliziten Typs.
2. Drücken Sie ⌘. (Windows, Linux Ctrl+.), um das Menü Quick Actions and Refactorings zu öffnen.
3. Wählen Sie Impliziten Typ verwenden.

Lambda-Ausdruck oder Block-Body verwenden

Was: Ermöglicht das Refactoring eines Lambda-Ausdrucks, um einen Ausdrucks-Body oder einen Block-Body zu verwenden.

Wann: Sie bevorzugen, dass Lambda-Ausdrücke entweder einen Ausdrucks-Body oder einen Block-Body verwenden.

Warum: Lambda-Ausdrücke können refaktoriert werden, um die Lesbarkeit gemäß Ihrer Benutzereinstellung zu verbessern.

Anleitung

1. Setzen Sie Ihren Cursor rechts von einem Lambda-Operator.
2. Drücken Sie ⌘. (Windows, Linux Ctrl+.), um das Menü Quick Actions and Refactorings zu öffnen.
3. Wählen Sie eine der folgenden Optionen

Wählen Sie Block-Body für Lambda-Ausdrücke verwenden.

Wählen Sie Ausdrucks-Body für Lambda-Ausdrücke verwenden.

Rekursive Muster verwenden

Was: Konvertiert einen Codeblock in die Verwendung eines rekursiven Musters. Dieses Refactoring funktioniert mit switch-Anweisungen, Property-Pattern-Matching, Tuple-Pattern-Matching und positionalem Pattern-Matching.

Wann: Die Verwendung von rekursiven Mustern kann Ihren Code leserlicher / sauberer machen.

Anleitung

1. Setzen Sie Ihren Cursor auf den Ausdruck, den Sie in ein rekursives Muster konvertieren möchten.
2. Drücken Sie ⌘. (Windows, Linux Ctrl+.), um das Menü Quick Actions and Refactorings zu öffnen.
3. Wählen Sie eine der folgenden Optionen

Wählen Sie switch-Anweisung in Ausdruck konvertieren.

Wählen Sie Rekursive Muster verwenden.

Wrap, Einrücken und Ausrichten von Refactorings

Aufrufkette umschließen und ausrichten

Was: Ermöglicht das Umschließen und Ausrichten von Aufrufkette.

Wann: Sie haben eine lange Kette, die aus mehreren Methodenaufrufen in einem Statement besteht.

Warum: Das Lesen einer langen Liste ist einfacher, wenn sie gemäß den Benutzereinstellungen umbrochen oder eingerückt sind.

Anleitung

1. Setzen Sie Ihren Cursor in eine der Aufrufkette.
2. Drücken Sie ⌘. (Windows, Linux Ctrl+.), um das Menü Quick Actions and Refactorings zu öffnen.
3. Wählen Sie Aufrufkette umschließen oder Aufrufkette umschließen und ausrichten, um das Refactoring zu akzeptieren.

Parameter oder Argumente umschließen, einrücken und ausrichten

Was: Ermöglicht das Umschließen, Einrücken und Ausrichten von Parametern oder Argumenten.

Wann: Sie haben eine Methodendeklaration oder einen Methodenaufruf mit mehreren Parametern oder Argumenten.

Warum: Das Lesen einer langen Liste von Parametern oder Argumenten ist einfacher, wenn sie gemäß den Benutzereinstellungen umbrochen oder eingerückt sind.

Anleitung

1. Setzen Sie Ihren Cursor in eine Parameterliste.
2. Drücken Sie ⌘. (Windows, Linux Ctrl+.), um das Menü Quick Actions and Refactorings zu öffnen.
3. Wählen Sie aus den folgenden Optionen

Wählen Sie Jeden Parameter umschließen -> Eingepackte Parameter ausrichten

Wählen Sie Jeden Parameter umschließen -> Alle Parameter einrücken

Wählen Sie Jeden Parameter umschließen -> Eingepackte Parameter einrücken

Binäre Ausdrücke umschließen

Was: Ermöglicht das Umschließen von binären Ausdrücken.

Wann: Sie haben einen binären Ausdruck.

Warum: Das Lesen eines binären Ausdrucks ist einfacher, wenn er gemäß den Benutzereinstellungen umbrochen ist.

Anleitung

1. Setzen Sie Ihren Cursor in den binären Ausdruck.
2. Drücken Sie ⌘. (Windows, Linux Ctrl+.), um das Menü Quick Actions and Refactorings zu öffnen.
3. Wählen Sie Ausdruck umschließen, um das Refactoring zu akzeptieren.