TP 1 : Fondamentaux C# & Programmation Orientée Objet

Module : Programmation .Net C#

Niveau : 4ème année

Objectif : Maîtriser la syntaxe C# moderne, la gestion de classes et les collections pour préparer le terrain au développement Web.

Prérequis : SDK .NET et VS Code installés.

Activité 1 : Environnement et "Top-Level Statements"

Ouvrez votre terminal et naviguez vers votre dossier de travail.
Exécutez les commandes suivantes pour créer et ouvrir le projet :
```
dotnet new console -n WeatherStation
cd WeatherStation
code .
```
Ouvrez le fichier Program.cs. Vous verrez une seule ligne de code grâce aux Top-Level Statements :
```
Console.WriteLine("Hello, World!");
```
Lancez le programme via le terminal intégré de VS Code :
```
dotnet run
```

Activité 2 : Création d'une Classe Modèle

Dans VS Code, créez un nouveau fichier nommé Sensor.cs à côté de Program.cs. Définissez la classe suivante avec ses propriétés :

public class Sensor
{
    public int Id { get; set; }
    public string Name { get; set; } = string.Empty;
    public string Type { get; set; } = string.Empty;
    public double Value { get; set; }
}

Activité 3 : Instanciation et Interpolation

Retournez dans Program.cs. Effacez le "Hello World" et écrivez le code suivant pour manipuler votre classe :

var sensor = new Sensor
{
    Id = 1,
    Name = "Sensor_1",
    Type = "Temperature",
    Value = 24.5
};

Console.WriteLine($"Alerte: {sensor.Name} ({sensor.Type}) = {sensor.Value}");

Lancez avec dotnet run. Vérifiez que l'alerte s'affiche.

Activité 4 : Les Collections (List vs Array)

En Data Science, on gère rarement un seul objet. En C#, on utilise List<T> (équivalent du vector en C++ ou list en Python) plutôt que les tableaux statiques [].

Modifiez Program.cs pour gérer une flotte de capteurs :

var dataLake = new List<Sensor>();

dataLake.Add(new Sensor { Id = 1, Name = "Sensor_1", Type = "Temperature", Value = 24.5 });
dataLake.Add(new Sensor { Id = 2, Name = "Sensor_2", Type = "Humidity", Value = 50.0 });
dataLake.Add(new Sensor { Id = 3, Name = "Sensor_3", Type = "CO2", Value = 400.0 });

foreach(var s in dataLake)
{
    Console.WriteLine($"[{s.Id}] {s.Name} => {s.Value}");
}

Lancez le programme. Ajoutez un capteur supplémentaire dans la liste et relancez.

✅ Synthèse

Structure : Le point d'entrée est implicite dans Program.cs. Les classes sont organisées par namespace.
Typage : C# est fortement typé, mais var permet de laisser au compilateur de deviner le type (ex: var x = new List<string>()).
Properties : On utilise public int Age { get; set; } au lieu de créer manuellement Get/Set. C'est l'encapsulation standard en .NET.
Collections : List<T> est la structure de données dynamique la plus courante.
Mémoire : Les objets (class) sont des types Référence. Pas de malloc/free, le Garbage Collector nettoie la mémoire.

Exercices d'Application : Simulation & Analyse

Contexte : Vous êtes chargé de développer le module de collecte d'une station météo. Vous devez simuler des données, les analyser pour détecter des anomalies, et les préparer pour l'envoi.

Exercice 1 : Génération de "Big Data" (Simulée)

Au lieu de créer les objets un par un, nous allons générer un jeu de données plus conséquent.

Consigne :

Dans Program.cs, effacez le code de test précédent. Écrivez un code qui génère une liste List<Sensor> contenant 100 capteurs.

Les IDs doivent aller de 1 à 100.
Les noms doivent être Sensor_1, Sensor_2, etc.
Le Type doit être choisi aléatoirement entre "Temperature", "Humidity" et "CO2".
La Valeur doit être aléatoire (ex: entre 0 et 100).

Aide : Utilisez la classe Random et une boucle for.

Exercice 2 : Analyse Statistique (Algorithmique)

Maintenant que vous avez les données, nous allons faire des calculs sans utiliser de bibliothèques avancées, pour bien comprendre la manipulation des boucles en C#.

Consignes :

En parcourant la liste dataLake avec une boucle foreach, calculez et affichez :

La moyenne globale de toutes les valeurs.
Le nom et la valeur du capteur ayant la valeur maximale.
Le nombre de capteurs de type "CO2" qui dépassent la valeur 80 (Seuil critique).

Question de réflexion

Regardez votre code de l'Exercice 2 (le calcul de la moyenne et du max).

Imaginez devoir filtrer uniquement les températures, les trier par ordre décroissant, puis prendre les 5 premières.
Combien de lignes de code et de boucles if / for faudrait-il ?

(Cela introduit le besoin de LINQ).

TP 1: C# Fundamentals & Object-Oriented Programming

Module: .Net C# Programming

Level: 4th Year

Objective: Master modern C# syntax, class management, and collections to pave the way for Web development.

Prerequisite: .NET SDK and VS Code installed.

Activity 1: Environment and "Top-Level Statements"

Open your terminal and navigate to your working directory.
Execute the following commands to create and open the project:
```
dotnet new console -n WeatherStation
cd WeatherStation
code .
```
Open the Program.cs file. You will see a single line of code thanks to Top-Level Statements:
```
Console.WriteLine("Hello, World!");
```
Run the program via the integrated VS Code terminal:
```
dotnet run
```

Activity 2: Creating a Model Class

In VS Code, create a new file named Sensor.cs next to Program.cs. Define the following class with its properties:

public class Sensor
{
    public int Id { get; set; }
    public string Name { get; set; } = string.Empty;
    public string Type { get; set; } = string.Empty;
    public double Value { get; set; }
}

Activity 3: Instantiation and Interpolation

Return to Program.cs. Delete the "Hello World" and write the following code to manipulate your class:

var sensor = new Sensor
{
    Id = 1,
    Name = "Sensor_1",
    Type = "Temperature",
    Value = 24.5
};

Console.WriteLine($"Alert: {sensor.Name} ({sensor.Type}) = {sensor.Value}");

Run with dotnet run. Verify that the alert is displayed.

Activity 4: Collections (List vs Array)

In Data Science, we rarely handle a single object. In C#, we use List<T> (equivalent to vector in C++ or list in Python) rather than static arrays [].

Modify Program.cs to manage a fleet of sensors:

var dataLake = new List<Sensor>();

dataLake.Add(new Sensor { Id = 1, Name = "Sensor_1", Type = "Temperature", Value = 24.5 });
dataLake.Add(new Sensor { Id = 2, Name = "Sensor_2", Type = "Humidity", Value = 50.0 });
dataLake.Add(new Sensor { Id = 3, Name = "Sensor_3", Type = "CO2", Value = 400.0 });

foreach(var s in dataLake)
{
    Console.WriteLine($"[{s.Id}] {s.Name} => {s.Value}");
}

Run the program. Add an extra sensor to the list and run it again.

✅ Synthesis

Structure: The entry point is implicit in Program.cs. Classes are organized by namespace.
Typing: C# is strongly typed, but var allows the compiler to infer the type (e.g., var x = new List<string>()).
Properties: We use public int Age { get; set; } instead of manually creating Get/Set methods. This is standard encapsulation in .NET.
Collections: List<T> is the most common dynamic data structure.
Memory: Objects (classes) are Reference types. No malloc/free; the Garbage Collector reclaims unused memory.

Application Exercises: Simulation & Analysis

Context: You are tasked with developing the data collection module for a weather station. You must simulate data, analyze it to detect anomalies, and prepare it for transmission.

Exercise 1: Generating (Simulated) "Big Data"

Instead of creating objects one by one, we will generate a larger dataset.

Instruction:

In Program.cs, delete the previous test code. Write code that generates a List<Sensor> containing 100 sensors.

IDs should range from 1 to 100.
Names should be Sensor_1, Sensor_2, etc.
Type should be randomly chosen between "Temperature", "Humidity", and "CO2".
Value should be random (e.g., between 0 and 100).

Hint: Use the Random class and a for loop.

Exercise 2: Statistical Analysis (Algorithmic)

Now that you have the data, we will perform calculations without using advanced libraries, to properly understand loop manipulation in C#.

Instructions:

Iterating through the dataLake list with a foreach loop, calculate and display:

The overall average of all values.
The name and value of the sensor with the maximum value.
The number of "CO2" sensors that exceed the value 80 (Critical threshold).

Reflection Question

Look at your code from Exercise 2 (calculating the average and max).

Imagine having to filter only temperatures, sort them in descending order, and then take the top 5.
How many lines of code and if / for loops would you need?

(This introduces the need for LINQ).

🎙️ Sélectionner une voix

🎙️ Select a voice