ENIB S5-OBJ - Programmation Orientée Objet

{} Présentation du cours

{} Objectifs

{} Qu’est-ce que la POO ?

La programmation orientée objet est un paradigme de programmation dans lequel le logiciel est conçu comme un ensemble d’objets qui interagissent les uns avec les autres pour résoudre un problème donné.
Un objet est une entité logicielle autonome qui représente un concept abstrait ou une entité du monde réel.
Il regroupe des données (appelées attributs ou champs) et des comportements (appelés méthodes ou fonctions membres) dans une même structure.

La POO repose principalement sur les concepts suivants :

Abstraction : représenter les aspects essentiels d'un objet ou d'un comportement, sans s'intéresser à tous les détails de son implémentation.
Encapsulation : séparer les aspects externes d’un objet des détails de son implémentation interne, qui sont masqués pour protéger l’intégrité de l’objet.
Collaborations : construire des objets complexes à partir d’objets plus simples en définissant les relations qui les unissent.
Polymorphisme dynamique : manipuler des objets de types différents à travers une même abstraction.

{} Un peu d'histoire

La programmation orientée objet (POO) s'est progressivement imposée à partir des années 1980 et est devenue, dans les années 1990, le principal paradigme utilisé pour le développement des logiciels.
Elle proposait une nouvelle manière d'organiser les programmes en les structurant autour d'objets collaborant entre eux.
À cette époque, la POO suscitait de grands espoirs. Elle devait notamment permettre :

de mieux organiser les logiciels grâce à une répartition claire des responsabilités ;
de favoriser la réutilisation du code ;
de faciliter l'évolution et la maintenance des applications ;
de modéliser les problèmes sous forme d'objets proches des concepts du domaine étudié.

Au fil des années, l'expérience acquise sur de grands projets a cependant montré que certains mécanismes de la POO étaient plus efficaces que d'autres.
En particulier, l'héritage, qui occupait une place centrale dans les premiers langages orientés objet, peut conduire à des hiérarchies de classes difficiles à faire évoluer lorsqu'il est utilisé de manière excessive.
À l'inverse, d'autres principes, comme l'encapsulation, les interfaces, le polymorphisme ou la composition, se sont révélés particulièrement efficaces et occupent aujourd'hui une place essentielle dans la conception des logiciels.

La programmation orientée objet reste ainsi l'un des paradigmes les plus utilisés, mais les pratiques ont évolué avec l'expérience des développeurs.

Une approche moderne de la programmation orientée objet
L'expérience acquise sur de nombreux projets a conduit les développeurs à privilégier certains principes de conception qui facilitent l'évolution et la maintenance des logiciels.
Parmi les plus importants figurent :

La composition plutôt que l'héritage : il est souvent préférable de construire un objet en assemblant plusieurs composants plutôt qu'en multipliant les niveaux d'héritage.
Les interfaces pour représenter les comportements communs : le polymorphisme est aujourd'hui le plus souvent obtenu à l'aide d'interfaces, qui offrent une plus grande souplesse que les hiérarchies de classes.
Des classes ayant une responsabilité claire : chaque classe doit remplir un rôle bien défini et collaborer avec les autres à travers des interfaces simples.

L'objectif de la programmation orientée objet n'est donc pas seulement de représenter les objets du monde réel, mais surtout de concevoir des logiciels modulaires, faciles à comprendre, à tester et à faire évoluer.

C'est cette approche moderne et pragmatique que nous adopterons tout au long de ce cours.

{} Pourquoi C# et Rust ?

{} Organisation du cours

{} Les supports de labos

{} Validation des acquis

{} Environnement de développement

Les ordinateurs mis à disposition dans les salles de travaux pratiques disposent déjà de tous les outils nécessaires à la réalisation de cette série de laboratoires.
Aucune installation supplémentaire n'est donc requise.

Les étudiants qui souhaitent travailler sur leur ordinateur personnel trouveront dans cette section les instructions nécessaires pour installer les outils de développement et créer un projet en C# sous Linux Ubuntu ou sous Windows avec WSL.
Les autres systèmes d'exploitation (macOS, autres distributions Linux, etc.) ne sont pas couverts par ce support.
Les étudiants qui choisissent de les utiliser devront mettre en place eux-mêmes un environnement de développement compatible.

Les procédures d'installation et de configuration de l'environnement Rust, utilisées en S3 et en S4, ne sont pas reprises ici.
Les liens vers ces ressources sont simplement rappelés pour les étudiants qui souhaitent les réutiliser lors des comparaisons avec Rust proposées dans ce cours.

{} C# - Installer le SDK .NET sous Ubuntu et Windows (WSL)

Les procédures suivantes s'appliquent aussi bien à Ubuntu qu'à Windows lorsque celui-ci utilise WSL. Une fois WSL installé, les commandes sont identiques.

Commencez par mettre à jour la liste des paquets :

sudo apt update

Installez ensuite le SDK .NET :

sudo apt install dotnet-sdk-10.0

Vérifiez enfin l'installation :

dotnet --version

Si vous utilisez Windows sans WSL, installez d'abord WSL en suivant les instructions de Microsoft.

{} Créer et exécuter un projet C#

{} Configuration de Roslyn pour C# dans Sublime Text

Cette configuration permet à Sublime Text de fournir une analyse du code C# : détection des erreurs, complétion, navigation dans le code, etc.

Prérequis
Avant de commencer, vous devez disposer de :

WSL2 avec Ubuntu 24.04 LTS
.NET 10 SDK installé dans Ubuntu
Sublime Text installé dans Ubuntu sous WSL

Toutes les commandes ci-dessous doivent être exécutées dans un terminal Ubuntu, et non dans PowerShell ou dans l'invite de commandes Windows.

Vous pouvez vérifier la version de .NET avec :

dotnet --version

Vous devez obtenir une version 10.x.

1. Installer le serveur Roslyn
Roslyn est le compilateur et l'analyseur de code C# de Microsoft.
Nous allons utiliser son Language Server, qui permet à Sublime Text de communiquer avec Roslyn via le protocole LSP.

Dans un terminal Ubuntu, exécutez :

dotnet tool install --global roslyn-language-server --prerelease

Le serveur est installé comme un outil .NET global.

Vous pouvez vérifier qu'il est bien installé avec :

ls ~/.dotnet/tools/roslyn-language-server

Le fichier doit exister.

Attention : il ne faut pas essayer de lancer simplement roslyn-language-server pour vérifier son fonctionnement.
Le serveur est conçu pour être lancé par un éditeur et communiquer avec celui-ci via le protocole LSP.

2. Installer LSP dans Sublime Text
LSP est le plugin de Sublime Text qui permet de communiquer avec des Language Servers.

Dans Sublime Text :
Tools → Install Package Control
si Package Control n'est pas encore installé.

Puis :
Ctrl + Shift + P

et rechercher :

Package Control: Install Package

Sélectionner ensuite :

LSP

Installer le package LSP.

3. Configurer Roslyn dans LSP
Dans Sublime Text, ouvrir :
Preferences → Package Settings → LSP → Server Configurations

Un fichier de configuration s'ouvre.
Ajouter la configuration suivante :

{
    "roslyn": {
        "enabled": true,
        "command": [
            "${home}/.dotnet/tools/roslyn-language-server",
            "--logLevel",
            "Warning",
            "--autoLoadProjects",
            "--stdio"
        ],
        "selector": "source.cs",
        "syntax_map": {
            "roslyn-source-generated": "C#.sublime-syntax"
        }
    }
}

Enregistrez le fichier.

5. Vérifier que Roslyn fonctionne
Ouvrez un projet C# dans Sublime Text. Dans un fichier .cs du projet, introduisez volontairement une erreur.
Par exemple :

int x = "bonjour";

Sublime Text doit signaler l'erreur.

Vous pouvez également tester :

Console.WriteLine(variableInexistante);

Une erreur doit apparaître sous le code ou dans la marge.

Si les erreurs apparaissent automatiquement, Roslyn fonctionne correctement.

En cas de problème
Dans Sublime Text, ouvrez la palette de commandes avec : Ctrl + Shift + P puis utilisez :

LSP: Troubleshoot Server

et sélectionnez :

roslyn

Vous pouvez également utiliser :

LSP: Toggle Log Panel

pour afficher les messages du serveur LSP.

{} Rust - Installer le compilateur