Top-Fehler von C#-Anfängern: Fortgeschrittenes Niveau

Top-Fehler von C#-Anfängern: Fortgeschrittenes Niveau

Der Übergang vom Schreiben einfacher Konsolenanwendungen zur Erstellung zuverlässiger, skalierbarer und leistungsfähiger Lösungen in C# ist eine Herausforderung. Viele Entwickler, die die Syntax beherrschen, stoßen auf „Fallstricke“, die den Code in eine Quelle von Fehlern und Leistungseinbußen verwandeln. In diesem Artikel analysieren wir 4 Schlüsselfehler, die C#-Anfänger auf fortgeschrittenem Niveau machen, und zeigen, wie man sie vermeidet.

1. Falsche Arbeit mit Asynchronität (async/await)

Eines der häufigsten Probleme ist das falsche Verständnis des async/await-Modells. Ein typischer Fehler ist das Blockieren von asynchronem Code mit .Result oder .Wait(). Dies tötet nicht nur die Leistung, sondern kann auch zu einem Deadlock führen.

Beispielfehler:

public class BadAsyncExample{    public string GetData()    {        // Blockiert den Thread, während auf das Ergebnis der asynchronen Operation gewartet wird        return GetDataAsync().Result; // Tödlicher Griff!    }

    private async Task<string> GetDataAsync()    {        await Task.Delay(1000);        return "Data";    }}

Richtiger Ansatz:

public class GoodAsyncExample{    public async Task<string> GetDataAsync()    {        await Task.Delay(1000);        return "Data";    }

    // Der aufrufende Code muss von Anfang bis Ende asynchron sein    public async Task ProcessAsync()    {        var data = await GetDataAsync();        Console.WriteLine(data);    }}

Verwenden Sie ConfigureAwait(false) in Bibliothekscode, um die Erfassung des Synchronisationskontexts zu vermeiden und das Risiko von Deadlocks zu verringern.

2. Missbrauch von LINQ und Leistungseinbußen

LINQ ist ein mächtiges Werkzeug, aber seine falsche Verwendung kann zu mehrfachem Durchlaufen der Sammlung und Leistungseinbußen führen. Der Hauptfehler ist das Nichtverstehen der verzögerten Ausführung (deferred execution).

Beispielfehler:

var numbers = Enumerable.Range(1, 1000);

// Filtert die Sammlungvar filtered = numbers.Where(n => n % 2 == 0);

// Mehrfaches Durchlaufenvar count = filtered.Count();   // 1. Durchlaufvar sum = filtered.Sum();       // 2. Durchlaufvar list = filtered.ToList();   // 3. Durchlauf

Jeder Aufruf von Count(), Sum() oder ToList() führt die gesamte LINQ-Pipeline erneut aus. Dies ist besonders kritisch bei der Arbeit mit Datenbanken (Entity Framework), wo jeder Durchlauf eine neue SQL-Abfrage ist.

Richtiger Ansatz:

var numbers = Enumerable.Range(1, 1000);

// Materialisiert das Ergebnis einmalvar filtered = numbers.Where(n => n % 2 == 0).ToList();

// Jetzt arbeiten wir mit der fertigen Listevar count = filtered.Count;var sum = filtered.Sum();

Materialisieren Sie das Ergebnis einer LINQ-Abfrage immer (ToList(), ToArray()), wenn Sie es mehr als einmal verwenden möchten.

3. Ignorieren der Null-Sicherheit und NullReferenceException

NullReferenceException ist ein ständiger Begleiter von C#-Entwicklern. Mit dem Aufkommen der nullable reference types in C# 8.0 haben wir Werkzeuge zur Bekämpfung dieses Problems, aber viele Anfänger ignorieren sie.

Beispielfehler:

public class User{    public string Name { get; set; } // Kann null sein!}

public void PrintUserName(User user){    Console.WriteLine(user.Name.Length); // NullReferenceException, wenn user == null oder Name == null}

Richtiger Ansatz:

#nullable enablepublic class User{    public string Name { get; set; } = string.Empty; // Lässt null nicht zu    public string? MiddleName { get; set; } // Gibt explizit an, dass null sein kann}