Chargement...

Guides
C#
A propos
Contact
Thème
Clair Sombre
Rouge Vert Bleu Violet Orange
FR
DE EN ES TR

Classes, Objets, Propriétés et Méthodes en C#

Découvrez comment les classes, objets, propriétés et méthodes en C# constituent les fondements de la programmation orientée objet.

En programmation orientée objet (OOP), une classe est un modèle qui regroupe les données (propriétés) et les comportements (méthodes) d’un concept sous une seule structure. Les instances créées à partir de ce modèle sont appelées objets. Les propriétés servent à accéder aux données et les méthodes définissent les comportements.

Qu’est-ce qu’une Classe ?

Une classe est un modèle utilisé pour représenter un concept ou une entité dans un logiciel. Elle définit des propriétés, des champs et des méthodes. Par exemple, une classe Product peut stocker des données comme le nom et le prix d’un produit, tout en incluant des comportements tels que « afficher les informations ». 


public class Product
{
    private decimal _price;

    public string Name { get; set; } = string.Empty;

    public decimal Price
    {
        get => _price;
        set => _price = value < 0 ? 0 : value; // prix négatif empêché
    }

    public void PrintInfo()
    {
        Console.WriteLine($"{Name} - {Price:0.00} EUR");
    }
}

Créer un Objet

Pour créer une instance concrète (objet) à partir d’une classe, on utilise le mot-clé new. Cela crée en mémoire un objet conforme à la définition de la classe. On peut attribuer des valeurs aux propriétés et appeler ses méthodes. 


var notebook = new Product();
notebook.Name = "Notebook";
notebook.Price = 45m;
notebook.PrintInfo();

// Résultat :
Notebook - 45.00 EUR

Les objets peuvent aussi être initialisés plus simplement grâce à un object initializer : 


var pen = new Product { Name = "Pen", Price = 12.5m };
pen.PrintInfo();

Types de Propriétés

Les propriétés permettent un accès contrôlé aux données d’une classe. Au lieu d’exposer directement les champs, l’utilisation de propriétés permet d’ajouter des validations et règles métier.

Propriétés automatiques : Le choix le plus pratique lorsqu’aucune logique supplémentaire n’est nécessaire.


public class Customer
{
    public int Id { get; set; }
    public string FullName { get; set; } = string.Empty;
}

Propriété avec champ privé : Contrôle via un champ privé interne.


public class Temperature
{
    private double _celsius;

    public double Celsius
    {
        get => _celsius;
        set => _celsius = value;
    }

    public double Fahrenheit => (_celsius * 9 / 5) + 32; // lecture seule
}

Propriété init-only (C# 9+): Peut uniquement être définie lors de la création de l’objet, pas après.


public class User
{
    public string Username { get; init; } = string.Empty;
    public string Email { get; init; } = string.Empty;
}

var u = new User { Username = "john", Email = "j@example.com" };
// u.Username = "michael"; // erreur : propriété init-only

Méthodes

Les méthodes définissent les actions qu’un objet peut exécuter. Elles peuvent accepter des paramètres et retourner des valeurs. Plusieurs méthodes portant le même nom mais avec des signatures différentes peuvent être définies (surcharge). 


public class MathUtil
{
    public static int Sum(int a, int b) => a + b;
    public static int Sum(int a, int b, int c) => a + b + c; // surcharge
}

int x = MathUtil.Sum(2, 3);     // 5
int y = MathUtil.Sum(1, 2, 3);  // 6

Méthodes d’instance : appelées via un objet. Méthodes statiques : appelées directement sur la classe.

Modificateurs d’accès

En C#, la visibilité des classes et de leurs membres est contrôlée par des modificateurs comme public, private, protected et internal :

Les modificateurs d’accès définissent depuis quelles parties du programme une classe ou ses membres (propriétés, méthodes, champs) peuvent être utilisés. Par exemple, les membres private ne sont accessibles qu’à l’intérieur de la classe où ils sont définis, garantissant ainsi l’intégrité des données. Les membres public sont accessibles partout et représentent l’interface publique d’une classe. Les membres protected sont accessibles dans la classe elle-même et dans ses classes dérivées, ce qui favorise l’héritage. Les membres internal sont accessibles uniquement dans le même assembly, bloquant l’accès depuis d’autres projets. Ce mécanisme répond à la question « quelles informations exposer et lesquelles garder encapsulées », permettant de réduire les dépendances, d’appliquer le principe d’encapsulation et de concevoir une architecture claire et sécurisée. 


public class Account
{
    private decimal _balance; // seulement dans la classe

    public decimal Balance { get; private set; } // en lecture seule à l’extérieur

    protected string Owner { get; set; } = string.Empty; // utilisable dans les sous-classes

    internal string? Tag { get; set; } // accessible dans le même projet

    public void Deposit(decimal amount)
    {
        if (amount <= 0) return;
        Balance += amount;
    }
}

Exemple : Système de bibliothèque simple

Dans l’exemple suivant, une classe Book et un service LibraryService sont définis. Cela illustre comment créer, stocker et manipuler des objets. 


public class Book
{
    public int Id { get; init; }
    public string Title { get; set; } = string.Empty;
    public string Author { get; set; } = string.Empty;

    public void Print() => Console.WriteLine($"{Id} - {Title} ({Author})");
}

public class LibraryService
{
    private readonly List<Book> _books = new();

    public void Add(Book b) => _books.Add(b);

    public Book? FindById(int id) => _books.FirstOrDefault(b => b.Id == id);

    public void PrintAll()
    {
        if (_books.Count == 0)
        {
            Console.WriteLine("La bibliothèque est vide.");
            return;
        }
        foreach (var b in _books) b.Print();
    }
}

// Utilisation
var lib = new LibraryService();
lib.Add(new Book { Id = 1, Title = "Clean Code", Author = "Robert C. Martin" });
lib.Add(new Book { Id = 2, Title = "CLR via C#", Author = "Jeffrey Richter" });
lib.PrintAll();

En résumé

  • Classe : Modèle définissant données + comportements.
  • Objet : Instance concrète créée à partir d’une classe.
  • Propriété : Accès contrôlé aux données (encapsulation).
  • Méthode : Définit ce qu’un objet peut faire (instance ou statique).
  • Modificateurs d’accès : Contrôlent la visibilité avec public, private, protected, internal.

Exemple : Informations d’entreprise et validation

Dans cet exemple, la classe Company stocke non seulement les informations saisies par l’utilisateur, mais les valide également grâce à une méthode Validate(). Le résultat de la validation est retourné sous forme d’énumération ValidationResult. Ainsi, la cause précise d’une erreur peut être identifiée. 


public enum ValidationResult
{
    Success,
    NameMissing,
    PhoneMissing,
    PhoneInvalid,
    AddressMissing
}

public class Company
{
    public string Name { get; set; } = string.Empty;
    public string Phone { get; set; } = string.Empty;
    public string Address { get; set; } = string.Empty;
    public string Sector { get; set; } = string.Empty;

    public void PrintInfo()
    {
        Console.WriteLine("=== Informations sur l’entreprise ===");
        Console.WriteLine($"Nom     : {Name}");
        Console.WriteLine($"Téléphone : {Phone}");
        Console.WriteLine($"Adresse : {Address}");
        Console.WriteLine($"Secteur : {Sector}");
    }

    public ValidationResult Validate()
    {
        if (string.IsNullOrWhiteSpace(Name))
            return ValidationResult.NameMissing;

        if (string.IsNullOrWhiteSpace(Phone))
            return ValidationResult.PhoneMissing;

        if (!Phone.All(char.IsDigit))
            return ValidationResult.PhoneInvalid;

        if (string.IsNullOrWhiteSpace(Address))
            return ValidationResult.AddressMissing;

        return ValidationResult.Success;
    }
}

class Program
{
    static void Main()
    {
        var company = new Company();

        Console.Write("Entrez le nom de l’entreprise : ");
        company.Name = Console.ReadLine();

        Console.Write("Entrez le téléphone : ");
        company.Phone = Console.ReadLine();

        Console.Write("Entrez l’adresse : ");
        company.Address = Console.ReadLine();

        Console.Write("Entrez le secteur : ");
        company.Sector = Console.ReadLine();

        var result = company.Validate();

        if (result == ValidationResult.Success)
        {
            Console.WriteLine();
            company.PrintInfo();
        }
        else
        {
            Console.WriteLine($"Erreur : {result}");
        }
    }
}

La méthode Validate() vérifie la validité des informations saisies et retourne un enum. Au lieu de simplement renvoyer true/false, elle précise la cause exacte de l’erreur. Par exemple : nom manquant, numéro de téléphone vide ou non numérique. Cette approche rend la gestion des erreurs plus claire et plus facile à maintenir.