Aller au contenu

TP : Intégration et Gestion de Versions chez "MathTech Solutions"

Contexte :
Vous rejoignez l'équipe de développement de MathTech Solutions. Votre responsable technique, Sarah, vous envoie vos tâches par courriel au fil de la journée.

Règles d'or de l'entreprise
  1. Langue : Tous les noms de branches (sauf main) et tous les messages de commit doivent être en français.
  2. Workflow : On ne touche jamais directement à main pour le code. Tout passe par une branche d'intégration nommée dev.

Prérequis :
Le dépôt a été créé pour vous via GitHub Classroom.
 Vous devez avoir l'URL de votre dépôt sous la main.

Démarrage - La propreté avant tout

De : Sarah Connor (Tech Lead)

Objet : Démarrage - La propreté avant tout

Bienvenue ! Ton dépôt est prêt.
Avant même d'écrire une ligne de code C#, on doit s'assurer que le dépôt restera propre. On ne veut surtout pas versionner les fichiers temporaires de Visual Studio (bin, obj, .vs).

Tes tâches :

Solution
  1. Ouvre ton terminal (Git Bash ou PowerShell) et clone ton dépôt :
    git clone <L_URL_DE_TON_DEPOT>
  2. Entre dans le dossier créé : cd TP_MathTech_VotreNom (ou le nom exact du dossier).
  3. Le .gitignore :
    • Va sur Google, cherche "github gitignore visual studio".
    • Prends le contenu du fichier officiel (souvent un lien "Raw").
    • Crée un fichier nommé .gitignore à la racine du dossier (là où se trouve le dossier caché .git) et colle le contenu dedans.
  4. Fais le tout premier commit du projet (c'est une bonne pratique de commencer par ça) :
    git add .gitignore
git commit -m "Config : Ajout du gitignore pour Visual Studio"

Création de l'architecture

De : Sarah Connor (Tech Lead)

Objet : Création de l'architecture

Parfait, le dépôt est sécurisé contre les fichiers inutiles. On peut créer la solution.
J'aimerais que tu crées une solution Visual Studio contenant une Bibliothèque de classes nommée Bibliotheque-git-<da> et un projet Console nommé Console-git-<da>. Une fois que c'est fait, envoie-moi une capture d'écran de l'explorateur de solutions dans Visual Studio pour confirmer la structure, et la sortie de git status pour vérifier que bin, obj et .vs ne sont pas suivis.

Tes tâches :

Solution
  1. Lance Visual Studio 2026.
  2. Crée une nouvelle solution dans ton dossier cloné :
    • Nom de la Solution : [NOM_SOLUTION]
    • Ajoute un projet Bibliothèque de classes nommé Bibliotheque-git-<da>.
    • Ajoute un projet Console nommé Console-git-<da>.
  3. Dans la librairie, renomme Class1.cs en Calculatrice.cs (et mets la classe public static).
  4. Vérifie avec git status que les dossiers bin et obj n'apparaissent pas (grâce à ton travail précédent).
  5. Valide la structure sur la branche principale :
    git add .
git commit -m "Initialisation : Structure de la solution C#"
  6. Création de la branche de développement :
    À partir de maintenant, main est sacré. Crée la branche dev et place-toi dessus :
    git checkout -b dev

Attention à tes fichiers personnels !

De : Sarah Connor (Tech Lead)

Objet : URGENT - J'ai fait une gaffe avec un fichier perso !

Oh là là, j'ai fait une grosse bêtise !
J'étais en train de prendre des notes rapidement dans un fichier note_personnelle.txt et, sans faire attention, je l'ai ajouté à l'index de Git (git add .) !
Je ne veux absolument pas que ce fichier finisse sur le dépôt. Je sais qu'il faut l'enlever du staging, mais je ne me souviens plus de la commande exacte.

Tu lui répondrais quoi ? Comment ferait-on pour retirer ce fichier de l'index sans le supprimer de mon ordinateur ?

Scénario à reproduire :

Après avoir lu le courriel de Sarah, voici comment tu pourrais l'aider :

Solution
  1. Crée un fichier texte nommé note_personnelle.txt à la racine du projet.
  2. Ajoute-le à l'index par erreur (oups !) :
    git add .
  3. Vérifie le statut (il doit être vert, prêt à être commité) :
    git status
  4. Correction : Pour garder le fichier sur ton ordi et l'enlever de Git de l'index :
    git rm --cached note_personnelle.txt
    (Note: La commande git rm --cached <fichier> désindexe le fichier et le supprime du suivi Git. Une alternative plus sécuritaire, git restore --staged <fichier>, désindexe le fichier sans le supprimer du suivi et sans toucher à votre copie locale, réduisant ainsi le risque d'effacement accidentel. Nous utiliserons ici git rm --cached comme demandé, mais gardez l'alternative git restore --staged en tête.)
  5. Pour éviter de refaire l'erreur, ajoute note_personnelle.txt à la fin de ton fichier .gitignore.
  6. Valide la mise à jour du gitignore sur la branche dev :
    git add .gitignore
git commit -m "Config : Ignorer les notes personnelles"

Dev de l'addition

De : Sarah Connor (Tech Lead)

Objet : Dev de l'addition - Implémentation de la fonction d'addition

C'est parti pour développer une nouvelle fonctionnalité !
N'oublie pas que l'on part toujours de la branche dev pour créer une fonctionnalité. Pour cette tâche, tu créeras une branche nommée fonctionnalite/addition.
J'ai besoin que tu implémentes la méthode d'addition suivante dans Calculatrice.cs :

public static int Additionner(int a, int b)  
{  
    return a + b;  
}
Une fois que tu as intégré cette méthode et fusionné ta branche de fonctionnalité dans dev, envoie-moi la sortie de git log --graph --oneline pour que je voie l'historique des commits.

Tes tâches :

Solution
  1. Crée une branche nommée fonctionnalite/addition (depuis dev).
  2. Implémente la méthode Additionner dans Calculatrice.cs selon les spécifications de Sarah.
  3. Valide ton travail :
    git add .
git commit -m "Fonctionnalité : Ajout de la méthode Additionner"
  4. Intégration :
    • Reviens sur la branche dev (git checkout dev).
    • Fusionne ta fonctionnalité :
      git merge fonctionnalite/addition
    • Vérifie l'historique avec :
      git log --graph --oneline

Implémentation de ta méthode Diviser (simple)

De : Sarah Connor (Tech Lead)

Objet : Dev - Implémentation de ta méthode Diviser (simple)

Maintenant, c'est à ton tour !
Crée une nouvelle branche depuis dev, par exemple fonctionnalite/division-simple.
J'ai besoin que tu implémentes la méthode Diviser suivante dans Calculatrice.cs :

public static double Diviser(int a, int b)  
{  
    return (double)a / b;  
}
Une fois que ta méthode est prête et que ta branche de fonctionnalité est fusionnée dans dev, envoie-moi le code final de Calculatrice.cs et la sortie de git log --graph --oneline pour que je valide ton travail.

Tes tâches :

Solution
  1. Assure-toi d'être sur la branche dev (git checkout dev).
  2. Crée une nouvelle branche pour ta fonctionnalité de division, par exemple fonctionnalite/division-simple (git checkout -b fonctionnalite/division-simple).
  3. Dans le fichier Calculatrice.cs, ajoute ta version de la méthode Diviser (une simple division sans gestion d'erreur) :
    public static double Diviser(int a, int b)
{
    return (double)a / b;
}
  4. Valide ton travail sur ta branche :
    git add .
git commit -m "Fonctionnalité : Ajout de ma version simple de la méthode Diviser"
  5. Retourne sur la branche dev (git checkout dev).
  6. Fusionne ta branche fonctionnalite/division-simple dans dev :
    git merge fonctionnalite/division-simple

Amélioration de la méthode Diviser (avec gestion d'erreur)

De : Sarah Connor (Tech Lead)

Objet : Dev - Amélioration de la méthode Diviser

Excellent ! Maintenant que la version de base de Diviser est en place, j'aimerais que tu l'améliores.
Crée une nouvelle branche depuis dev, par exemple fonctionnalite/division-gestion-erreur.
Dans cette branche, tu vas modifier la méthode Diviser dans Calculatrice.cs pour inclure une vérification de division par zéro, comme ceci :

public static double Diviser(int a, int b)  
{  
    if (b == 0) throw new Exception("Division par zéro impossible");  
    return (double)a / b;  
}
Une fois que tu as implémenté cette version et que tu l'as fusionnée dans dev, envoie-moi le code final de Calculatrice.cs et la sortie de git log --graph --oneline pour que je valide l'historique des commits et le code résultant.

Tes tâches :

Solution
  1. Assure-toi d'être sur la branche dev (git checkout dev).
  2. Crée une nouvelle branche pour cette amélioration, par exemple fonctionnalite/division-gestion-erreur (git checkout -b fonctionnalite/division-gestion-erreur).
  3. Dans le fichier Calculatrice.cs, modifie la méthode Diviser pour inclure la gestion d'erreur :
    public static double Diviser(int a, int b)
{
    if (b == 0) throw new Exception("Division par zéro impossible");
    return (double)a / b;
}
  4. Valide ton travail sur ta branche :
    git add .
git commit -m "Fonctionnalité : Amélioration de la méthode Diviser avec gestion d'erreur"
  5. Retourne sur la branche dev (git checkout dev).
  6. Tente de fusionner ta branche fonctionnalite/division-gestion-erreur dans dev :
    git merge fonctionnalite/division-gestion-erreur
    💥 Un conflit devrait être détecté ici, car tu as déjà une version de Diviser sur dev!
  7. Résolution du conflit :
    • Ouvre Calculatrice.cs dans ton éditeur de texte.
    • Tu verras des marqueurs de conflit (<<<<<<<, =======, >>>>>>>) indiquant les différences entre la version de dev (ta version simple) et ta nouvelle version (avec gestion d'erreur).
    • Modifie le fichier pour combiner les deux versions. L'objectif est de garder la nouvelle fonctionnalité de division avec la vérification de division par zéro. Le code final devrait ressembler à ceci :
      public static double Diviser(int a, int b)
{
    if (b == 0) throw new Exception("Division par zéro impossible");
    return (double)a / b;
}
    • Attention : Assure-toi de supprimer tous les marqueurs de conflit !
  8. Marque le conflit comme résolu et finalise la fusion :
    git add Calculatrice.cs
git commit -m "Fusion : Résolution de conflit sur la méthode Diviser (intégration de la version avec gestion d'erreur)"

Version 1.0

De : Sarah Connor (Tech Lead)

Objet : Version 1.0

Excellent travail !
Le développement est terminé. La branche dev est stable et testée.
C'est le moment de déployer !

Une fois que dev est fusionnée dans main, j'aimerais que tu places un tag v1.0 sur le commit le plus récent de main pour marquer cette version.

Après cela, envoie-moi la sortie complète de git log --graph --oneline --all ainsi que git tag pour que je puisse valider l'historique final de toutes les branches et les tags.

Tes tâches :

Solution
  1. Reviens sur la branche main.
  2. Fusionne le travail de dev vers main.
    git merge dev
  3. Place le tag v1.0 sur le commit actuel de main :
    git tag -a v1.0 -m "Release v1.0"
  4. Admire ton graphe final et les tags, puis appelle-moi pour la validation :
    git log --graph --oneline --all
git tag