Comment fonctionnent les classes, les constructeurs et les propriétés ?

Question

Accepted Answer

**Les classes** sont le fondement du modèle orienté objet de C# — des blueprints pour les objets, avec **des constructeurs** (initialiser les objets) et **des propriétés** (accès contrôlé aux données). La syntaxe des propriétés de C# est une fonctionnalité distinctive et élégante.

## Une classe avec constructeur et propriétés

```csharp
public class Person
{
    // auto-implemented PROPERTY — encapsulated access with get/set
    public string Name { get; set; }
    public int Age { get; private set; }      // settable only within the class
    public string Email { get; init; }          // set only during initialization (C# 9)

// CONSTRUCTOR
    public Person(string name, int age)
    {
        Name = name;
        Age = age;
    }

public string Greet() => $"Hi, I'm {Name}";   // a method
}

var person = new Person("Ann", 30);    // create an instance
person.Name = "Bob";                     // set a property
Console.WriteLine(person.Greet());
```

## Propriétés — l'encapsulation rendue élégante

```csharp
// auto-property (the common case) — compiler generates the backing field
public string Name { get; set; }

// property with custom logic
private decimal _balance;
public decimal Balance
{
    get => _balance;
    set => _balance = value >= 0 ? value : throw new ArgumentException();   // validation
}

// expression-bodied / computed property
public string FullName => $"{First} {Last}";   // read-only, computed
```

**Les propriétés** ressemblent à des champs mais sont en réalité des méthodes (`get`/`set`) — fournissant l'encapsulation (accès contrôlé, validation, valeurs calculées) avec une syntaxe propre. Les auto-propriétés (`{ get; set; }`) gèrent le cas courant sans boilerplate.

## Initialisateurs d'objets et fonctionnalités modernes

```csharp
var p = new Person("Ann", 30) { Email = "a@x.com" };   // object initializer

// primary constructor (C# 12) — concise constructor parameters
public class Point(int x, int y)
{
    public int X { get; } = x;
}
```

## Pourquoi c'est important

Les classes, les constructeurs et les propriétés sont le fondement de la programmation orientée objet en C# — pratiquement tout le code C# est organisé en classes, donc les comprendre est essentiel pour tout développement en C#.

Savoir comment définir des classes avec des constructeurs (initialisant les objets) et des méthodes est fondamental, mais les **propriétés** de C# sont une fonctionnalité particulièrement importante et distinctive qui mérite d'être bien comprise.

Les propriétés fournissent l'**encapsulation** élégamment — elles ressemblent à des champs mais sont en réalité des méthodes `get`/`set`, permettant un accès contrôlé, une validation, des valeurs calculées et des modificateurs d'accès (comme `private set` ou `init`-only) tout en conservant une syntaxe propre. Les **auto-propriétés** (`{ get; set; }`) gèrent le cas courant sans aucun boilerplate, rendant l'encapsulation effortless (contrairement aux langages où vous écrivez des méthodes getter/setter explicites).

Comprendre les propriétés (auto-propriétés, logique personnalisée, calculées/read-only, `init`-only pour l'immuabilité), les constructeurs, les initialisateurs d'objets et les commodités modernes (constructeurs primaires) est une connaissance fondamentale et quotidienne pour écrire des classes C# bien encapsulées.

Puisque les classes sont comment vous modélisez les données et le comportement dans les applications C#, et puisque les propriétés sont la façon idiomatique et élégante que C# gère l'encapsulation (une fonctionnalité de langage distinctive utilisée constamment), maîtriser ces concepts — en particulier le système de propriétés — est une matière fondamentale et incontournable pour un développement C# orienté objet efficace.