Classe partielle C#

Introduction

En C#, le concept de classes partielles permet de diviser une définition de classe unique en plusieurs parties, réparties dans différents fichiers ou blocs de code. Cette fonctionnalité est principalement utilisée pour gérer des classes importantes ou complexes, ce qui améliore la maintenabilité et permet une meilleure collaboration entre plusieurs développeurs. En utilisant le mot-clé partial, les développeurs peuvent décomposer le code de logique métier, les définitions de contrôles d'interface utilisateur et d'autres composants complexes en morceaux gérables.

Une classe partielle fait essentiellement référence à une définition de classe qui est divisée en plusieurs fichiers source. Toutes ces parties ou fragments sont combinés au moment de la compilation pour former la classe complète, qui se comporte comme si elle avait été écrite dans un seul fichier. Cette fonctionnalité puissante peut s'avérer extrêmement utile lorsque l'on travaille avec du code source généré automatiquement, car elle permet de séparer la logique écrite manuellement du code généré par des outils tels que LINQ to SQL ou du code généré par le concepteur.

Tim at (0:00) présente les classes partielles et explique que l'objectif de la vidéo est de faire comprendre rapidement ce que sont les classes partielles, comment elles fonctionnent et quand les utiliser.

Démonstration d'une application

À (0:25), Tim commence en créant un nouveau fichier nommé Demo.cs dans un projet d'application console. Il rend la classe partielle en utilisant le mot-clé partial. Cela permet de répartir le cours sur plusieurs fichiers.

// Demo.cs
public partial class Demo
{
    public void FromDemo()
    {
        Console.WriteLine("This is from Demo");
    }
}

// OtherDemo.cs
public partial class Demo
{
    public void FromOtherDemoFile()
    {
        Console.WriteLine("This is from OtherDemo file");
    }
}

// Demo.cs
public partial class Demo
{
    public void FromDemo()
    {
        Console.WriteLine("This is from Demo");
    }
}

// OtherDemo.cs
public partial class Demo
{
    public void FromOtherDemoFile()
    {
        Console.WriteLine("This is from OtherDemo file");
    }
}

Tim explique que même si les noms de fichiers sont différents, les noms de classes doivent correspondre pour qu'ils soient considérés comme faisant partie de la même classe partielle. Au moment de la compilation, le compilateur C# combine ces définitions de classe partielles en une seule classe.

Utilisation des classes partielles

Tim à (3:01) montre comment instancier et utiliser la classe partielle dans le fichier Program.cs.

class Program
{
    static void Main(string[] args)
    {
        Demo demo = new Demo();
        demo.FromDemo();
        demo.FromOtherDemoFile();
    }
}

class Program
{
    static void Main(string[] args)
    {
        Demo demo = new Demo();
        demo.FromDemo();
        demo.FromOtherDemoFile();
    }
}

Ce code montre que les méthodes de Demo.cs et OtherDemo.cs sont accessibles par une seule instance de la classe Demo.

Mise en œuvre d'interfaces

Tim (4:01) explique que les interfaces mises en œuvre dans une partie d'une classe partielle s'appliquent à l'ensemble de la classe. Par exemple, si une partie de la classe partielle implémente IDisposable, cela s'applique à l'ensemble de la classe.

// Demo.cs
public partial class Demo : IDisposable
{
    public void Dispose()
    {
        Console.WriteLine("Dispose method called");
    }
}

// Demo.cs
public partial class Demo : IDisposable
{
    public void Dispose()
    {
        Console.WriteLine("Dispose method called");
    }
}

Limitations des classes partielles

Tim (5:02) souligne certaines limites des classes partielles. Par exemple, toutes les parties d'une classe partielle doivent avoir les mêmes modificateurs d'accès. Vous ne pouvez pas avoir une partie marquée comme public et une autre comme internal ou private.

Cas d'utilisation pratique : Windows Forms

Tim (5:29) présente un cas pratique d'utilisation des classes partielles, en particulier dans les applications Windows Forms. Il montre comment le code généré par le concepteur de Windows Forms utilise des classes partielles pour séparer le code généré automatiquement du code écrit par l'utilisateur.

// Form1.cs
public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
    }
}

// Form1.Designer.cs
partial class Form1
{
    private void InitializeComponent()
    {
        this.SuspendLayout();
        // 
        // Form1
        // 
        this.ClientSize = new System.Drawing.Size(800, 450);
        this.Name = "Form1";
        this.ResumeLayout(false);
    }
}

// Form1.cs
public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
    }
}

// Form1.Designer.cs
partial class Form1
{
    private void InitializeComponent()
    {
        this.SuspendLayout();
        // 
        // Form1
        // 
        this.ClientSize = new System.Drawing.Size(800, 450);
        this.Name = "Form1";
        this.ResumeLayout(false);
    }
}

La séparation permet au concepteur de gérer le code de mise en page, tandis que l'utilisateur peut se concentrer sur la logique d'application dans la classe de formulaire principale.

Quand utiliser les classes partielles

Tim conclut en discutant des scénarios typiques dans lesquels les classes partielles sont utiles. Ils sont couramment utilisés dans les situations où le code est généré automatiquement ou dans les grands projets qui nécessitent une séparation nette des préoccupations. Un exemple est le code autogénéré, comme le code du concepteur de Windows Forms, où la séparation du code de mise en page de la logique de l'application permet d'éviter les conflits et facilite la maintenance.

Il mentionne également que si les classes partielles peuvent être utiles dans certaines situations, elles ne sont pas fréquemment utilisées dans le développement quotidien.