Les Classes en C#

Introduction aux Classes en C

Dans le langage C#, une classe agit comme un modèle ou un plan pour la création d'objets. C'est un élément clé qui définit la structure, les comportements et les caractéristiques de ces objets. On peut donc envisager une classe comme un type de données défini par l'utilisateur qui encapsule à la fois des données (attribus) et des actions (méthodes) qui peuvent être appliquées à ces données.

Syntaxe pour Déclarer des Classes

Pour déclarer une classe en C#, il suffit d'utiliser le mot-clé class, suivi du nom de la classe. Il est important de respecter les conventions de nommage de C# (généralement en utilisant PascalCase). La définition de la classe est entourée d'accolades ({}).

public class MaClasse {
    // Champs, propriétés et méthodes vont ici
}

Propriétés et Méthodes

Propriétés : Les propriétés servent à définir les attributs ou les membres de données d'une classe. Elles sont définies à l'intérieur de la classe et facilitent l'accès à l'état interne de celle-ci.

Méthodes : Les méthodes sont des fonctions définies au sein de la classe qui réalisent des actions ou opérations. Elles peuvent modifier l'état de la classe ou fournir des fonctionnalités.

Modificateurs d'Accès

C# offre des modificateurs d'accès permettant de contrôler la visibilité et l'accessibilité des membres de la classe. Les modificateurs d'accès les plus courants incluent :

public : Les membres sont accessibles depuis n'importe quel code.
private : Les membres ne sont accessibles qu'au sein de la classe.
protected : Les membres sont accessibles dans la classe et les classes dérivées.
internal : Les membres sont accessibles dans le même assembly (un groupe de classes connexes dans le même projet).
protected internal : Les membres sont accessibles dans le même assembly et dans les classes dérivées.
private protected : Les membres sont accessibles uniquement depuis les classes dérivées au sein du même assembly. Ce modificateur est présent depuis C# 7.2.

Exemple de Classe

Voici un exemple simple présentant une classe comportant des propriétés et des méthodes. Cet exemple illustre l'utilisation de méthodes publiques telles que GetBalance pour accéder à des propriétés privées comme le solde actuel. De plus, il démontre que des méthodes privées, comme PerformAudit(), ne sont pas accessibles depuis le code externe.

using System;
public class Programme {
    public static void Main() {
        // Création d'une instance de BankAccount avec un solde initial de 1000 €.
        BankAccount compte = new BankAccount(1000);
        // Utilisation de la méthode GetBalance pour obtenir le solde actuel.
        double soldeActuel = compte.GetBalance();
        Console.WriteLine("Solde Actuel : €" + soldeActuel);
        // Tentative d'appeler la méthode privée PerformAudit (ne compilera pas).
        // compte.PerformAudit();
    }
}

public class BankAccount {
    // Suivi du solde actuel.
    private double solde;
    // Constructeur
    public BankAccount(double montantInitial) {
        solde = montantInitial;
    }
    // Méthode d'accès au solde.
    public double GetBalance() {
        return solde;
    }
    // Méthode privée pour réaliser un audit de transaction.
    private void PerformAudit() {
        // Dans une application réelle, cette méthode effectuerait un audit.
        // Pour cet exemple, nous imprimerons juste un message.
        Console.WriteLine("Audit terminé.");
    }
}

Classes Statics et Classes Partielles

Les classes statiques sont définies en utilisant le mot-clé static et ne contiennent que des membres statiques, tels que des méthodes, des propriétés et des champs. Contrairement aux classes ordinaires, les classes statiques ne peuvent pas être instanciées avec le mot-clé new. Leur accès se fait uniquement via le nom de la classe. Elles sont souvent utilisées pour des fonctions utilitaires ou pour regrouper des fonctionnalités connexes.

Les classes partielles permattent aux définitions de classes d'être réparties sur plusieurs fichiers. Chaque partie de la classe est définie dans un fichier séparé et s'assemble au moment de la compilation pour former une unique classe. Ceci est particulièrement utile lorsque la classe devient trop grande ou complexe, ou quand plusieurs développeurs travaillent simultanément sur différents aspects de celle-ci.

Dans l'exemple ci-dessous, la classe Calculator est montrée comme une structure de classe partielle, permettant le développement indépendant des composants de la classe. Dans le code suivant, le point d'entrée de l'application, la méthode Main, crée une instance de la classe Calculator et utilise ses méthodes pour des opérations d'addition et de soustraction.

using System;
class Program {
    static void Main() {
        Calculator calculatrice = new Calculator();
        int resultat1 = calculatrice.Add(5, 3);
        int resultat2 = calculatrice.Subtract(10, 4);
        Console.WriteLine("Addition : " + resultat1); // Sortie : Addition : 8
        Console.WriteLine("Soustraction : " + resultat2); // Sortie : Soustraction : 6
    }
}