Maîtriser le principe DRY : Appliquer les Design Patterns en C# pour un code plus propre

Etapes et exemples:

1. Code initial: La logique de génération de l'identifiant de l'employé se trouvait directement dans le gestionnaire d'événement de clic d'un bouton.

   

2. <Tim améliore la méthode en la rendant plus flexible. Au lieu de se fier à des éléments d'interface spécifiques, la méthode accepte désormais firstName et lastName comme paramètres et retourne l'ID généré. Cette modification permet d'utiliser la méthode dans différents contextes et éléments d'interface utilisateur :

   private string GenerateEmployeeID(string firstName, string lastName)
   {
     string employeeID = firstName.Substring(0, 4) + lastName.Substring(0, 4) + DateTime.Now.Millisecond.ToString();
     return employeeID;
   }

   private string GenerateEmployeeID(string firstName, string lastName)
   {
     string employeeID = firstName.Substring(0, 4) + lastName.Substring(0, 4) + DateTime.Now.Millisecond.ToString();
     return employeeID;
   }

   Tim montre ensuite comment cette méthode est appelée à partir de l'événement de clic :

   employeeIdText.Text = GenerateEmployeeID(firstNameText.Text, lastNameText.Text);

   employeeIdText.Text = GenerateEmployeeID(firstNameText.Text, lastNameText.Text);

   Il note également que cette méthode peut désormais être utilisée dans d'autres parties de l'application, par exemple pour traiter des fichiers CSV contenant plusieurs enregistrements d'employés, sans avoir à répéter le code.

Etapes et exemples:

1. Création de la bibliothèque de classes:

   • Tim, à (9:47), crée un nouveau projet de bibliothèque de classes dans .NET Framework, qu'il nomme DRYDemoLibrary.

   • À l'intérieur de cette bibliothèque, il définit une classe publique EmployeeProcessor et déplace la méthode GenerateEmployeeID dans cette classe :

     public class EmployeeProcessor
     {
      public string GenerateEmployeeID(string firstName, string lastName)
      {
         string employeeID = firstName.Substring(0, 4) + lastName.Substring(0, 4) + DateTime.Now.Millisecond.ToString();
         return employeeID;
      }
     }

     public class EmployeeProcessor
     {
      public string GenerateEmployeeID(string firstName, string lastName)
      {
         string employeeID = firstName.Substring(0, 4) + lastName.Substring(0, 4) + DateTime.Now.Millisecond.ToString();
         return employeeID;
      }
     }

2. Utilisation de la bibliothèque de classes dans les projets:

   • Dans ses projets WinForms (13:18) et WPF (14:00), Tim ajoute une référence à la bibliothèque de classes DRYDemoLibrary.

   • Il remplace ensuite l'ancien code par des appels à la méthode GenerateEmployeeID depuis la bibliothèque de classes :

     EmployeeProcessor processor = new EmployeeProcessor();
     employeeIDText.Text = processor.GenerateEmployeeID(firstNameText.Text, lastNameText.Text);

     EmployeeProcessor processor = new EmployeeProcessor();
     employeeIDText.Text = processor.GenerateEmployeeID(firstNameText.Text, lastNameText.Text);

   • Cette approche élimine la redondance, puisque la méthode est désormais conservée en un seul endroit. Tim démontre que la même bibliothèque de classes peut être utilisée dans différents cadres d'interface utilisateur (WinForms et WPF) sans répéter le code.

3. Avantages:

   • <En centralisant la logique dans une bibliothèque de classes, Tim garantit que les modifications apportées à la logique (par exemple, les corrections de bogues) sont appliquées de manière uniforme dans tous les projets.

   • Maintenance réduite: Les modifications apportées à la méthode ne doivent être effectuées que dans la bibliothèque de classes, ce qui permet d'éviter les incohérences et de réduire les frais généraux de maintenance.

Etapes et exemples:

1. Création d'une nouvelle solution et d'un nouveau projet:

   • Tim, à (17:29), commence par créer une nouvelle solution pour une application console, en simulant un scénario dans lequel vous pourriez avoir besoin d'utiliser la bibliothèque DRYDemo dans un autre type de projet, comme un service Windows ou une application console.

   • Il nomme le nouveau projet ConsoleUI et montre comment configurer une application console de base.

     class Program
     {
      static void Main(string[] args)
      {
         Console.ReadLine();
      }
     }

     class Program
     {
      static void Main(string[] args)
      {
         Console.ReadLine();
      }
     }

2. Ajouter une référence à la bibliothèque de classes:

   • Tim explique comment ajouter une référence à la DLL DRYDemoLibrary dans le nouveau projet. Il s'agit de naviguer jusqu'au fichier DLL dans le dossier bin du projet de bibliothèque de classes et de l'ajouter à l'application console.

     using DRYDemoLibrary;

     using DRYDemoLibrary;

   • Une fois la référence ajoutée, Tim (19:24) utilise la classe EmployeeProcessor de la bibliothèque pour générer un identifiant d'employé à partir des données saisies par l'utilisateur.

     Console.WriteLine("What is your first name?");
     string firstName = Console.ReadLine();
     
     Console.WriteLine("What is your last name?");
     string lastName = Console.ReadLine();
     
     EmployeeProcessor processor = new EmployeeProcessor();
     string employeeID = processor.GenerateEmployeeID(firstName, lastName);
     
     Console.WriteLine($"Your employee ID is {employeeID}");

     Console.WriteLine("What is your first name?");
     string firstName = Console.ReadLine();
     
     Console.WriteLine("What is your last name?");
     string lastName = Console.ReadLine();
     
     EmployeeProcessor processor = new EmployeeProcessor();
     string employeeID = processor.GenerateEmployeeID(firstName, lastName);
     
     Console.WriteLine($"Your employee ID is {employeeID}");

3. Exécution de l'application console:

   • Tim montre l'exécution de l'application console pour montrer qu'elle génère avec succès l'identifiant de l'employé à l'aide de la bibliothèque. Cela confirme que le même code de la bibliothèque de classes peut être réutilisé dans différents projets.

     

4. Mise à jour de la DLL:

   • Tim mentionne brièvement que si la DLL change, vous pouvez la mettre à jour dans les projets qui y font référence. Il note que, bien que cette vidéo ne l'aborde pas en détail, l'utilisation des packages NuGet est une approche recommandée pour la gestion et la mise à jour des DLL dans plusieurs projets.

Points Clés :

1. Création d'un package NuGet:

   • Au lieu de gérer manuellement les fichiers DLL, Tim suggère de créer un package NuGet pour la bibliothèque de classes. Il s'agit de conditionner la DLL dans un package NuGet et de la télécharger sur un serveur NuGet (privé ou public).

2. Mise à jour des paquets:

   • En utilisant un package NuGet, vous pouvez mettre à jour la bibliothèque dans tous les projets qui y font référence en mettant simplement à jour la version du package. Cela permet de garantir la cohérence et de réduire le risque de décalage entre les versions ou d'absence de mises à jour.

3. Avantages:

   • Gestion centralisée : Les packages NuGet constituent un moyen centralisé de gérer les versions et les dépendances des bibliothèques.

   • Facilité des mises à jour: La mise à jour de la bibliothèque dans le cadre de plusieurs projets devient plus facile et plus fiable.

   • Intégration: NuGet s'intègre à divers outils et environnements de développement, rationalisant ainsi le processus de gestion des dépendances des bibliothèques.

Configuration du test initial

Tim commence par exécuter un test unitaire qui échoue actuellement en raison d'un bogue dans la DLL. Il souligne l'importance des tests unitaires pour identifier les problèmes, même lorsque le code se trouve en dehors de la solution principale. Le code s'attendait à une entrée de 4 lettres, mais Tim a transmis un prénom de 3 lettres qui se plante dans le fichier DLL même s'il n'est pas directement inclus dans la solution.

Refacturer le code pour résoudre les bogues

Pour résoudre le problème de la gestion des prénoms, Tim remanie le code. Il explique comment la méthode DRY peut être appliquée au développement en créant un nouveau projet de bibliothèque de classes (23:50). Cette approche permet de s'assurer que les modifications apportées à plusieurs objets peuvent être effectuées une seule fois et testées efficacement sans répéter les corrections.

Ajouter des tests unitaires

Tim introduit une nouvelle classe de test, EmployeeProcessorTest, dans le projet de bibliothèque de classes et met en place des tests unitaires à l'aide de XUnit. Il montre comment créer une méthode de test pour générer des identifiants d'employés et discute de l'importance de simuler des dépendances au lieu de se fier à des valeurs réelles.

Écrire une méthode de test

Tim écrit une méthode de test unitaire appelée GenerateEmployeeID_ShouldCalculate. Il met en place une théorie avec des données en ligne pour tester différents scénarios, en s'assurant que la méthode renvoie les résultats escomptés. Il explique également comment utiliser Assert.Equal pour vérifier la sortie.

public class EmployeeProcessorTest
{
   [Theory]
   [InlineData("Timothy", "Corey", "TimoCore")]
   public void GenerateEmployeeID_ShouldCalculate(string firstName, string lastName, string expectedStart)
   {
      // Arrange
      var processor = new EmployeeProcessor();

      // Act
      var actualStart = processor.GenerateEmployeeID(firstName, lastName).Substring(0, 8);

      // Assert
      Assert.Equal(expectedStart, actualStart);
   }
}

public class EmployeeProcessorTest
{
   [Theory]
   [InlineData("Timothy", "Corey", "TimoCore")]
   public void GenerateEmployeeID_ShouldCalculate(string firstName, string lastName, string expectedStart)
   {
      // Arrange
      var processor = new EmployeeProcessor();

      // Act
      var actualStart = processor.GenerateEmployeeID(firstName, lastName).Substring(0, 8);

      // Assert
      Assert.Equal(expectedStart, actualStart);
   }
}

Exécution du test unitaire

Tim insiste sur l'importance d'utiliser des données dynamiques, telles que des valeurs de date et d'heure, pour contrôler les conditions et les résultats des tests. Il aborde la difficulté de travailler avec des chaînes dynamiques et la manière de tester différents scénarios à l'aide de valeurs contrôlées. Il exécute ensuite le test unitaire mais avant cela, il ajoute deux packages NuGet nécessaires pour exécuter les tests : xunit.runner.console et xunit.runner.visualstudio.

Après avoir exécuté avec succès tous les tests pour une donnée en ligne, la sortie se présente comme suit :

Maintenant à (31:30), Tim a ajouté une autre donnée inline et a changé le second paramètre de sous-chaîne en expectedStart.Length :

public class EmployeeProcessorTest
{
   [Theory]
   [InlineData("Timothy", "Corey", "TimoCore")]
   [InlineData("Tim", "Corey", "TimCore")]
   public void GenerateEmployeeID_ShouldCalculate(string firstName, string lastName, string expectedStart)
   {
      var processor = new EmployeeProcessor();
      var actualStart = processor.GenerateEmployeeID(firstName, lastName).Substring(0, expectedStart.Length);
      Assert.Equal(expectedStart, actualStart);
   }
}

public class EmployeeProcessorTest
{
   [Theory]
   [InlineData("Timothy", "Corey", "TimoCore")]
   [InlineData("Tim", "Corey", "TimCore")]
   public void GenerateEmployeeID_ShouldCalculate(string firstName, string lastName, string expectedStart)
   {
      var processor = new EmployeeProcessor();
      var actualStart = processor.GenerateEmployeeID(firstName, lastName).Substring(0, expectedStart.Length);
      Assert.Equal(expectedStart, actualStart);
   }
}

Après avoir réexécuté le test unitaire à (32:05), le test s'est interrompu avec la deuxième théorie :

Améliorer le code avec des méthodes privées

Pour adhérer au principe DRY, Tim refactorise le code davantage en créant une méthode privée GetPartOfName dans la classe actuelle EmployeeProcessor sous DRYDemoLibrary. Cette méthode permet d'extraire des parties d'un nom, ce qui améliore la réutilisation et la lisibilité du code. Tim a apporté les modifications suivantes :

public string GenerateEmployeeID(string firstName, string lastName)
{
   string employeeID = $@"{GetPartOfName(firstName, 4)}{GetPartOfName(lastName, 4)}{DateTime.Now.Millisecond.ToString()}";
   return employeeID;
}

private string GetPartOfName(string name, int numberOfCharacters)
{
   string output = name;

   if (name.Length > numberOfCharacters)
   {
      output = name.Substring(0, numberOfCharacters);
   }

   return output;
}

public string GenerateEmployeeID(string firstName, string lastName)
{
   string employeeID = $@"{GetPartOfName(firstName, 4)}{GetPartOfName(lastName, 4)}{DateTime.Now.Millisecond.ToString()}";
   return employeeID;
}

private string GetPartOfName(string name, int numberOfCharacters)
{
   string output = name;

   if (name.Length > numberOfCharacters)
   {
      output = name.Substring(0, numberOfCharacters);
   }

   return output;
}

Mise à jour des tests unitaires

Tim met à jour les tests unitaires pour refléter les changements apportés au code, tels que la modification de la longueur attendue des sous-chaînes. Il explique comment l'exécution de ces tests permet d'identifier rapidement les problèmes et de valider que le code répond aux nouvelles exigences. Tim ajoute de nouvelles théories et exécute ensuite les tests unitaires pour vérifier si les résultats sont conformes aux attentes :

Création d'une bibliothèque .NET Standard

Réduire les répétitions dans le développement

Tim Corey souligne qu'en adoptant une bibliothèque .NET Standard, vous minimisez la répétition du code non seulement dans votre base de code, mais aussi dans le processus de développement. Au lieu de dupliquer le code dans différents projets spécifiques à une plateforme, vous le centralisez dans une bibliothèque unique qui fonctionne dans plusieurs environnements.

Avantages:

• Base de code unifiée : Une base de code unique pour différentes plateformes réduit les efforts nécessaires pour maintenir et mettre à jour votre code.
• Tests simplifiés : Avec une bibliothèque .NET Standard, vous pouvez écrire des tests unitaires une seule fois et vous assurer qu'ils s'appliquent à toutes les plateformes prises en charge.

<Tim présente les tests unitaires comme un moyen de réduire les efforts et les répétitions. Les tests automatisés vérifient l'exactitude de votre code sans qu'il soit nécessaire de tester manuellement chaque itération de l'application.