Sealed-, Static- und Partial-Klassen in C#

In C# können Klassen mit speziellen Schlüsselwörtern für unterschiedliche Zwecke definiert werden. sealed-Klassen können nicht vererbt werden, static-Klassen dienen nur allgemeinen (Utility-)Funktionen, und partial-Klassen ermöglichen es, die Definition derselben Klasse auf mehrere Dateien aufzuteilen. Diese Konzepte sind wichtig, um die Sicherheit des Codes zu erhöhen, die Wiederverwendbarkeit zu erleichtern und in großen Projekten Arbeitsteilung zu ermöglichen.

Sealed Class

Klassen, die mit dem Schlüsselwort sealed markiert sind, können nicht von anderen Klassen abgeleitet werden. Dies wird verwendet, wenn wir nicht möchten, dass das Verhalten einer Klasse verändert wird. Zum Beispiel können sicherheitskritische oder vollständig implementierte Klassen als sealed deklariert werden.

public sealed class PaymentProcessor
{
    public void Process()
    {
        Console.WriteLine("Zahlung verarbeitet.");
    }
}

// Der folgende Code führt zu einem Kompilierungsfehler:
// public class CustomProcessor : PaymentProcessor { }

Static Class

static-Klassen enthalten nur static-Member und können nicht instanziiert werden. Sie eignen sich ideal, um gemeinsame Hilfsmethoden zu sammeln. Zum Beispiel für mathematische Berechnungen, Datumsberechnungen oder Formatierungen. Die Math-Klasse ist ein bekanntes Beispiel. Praktisch verhält sich eine static-Klasse so, als gäbe es nur eine einzige Instanz in der gesamten Anwendung.

public static class MathHelper
{
    public static int Square(int x) => x * x;

    public static int Cube(int x) => x * x * x;
}

class Program
{
    static void Main()
    {
        Console.WriteLine(MathHelper.Square(5)); // 25
        Console.WriteLine(MathHelper.Cube(3));   // 27
    }
}

Partial Class

partial-Klassen ermöglichen es, die Definition einer einzigen Klasse auf mehrere Dateien aufzuteilen. Dies ist besonders nützlich in großen Projekten oder beim Arbeiten mit automatisch generiertem Code (z. B. WinForms, WPF), sodass Entwickler unabhängig an verschiedenen Teilen derselben Klasse arbeiten können.

// File1.cs
public partial class Person
{
    public string FirstName { get; set; } = string.Empty;
    public string LastName { get; set; } = string.Empty;
}

// File2.cs
public partial class Person
{
    public void Print()
    {
        Console.WriteLine($"{FirstName} {LastName}");
    }
}

class Program
{
    static void Main()
    {
        var p = new Person { FirstName = "Hans", LastName = "Müller" };
        p.Print(); // Hans Müller
    }
}

Wann verwenden?

• Sealed: Wenn Sie nicht möchten, dass andere Klassen davon erben, um das Verhalten unverändert zu lassen.
• Static: Zum Sammeln gemeinsamer, objektunabhängiger Hilfsmethoden.
• Partial: Um große Klassen aufzuteilen oder automatisch generierten Code von manuellem Code zu trennen.

TL;DR

Beispielanwendung: Verwendung von Static und Partial Classes

In diesem Beispiel werden zwei besondere Klassentypen gemeinsam verwendet:

• Static class (Calculator) → Enthält gemeinsame Berechnungsmethoden ohne Instanzierung.
• Partial class (Product) → Eigenschaften und Methoden sind auf verschiedene Dateien verteilt.

Calculator.cs

// Static class: enthält nur statische Methoden, kann nicht mit new instanziiert werden
public static class Calculator
{
    // Wendet einen Rabatt an (Preis wird prozentual reduziert)
    public static decimal ApplyDiscount(decimal price, decimal rate)
        => price - (price * rate);

    // Fügt Steuer hinzu (Preis wird prozentual erhöht)
    public static decimal AddTax(decimal price, decimal taxRate)
        => price + (price * taxRate);
}

Product.Part1.cs

// Erster Teil der Partial Class: Eigenschaften definiert
public partial class Product
{
    public string Name { get; set; } = string.Empty;
    public decimal Price { get; set; }
}

Product.Part2.cs

// Zweiter Teil der Partial Class: Methoden definiert
public partial class Product
{
    // Gibt das Produkt aus
    public void Print()
    {
        Console.WriteLine($"{Name} - {Price:0.00} EUR");
    }

    // Wendet zuerst Rabatt, dann Steuer an
    public void ApplyDiscountAndTax(decimal discountRate, decimal taxRate)
    {
        // Verwendet Calculator (statische Klasse)
        Price = Calculator.ApplyDiscount(Price, discountRate);
        Price = Calculator.AddTax(Price, taxRate);
    }
}

Program.cs

class Program
{
    static void Main()
    {
        // Neues Produktobjekt erstellen
        var p = new Product { Name = "Laptop", Price = 2000m };

        Console.WriteLine("Anfangspreis:");
        p.Print(); // 2000 EUR

        // Wendet 10 % Rabatt und 20 % Steuer an
        p.ApplyDiscountAndTax(0.10m, 0.20m);

        Console.WriteLine("Preis nach Rabatt und Steuer:");
        p.Print(); // Preis nach Rabatt und Steuer
    }
}

Beispielausgabe:

Anfangspreis:
Laptop - 2000,00 EUR
Preis nach Rabatt und Steuer:
Laptop - 2160,00 EUR