14 Wege zur Vereinfachung Ihres C#-Codes - Einblicke in die besten C#-Praktiken aus Tim Coreys Video

1. Statische Anwendung für saubereren Code

Tim beginnt damit, dass er zeigt, wie statischer Zugriff wiederholte Aufrufe vereinfachen kann. Durch Erklärungen:

using static System.Console;

using static System.Console;

sie müssen nicht mehr jedem statischen Element das Wort Console... voranstellen.

Dabei geht es um mehr als nur das Entfernen von Wörtern - es geht darum, den statischen Zugang klar zu machen. Tim weist darauf hin, dass diese Kurzschrift die Lesbarkeit des Codes verbessert, wenn Sie ein statisches Mitglied aufrufen, das in einer häufig verwendeten Klasse wie Console oder Math definiert ist.

Im Rahmen guter Programmierpraktiken warnt er jedoch, dass Entwickler Konflikte vermeiden sollten - zwei verschiedene Klassen könnten denselben Namen für ein statisches Mitglied haben. Das Bewusstsein für mögliches unerwartetes Verhalten ist entscheidend.

2. die Initialisierung von Listen mit

In C# können Sie Listen jetzt direkter initialisieren:

List<string> names = ["Tim", "Sue", "Bilbo"];

List<string> names = ["Tim", "Sue", "Bilbo"];

Tim erklärt, dass es nicht darum geht, alles in eine einzige Erklärung zu quetschen - es geht darum, Code zu schreiben, der leichter zu lesen ist und die Leistung durch die Reduzierung von Zeremonien zu optimieren.

Anstatt den Text "new List of String" zu analysieren, sieht der Leser genau, worauf es ankommt: die beschreibenden Namen in der Sammlung. Tim merkt an, dass dies auch bei Arrays und sogar Wörterbüchern funktioniert und mit den Codierungskonventionen übereinstimmt, bei denen Klarheit im Vordergrund steht.

3. zielgruppenspezifisch neu

Eine weitere Zeitersparnis: zielsprachlich neu. Anstelle von:

List<int> numbers = new List<int>();

List<int> numbers = new List<int>();

sie können schreiben:

List<int> numbers = new();

List<int> numbers = new();

Tim betont, dass die Wiederholung des Klassennamens unnötig ist - er steht bereits auf der linken Seite. Dies entspricht guten Kodierungspraktiken, da Redundanz vermieden wird und die Codebasis leichter zu durchsuchen ist.

4. var und anonyme Typen

Tim befasst sich mit var, einer Funktion, die in Kreisen der Kodierungspraktiken für Diskussionen sorgt. Einige mögen es nicht, weil es Variablennamen und -typen verbirgt, aber Tim stellt klar, dass seine wahre Stärke in anonymen Typen liegt.

Bei der Arbeit mit Datenquellen (z. B. SQL über Dapper) zeigt Tim, wie man mit var Objekte "on the fly" erstellen kann:

var parameters = new { FirstName = "Tim", LastName = "Corey" };

var parameters = new { FirstName = "Tim", LastName = "Corey" };

Dies ist perfekt für schriftliche Abfragen oder einmalige Objekte - Sie müssen keine Basisklasse nur für Parameter erstellen. Wie Tim sagt, wird so vermieden, dass die Codebasis mit unnötigen Typen verunreinigt wird, während gleichzeitig aussagekräftige Fehlermeldungen geliefert werden, wenn etwas schief läuft.

5. Dateiübergreifende Namensräume

Tim geht zu dateiübergreifenden Namespaces über und zeigt, wie das geht:

namespace ProjectName
{
    // indented code
}

namespace ProjectName
{
    // indented code
}

wird dies:

namespace ProjectName;

namespace ProjectName;

Durch diese kleine Änderung werden unnötige Einrückungen vermieden und die C#-Namenskonventionen wie die Pascal-Gehäuse für öffentliche Mitglieder eingehalten. Tim erklärt, dass die meisten Dateien nur einen Namespace enthalten, was die Lesbarkeit des Codes verbessert und die logischen Abschnitte aneinanderreiht.

6. Datensätze für einzeilige Datenstrukturen

Mit Datensätzen können Sie Datenobjekte in nur einer Anweisung definieren:

public record EmployeeRecord(int Id, string Name);

public record EmployeeRecord(int Id, string Name);

Tim merkt an, dass dadurch ein vollständiger Typ - Eigenschaften, Unveränderlichkeit und ToString() - mit minimalem Aufwand erzeugt wird. Er ist sich darüber im Klaren, dass abgeleitete Klassenszenarien immer noch Klassen erfordern, aber wenn Ihr Objekt schreibgeschützt ist, folgen Datensätze dem Prinzip der einzigen Verantwortung, indem sie eine Aufgabe gut erfüllen.

7. mustervergleich

Tim demonstriert, wie der Musterabgleich Ihnen hilft, Ausnahmen zu behandeln und Vergleiche sicher durchzuführen. Anstatt ausführliche Typüberprüfungen zu schreiben, können Sie diese kombinieren:

if (emp is EmployeeRecord e)
{
    e.Id = 1;
}

if (emp is EmployeeRecord e)
{
    e.Id = 1;
}

Diese einzelne Zeile prüft und gleicht ab. Tim sagt, dass dies mit guten Programmierpraktiken übereinstimmt - Sie vermeiden Variablennamen mit einem Buchstaben wie x oder y und geben stattdessen beschreibende Namen wie e. Klare Methoden- und Variablennamen erleichtern anderen Entwicklern die Pflege des Codes.

8. String-Interpolation

Um lesbare Strings zu erstellen, demonstriert Tim die String-Interpolation:

$"The employee with ID {e.Id} is {e.Name}"

$"The employee with ID {e.Id} is {e.Name}"

Er weist darauf hin, dass dies sinnvolle Fehlermeldungen und das Schreiben von Kommentaren erleichtert. Statt verworrener Verkettungen können Sie buchstäblich Code schreiben, der sich wie Englisch liest - das verbessert die Codequalität und vereinfacht zukünftige Unit-Tests, die die Ausgabe überprüfen.

9. nameof() für sicheres Refactoring

Tim zeigt, wie nameof() Sie schützt, wenn Sie Code refaktorisieren. Fest kodierte Variablennamen in Strings können zu unerwartetem Verhalten führen, wenn sie umbenannt werden. Aber durch das Schreiben:

nameof(emp)

nameof(emp)

der Compiler aktualisiert jede Verwendung automatisch. Dies ist eine dieser Best Practices, die Ihre Code-Basis gesund hält, wenn Sie sauberen und reorganisierten Code schreiben.

10. Tupel für mehrere Rückgabewerte

Anstatt eine Basisklasse zu erstellen, die nur zwei Werte zurückgibt, verwendet Tim Tupel:

(string FirstName, string LastName) SplitName(string fullName)

(string FirstName, string LastName) SplitName(string fullName)

Dadurch werden unnötige externe Abhängigkeiten vermieden und das Prinzip der einzigen Verantwortung eingehalten - die Methode teilt lediglich einen Namen auf, mehr nicht. Wie Tim sagt, macht Übung den Code besser, wenn man ein Over-Engineering vermeidet.

11. Dekonstruktion

Aufbauend auf Tupeln zeigt Tim, wie Ergebnisse in lokale Variablen zerlegt werden können:

var (firstName, lastName) = SplitName("Tim Corey");

var (firstName, lastName) = SplitName("Tim Corey");

So werden Variablennamen beschreibend gehalten und spätere kryptische Tupel-Syntax vermieden. Tim geht sogar darauf ein, dass ungenutzte Werte verworfen werden (mit _), was Absicht signalisiert - keine Variablennamen mit nur einem Buchstaben, die unerklärt bleiben.

12. Verwerfungen für nicht benötigte Werte

Wenn Sie nicht alle Tupelteile benötigen, empfiehlt Tim, diese zu verwerfen:

var (firstName, _) = SplitName("Tim Corey");

var (firstName, _) = SplitName("Tim Corey");

Dies zeigt anderen Entwicklern, dass Sie absichtlich einen Wert ignorieren - gut für das Testen von Frameworks oder Unit-Tests, bei denen nicht alle Ausgaben wichtig sind.

13. Verwendung von Anweisungen ohne Blöcke

Tim geht auf die Ressourcenverwaltung und Fehlerbehandlung ein. Zuvor würden Sie schreiben:

using (var connection = new SqlConnection(connString))
{
    // work
}

using (var connection = new SqlConnection(connString))
{
    // work
}

Jetzt können Sie verwenden:

using var connection = new SqlConnection(connString);

using var connection = new SqlConnection(connString);

Dies entspricht den SOLID-Grundsätzen, insbesondere dem Prinzip der einzigen Verantwortung und dem Prinzip der Umkehrung der Abhängigkeiten. Tim merkt an, dass diese Syntax gut für externe Abhängigkeiten wie Datenbanken funktioniert und sicherstellt, dass die meisten Ausnahmen sauberer behandelt werden und Verbindungen immer geschlossen werden, wodurch Leistungsprobleme oder sogar SQL-Injection-Szenarien vermieden werden, wenn Verbindungen nicht abgebaut werden.

14. Inline-Variablendeklarationen

Schließlich behandelt Tim Inline-Out-Variablendeklarationen für Dinge wie Parsing:

if (int.TryParse(numberText, out int numberValue))

if (int.TryParse(numberText, out int numberValue))

Hier erstellen Sie die lokale Variable in der gleichen Zeile. Auf diese Weise bleiben die Kodierungskonventionen streng und die Methodennamen aussagekräftig. Indem Sie den Code richtig gruppieren, reduzieren Sie unerwartetes Verhalten und machen künftige Refactoring-Maßnahmen sicherer.

Zusammenfassung

Tim schließt mit seinem Video, indem er die Zuschauer daran erinnert, dass es bei diesen Vereinfachungen nicht darum geht, kryptische Einzeiler zu schreiben, sondern um gute Programmierpraktiken. Funktionen wie die Verwendung von Static, Records, Pattern Matching, Tuples und Discards ermöglichen es Ihnen, sauberes, modernes C# zu schreiben.

Er ermutigt Entwickler, bei der Übernahme dieser Funktionen über Namenskonventionen, Fehlerbehandlung und aussagekräftige Namen nachzudenken. "Code ist dazu da, von Menschen gelesen zu werden", sagt Tim - und wenn man Code schreibt, der leicht zu verstehen ist, macht man sich selbst und anderen Entwicklern das Leben leichter.

Kurz gesagt: Beherzigen Sie diese C#-Best-Practices, befolgen Sie SOLID-Prinzipien wie das Prinzip der einzigen Verantwortung, das Prinzip der Schnittstellentrennung und das Prinzip der Abhängigkeitsumkehrung, und Ihr Code wird nicht nur kompilierbar sein, sondern auch die Leistung verbessern, unerwartetes Verhalten reduzieren und Ihrem Team Freude beim Programmieren bereiten.