In C# sollte ToList() nur verwendet werden, wenn tatsächlich eine Liste benötigt wird. Eine unnötige Verwendung kann Speicher und Leistung kosten.
// Unnötiger ToList()-Aufruf
var activeUsers = users
.Where(u => u.IsActive)
.ToList();
foreach (var user in activeUsers)
{
Console.WriteLine(user.Name);
}
// Bessere Lösung
var activeUsersBetter = users
.Where(u => u.IsActive);
foreach (var user in activeUsersBetter)
{
Console.WriteLine(user.Name);
}
In C# sollte bei der Umwandlung von Benutzereingaben oder externen Daten TryParse anstelle von Parse verwendet werden, um Laufzeitfehler zu vermeiden.
// Riskante Nutzung
int age = int.Parse(input);
// Sichere Nutzung
if (int.TryParse(input, out int result))
{
Console.WriteLine(result);
}
else
{
Console.WriteLine("Ungültige Zahl");
}
In C# verwenden Sie is und is not für bessere Typprüfungen und Musterabgleiche.
// Alte Methode (using "as" und null Check)
object obj = "Hallo, Welt!";
if (obj is string)
{
Console.WriteLine(((string)obj).ToUpper()); // HALLO, WELT!
}
// Empfohlene Methode (using is)
if (obj is string str)
{
Console.WriteLine(str.ToUpper()); // HALLO, WELT!
}
// Verwendung von "is not" für Negation
if (obj is not int)
{
Console.WriteLine("Kein Integer");
}
In C# gibt nameof() den Namen einer Variable, Eigenschaft oder Methode als Text zurück. Dadurch werden Fehler durch fest geschriebene Zeichenketten vermieden.
int age = 25;
// Alte Schreibweise
if (age < 0)
{
throw new ArgumentException("age");
}
// Empfohlene Schreibweise
if (age < 0)
{
throw new ArgumentException(nameof(age));
}
Console.WriteLine(nameof(age)); // age
In C# ist es nicht ausreichend, nur auf null oder leere Zeichenketten zu prüfen. Die Verwendung von string.IsNullOrWhiteSpace() ist sicherer.
// Riskante Prüfungen
if (text == null || text == "")
{
Console.WriteLine("Ungültiger Text");
}
// Sichere und empfohlene Prüfung
if (string.IsNullOrWhiteSpace(text))
{
Console.WriteLine("Ungültiger Text");
}
In C# kann bei vielen Bedingungen eine Dictionary-basierte Lösung übersichtlicher sein als ein langer switch-Block.
// switch-basierter Ansatz
string GetRoleName(int roleId)
{
switch (roleId)
{
case 1: return "Admin";
case 2: return "Editor";
case 3: return "Benutzer";
default: return "Unbekannt";
}
}
// Dictionary-basierter Ansatz
var roles = new Dictionary<int, string>
{
{ 1, "Admin" },
{ 2, "Editor" },
{ 3, "Benutzer" }
};
string roleName = roles.TryGetValue(roleId, out var name)
? name
: "Unbekannt";
In C# sollte eine for-Schleife anstelle von foreach verwendet werden, wenn ein Index benötigt wird oder die Sammlung geändert werden muss.
// foreach: kein Index verfügbar
foreach (var item in items)
{
Console.WriteLine(item);
}
// for: wenn ein Index benötigt wird
for (int i = 0; i < items.Count; i++)
{
Console.WriteLine($"{i}: {items[i]}");
}
// for: sicher beim Entfernen von Elementen
for (int i = items.Count - 1; i >= 0; i--)
{
items.RemoveAt(i);
}
In C# sollten Sie keine allgemeine Exception abfangen. Fangen Sie nur die Ausnahmen ab, mit denen Sie rechnen.
// Riskante Nutzung: verdeckt das eigentliche Problem
try
{
int number = int.Parse(input);
}
catch (Exception)
{
Console.WriteLine("Ein Fehler ist aufgetreten");
}
// Empfohlene Nutzung: spezifische Exception abfangen
try
{
int number = int.Parse(input);
}
catch (FormatException)
{
Console.WriteLine("Keine gültige Zahl");
}
In C# kann using var verwendet werden, um Ressourcen kürzer und übersichtlicher zu verwalten, wenn der Gültigkeitsbereich klar ist.
// Klassischer using-Block
using (var stream = new FileStream(path, FileMode.Open))
{
// Stream verwenden
}
// using var (empfohlen bei kurzem Scope)
using var stream2 = new FileStream(path, FileMode.Open);
// Stream verwenden
In C# kann FirstOrDefault() null zurückgeben. Prüfen Sie das Ergebnis immer, bevor Sie es verwenden, um Fehler zu vermeiden.
// Riskante Verwendung
var user = users.FirstOrDefault();
Console.WriteLine(user.Name); // kann einen Fehler auslösen
// Sichere Verwendung
var safeUser = users.FirstOrDefault();
if (safeUser != null)
{
Console.WriteLine(safeUser.Name);
}