Clases Sealed, Static y Partial en C#

En C#, les classes peuvent être définies avec des mots-clés spéciaux pour différents usages. Les classes sealed ne peuvent pas être héritées, les classes static sont utilisées uniquement pour des fonctions communes (utilitaires), et les classes partial permettent de diviser la définition d’une même classe en plusieurs fichiers. Ces fonctionnalités sont importantes pour renforcer la sécurité du code, faciliter la réutilisation et permettre le travail en équipe dans de grands projets.

Classe Sealed

Les classes marquées avec le mot-clé sealed ne peuvent pas être héritées par d’autres classes. Cela est utilisé lorsqu’on ne veut pas que le comportement d’une classe soit modifié. Par exemple, des classes critiques pour la sécurité ou dont la logique est finalisée peuvent être déclarées sealed.

public sealed class PaymentProcessor
{
    public void Process()
    {
        Console.WriteLine("Paiement traité.");
    }
}

// Le code suivant génère une erreur de compilation :
// public class CustomProcessor : PaymentProcessor { }

Classe Static

Les classes static ne contiennent que des membres static et ne peuvent pas être instanciées. Elles sont idéales pour regrouper des méthodes utilitaires communes. Par exemple, pour des opérations mathématiques, des calculs de dates ou des fonctions de formatage. La classe Math en est un exemple. En pratique, une classe static se comporte comme s’il n’existait qu’une seule instance partagée dans l’application.

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
    }
}

Classe Partial

Les classes partial permettent de diviser la définition d’une seule classe en plusieurs fichiers. Cela est particulièrement utile dans les grands projets ou lors de l’utilisation de code généré automatiquement (par ex. WinForms, WPF), permettant aux développeurs de travailler indépendamment sur différentes parties de la même classe.

// 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 = "Jean", LastName = "Dupont" };
        p.Print(); // Jean Dupont
    }
}

Quand les utiliser ?

• Sealed : Lorsque vous ne voulez pas que d’autres classes héritent de celle-ci, afin de garantir un comportement inchangé.
• Static : Pour regrouper des méthodes utilitaires communes, indépendantes des objets.
• Partial : Pour diviser de grandes classes ou séparer le code généré automatiquement du code manuel.

TL;DR

Exemple d’application : Utilisation des classes Static et Partial

Dans cet exemple, deux types de classes spéciales sont utilisés ensemble :

• Classe statique (Calculator) → Contient des méthodes de calcul communes sans instanciation.
• Classe partielle (Product) → Les propriétés et méthodes sont réparties dans différents fichiers.

Calculator.cs

// Classe statique : contient uniquement des méthodes statiques, ne peut pas être instanciée avec new
public static class Calculator
{
    // Applique une remise (réduit le prix en pourcentage)
    public static decimal ApplyDiscount(decimal price, decimal rate)
        => price - (price * rate);

    // Ajoute une taxe (augmente le prix en pourcentage)
    public static decimal AddTax(decimal price, decimal taxRate)
        => price + (price * taxRate);
}

Product.Part1.cs

// Première partie de la classe partielle : propriétés définies ici
public partial class Product
{
    public string Name { get; set; } = string.Empty;
    public decimal Price { get; set; }
}

Product.Part2.cs

// Deuxième partie de la classe partielle : méthodes définies ici
public partial class Product
{
    // Affiche le produit
    public void Print()
    {
        Console.WriteLine($"{Name} - {Price:0.00} EUR");
    }

    // Applique d’abord une remise, puis une taxe
    public void ApplyDiscountAndTax(decimal discountRate, decimal taxRate)
    {
        // Utilise Calculator (classe statique)
        Price = Calculator.ApplyDiscount(Price, discountRate);
        Price = Calculator.AddTax(Price, taxRate);
    }
}

Program.cs

class Program
{
    static void Main()
    {
        // Création d’un nouvel objet produit
        var p = new Product { Name = "Laptop", Price = 2000m };

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

        // Application d’une remise de 10 % et d’une taxe de 20 %
        p.ApplyDiscountAndTax(0.10m, 0.20m);

        Console.WriteLine("Prix après remise et taxe :");
        p.Print(); // prix après remise et taxe
    }
}

Exemple de sortie :

Prix initial :
Laptop - 2000,00 EUR
Prix après remise et taxe :
Laptop - 2160,00 EUR