Clean Code in C#: Prinzipien für lesbaren Code mit Beispielen

Einleitung: Warum sauberer Code der Schlüssel zu einem erfolgreichen Projekt ist

In der Welt der Softwareentwicklung auf der .NET-Plattform ist das Schreiben von funktionierendem Code nur die halbe Miete. Wahre Meisterschaft zeigt sich in der Fähigkeit, Code zu erstellen, der leicht zu lesen, zu warten und zu erweitern ist. Das Konzept des Clean Code, popularisiert von Robert Martin, ist eine Reihe von Prinzipien, die ein chaotisches Programm in ein klares, verständliches System verwandeln. Für einen C#-Entwickler bedeutet die Befolgung dieser Prinzipien nicht nur Respekt gegenüber Kollegen, sondern auch eine deutliche Reduzierung der Zeit für Debugging und die Implementierung neuer Features.

In diesem Artikel werden wir die wichtigsten Clean-Code-Prinzipien in Bezug auf die Sprache C# und das .NET-Framework analysieren. Sie werden konkrete Beispiele für "schlechten" und "guten" Code sehen, die Ihnen helfen, bessere Anwendungen zu schreiben.

Prinzip 1: Aussagekräftige Namen und einheitlicher Stil

Richtige Benennung von Variablen und Methoden

Der Name einer Variable, Klasse oder Methode sollte die Fragen beantworten: "Was ist das?" oder "Was macht es?". Vermeiden Sie einbuchstabige Abkürzungen (außer bei Schleifenzählern) und abstrakte Bezeichnungen wie data, info, temp.

Schlechtes Beispiel:

public int Calc(int a, int b) // Was sind a und b? Was macht die Methode?{    int d = a * b;    return d;}

Gutes Beispiel (Clean Code):

/// <summary>/// Berechnet die Fläche eines Rechtecks./// </summary>public int CalculateRectangleArea(int width, int height){    int area = width * height;    return area;}

Einheitlichkeit im Team

Verwenden Sie camelCase für lokale Variablen und Parameter, PascalCase für Methoden und Klassen, _camelCase für private Felder (gemäß den gängigen .NET-Richtlinien). Dies macht den Code vorhersagbar.

public class OrderService{    private readonly IOrderRepository _orderRepository; // privates Feld

    public async Task<Order> GetOrderByIdAsync(int orderId) // Methode    {        var order = await _orderRepository.FindAsync(orderId); // lokale Variable        return order;    }}

Prinzip 2: Kleine Funktionen und das Single Responsibility Principle (SRP)

Eine Funktion sollte nur eine Sache tun

Dies ist das wichtigste Clean-Code-Prinzip. Wenn eine Methode mehrere Aktionen ausführt (Validierung, Logging, Geschäftslogik, Speichern in der DB), ist sie schwer zu testen und zu ändern. Teilen Sie solche Methoden in kleinere auf.

Schlechtes Beispiel (Methode macht alles auf einmal):

public void ProcessOrder(Order order){    // 1. Validierung    if (order == null || order.TotalAmount <= 0)        throw new ArgumentException("Invalid order");

    // 2. Logging    Console.WriteLine($"Processing order {order.Id}");

    // 3. Geschäftslogik    var discount = order.TotalAmount > 100 ? 0.1m : 0;    order.FinalAmount = order.TotalAmount - (order.TotalAmount * discount);

    // 4. Speichern    _context.Orders.Add(order);    _context.SaveChanges();}

Gutes Beispiel (Aufteilung in Methoden):

public void ProcessOrder(Order order){    ValidateOrder(order);    LogOrderProcessing(order);    ApplyDiscount(order);    SaveOrder(order);}

private void ValidateOrder(Order order){    if (order == null || order.TotalAmount <= 0)        throw new ArgumentException("Invalid order", nameof(order));}

private void LogOrderProcessing(Order order){    Console.WriteLine($"Processing order {order.Id}");}

private void ApplyDiscount(Order order){    const decimal discountThreshold = 100m;    const decimal discountRate = 0.1m;

    if (order.TotalAmount > discountThreshold)    {        order.FinalAmount = order.TotalAmount - (or