Classes

Une classe est un modèle pour représenter et manipuler des données. Elle est au cœur de la programmation orientée objet (POO).

Définir une classe personnalisée#

public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public DateTime DateOfBirth { get; init; }
}

Généralement, le code correspondant à une classe est défini dans un fichier dédié appelé par le nom de la classe, par exemple ici Person.cs.

Une fois définie, on peut créer des instances, ou objets, de cette classe en utilisant le mot clé new :

var person = new Person
{
    FirstName = "Alice",
    LastName = "Durand",
    DateOfBirth = new DateTime(1990, 5, 12)
};
// person est un objet/instance de la classe Person
// Ou encore, person est de type Person

Champs (fields)#

Pour créer des champs pour une classe :

class Item {
  public string description;
  public int count;
}

Il est recommandé de nommer les champs uniquement avec des caractères minuscule.

Pour accéder et modifier les champs, il faut utiliser la syntaxe suivante :

Item bag = new Item();
bag.description = "Paper bag with handles";
bag.count = 4;
Console.WriteLine(bag.description); // Prints "Paper bag with handles"

Item bottle = new Item();
bottle.description = "Plastic water bottle with sealed lid";
bottle.count = 5;
Console.WriteLine(bottle.count); // Prints "5"

Propriétés#

Les propriétés permettent de contrôler l’accès à un champ (field), tout en pouvant valider les valeurs affectées.

Une propriété est composée de :

• get : permet de lire la valeur
• set : permet de modifier la valeur
• init : permet de définir la valeur une seule fois (ex. à l’instanciation)

public int area;
public int Area // Propriété
{
  get { return area; }
  set { area = value; }
}

[!TIPS] Convention de nommage : le nom de la propriété est le même que celui du champ mais avec une majuscule.

Ce modèle est tellement courant qu’il existe une syntaxe simplifiée, appelée propriété auto-implémentée

public string Size { get; set; }

Petit exemple pour montrer ce qu’il est possible de faire :

internal class Person {
	public string FirstName { get; set; }
	public string LastName { get; set; }
	public string FullName => $"{FirstName} {LastName}";
	public DateOnly DateOfBirth { get; init; }
}

var person = New Person {
	FirstName = "Alexis",
	LastName = "THIOU",
	DateOfBirth = new DateOnly(1994, 12, 24)
};

Méthodes (methods)#

En plus des champs, il est possible de définir des méthodes au sein d’une classe. Elles représentent les actions qu’un objet peut réaliser.

class Shape {
  public int area; // area est un champ
  public void IncreaseArea(int amount) // IncreaseArea est une méthode
  {
    area += amount;
  }
}

Paramètres#

Des paramètres peuvent être déclarés en même temps que la méthode :

static void OurMethodName(string identity, int age)
{
  Console.WriteLine($"{identity} is {age} years old.");
}

// L'appel de la méthode permet de peupler les paramètres prédéfinis
OurMethodName("Jill", 34);

Paramètre out#

Les paramètres out doivent être précédés de out dans la déclaration de la méthode.

Paramètres optionnels#

En C#, il est possible de définir des paramètres optionnels pour les méthodes. Un paramètre est considéré comme optionnel si sa déclaration spécifie une valeur par défaut. Si une méthode est appelée sans qu’une valeur ne soit fournie pour le paramètre optionnel, alors celui-ci est initialisé avec sa valeur par défaut.

Pour définir un paramètre optionnel, on utilise un signe égal = après la déclaration du paramètre, suivi de sa valeur par défaut.

// y and z are optional parameters.
static int AddSomeNumbers(int x, int y = 3, int z = 2)
{
  return x + y + z;
}

// Any of the following are valid method calls.
AddSomeNumbers(1); // Returns 6.
AddSomeNumbers(1, 1); // Returns 4.
AddSomeNumbers(3, 3, 3); // Returns 9.

Arguments positionnels vs nommés#

En C#, un argument passé à une méthode peut être identifié par sa position ou par son nom.

Les arguments positionnels sont des valeurs passées directement lors de l’appel de la méthode, dans le même ordre que celui des paramètres définis.

// Argument positionnel
OurMethodName(4);

Les arguments nommés sont des valeurs passées à la méthode accompagnées du nom du paramètre auquel elles doivent être affectées, et ce, quel que soit l’ordre de définition des paramètres. Un argument peut être nommé en utilisant le nom du paramètre suivi d’un deux-points (:), puis de la valeur de l’argument.

// Argument nommé
OurMethodName(d: 4);

Instruction return#

Ce mot clé permet de sortir d’une méthode et de retourner une valeur en fonction d’où la méthode a été appelée.

Variables dans la méthode#

Une variable qui est déclarée dans une méthode ne pourra pas être utilisée en dehors. Cela retournera une erreur.

Constructors#

En C#, il est possible de créer un objet sans initialiser ses propriétés, ce qui peut poser problème :

Person p = new Person(); // Pas de nom, pas de date de naissance

Un constructeur est alors une méthode qui s’exécute à chaque fois qu’un objet est instancié.

public class Person
{
    public string Name { get; set; }
    public DateTime DateOfBirth { get; set; }

    public Person(string name, DateTime dob)
    {
        Name = name;
        DateOfBirth = dob;
    }
}

Maintenant, on ne peut plus instancier une Person sans fournir ces données :

Person p = new Person("Alice", new DateTime(1990, 1, 1)); // OK
Person p2 = new Person(); // ❌ Erreur : pas de constructeur vide

[!warning] Le constructeur doit posséder le même nom que sa classe.

Polymorphisme#

Le polymorphisme permet de rendre les classes flexibles grâce à l’héritage. Exemple :

class Animal
{
    public string Name { get; set; }
}

class Dog : Animal { }
class Cat : Animal { }

Dog d = new Dog { Name = "Rex" };
Cat c = new Cat { Name = "Mimi" };
// "Dog" et "Cat" héritent de "Animal", ils possèdent donc la propriété "Name"

Abstraction#

Par défaut, une classe non statique ne peut pas être instanciée. Mais parfois, il est illogique d’instancier une classe “générique” comme Animal. Utiliser le mot clé abstract pour cette classe empêche la création d’instances.

abstract class Animal
{
    public string Name { get; set; }
}

Interfaces#

Une interface est une forme d’abstraction plus stricte :

• Elle contient uniquement des méthodes et propriétés (pas de logique)
• Pas d’attributs ou de constructeurs
• Doit commencer par un I par convention