Passer au contenu du pied de page
.NET AIDE

NBuilder .NET (Comment ça fonctionne pour les développeurs)

NBuilder est une bibliothèque .NET simplifiant la génération de données de test. Les développeurs peuvent créer des graphiques d'objets complexes sans effort avec son interface fluide. Il offre flexibilité, efficacité et intégration transparente avec les cadres de test populaires. Dans cet article, nous explorerons les fonctionnalités de NBuilder, comment l'installer et démontrer ses capacités avec des exemples de code pratiques.

NBuilder .NET (Comment cela fonctionne pour les développeurs) : Figure 1 - NBuilder

Fonctionnalités de NBuilder

  1. NBuilder est une bibliothèque open source .NET en C# conçue pour simplifier la création d'objets à des fins de test et de simulation. Elle permet aux développeurs de générer rapidement des objets avec des entrées par défaut ou spécifiées en fonction de différents types de données.
  2. Elle est particulièrement utile pour les tests unitaires, les tests fonctionnels et les tests d'intégration.
  3. C'est l'un des packages essentiels pour tester les types de données .NET intégrés et les objets complexes.
  4. Elle est utilisée pour la génération de données aléatoires. Vous pouvez contribuer à ce projet open source.
  5. Avec NBuilder, vous pouvez facilement remplacer les propriétés par défaut et écrire des configurations personnalisées.

Installation de NBuilder

Pour installer NBuilder dans la console du gestionnaire de packages NuGet, utilisez la commande suivante.

Install-Package NBuilder

La commande ci-dessus installera NBuilder avec toutes ses dépendances.

NBuilder .NET (Comment cela fonctionne pour les développeurs) : Figure 2 - Installer NBuilder

Utilisation de NBuilder

NBuilder fournit un moyen fluide de créer des objets à la volée. Commençons par un exemple simple de création d'un objet.

Voici le code source de la classe de modèle Person.

class Person
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Email { get; set; }
    public bool IsMarried { get; set; }
}
class Person
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Email { get; set; }
    public bool IsMarried { get; set; }
}
$vbLabelText   $csharpLabel

Exemple 1 : Création d'un objet Person avec des valeurs par défaut

// Create a new person object with default values using NBuilder
var person = Builder<Person>
                .CreateNew()
                .Build();
// By default, NBuilder can provide values like 
// Id = 1, Name = Name1, Email = Email1, IsMarried = false
// Create a new person object with default values using NBuilder
var person = Builder<Person>
                .CreateNew()
                .Build();
// By default, NBuilder can provide values like 
// Id = 1, Name = Name1, Email = Email1, IsMarried = false
$vbLabelText   $csharpLabel
![Image 2](/static-assets/barcode/how-to/async-multithread/sample2.webp) ![NBuilder .NET (Comment cela fonctionne pour les développeurs) : Figure 3 - Objet Person avec des valeurs](/static-assets/pdf/blog/nbuilder-net/nbuilder-net-3.webp) #### Exemple 2 : Création d'objets avec un générateur personnalisé Voici un exemple de la façon d'utiliser NBuilder pour créer et configurer un objet Person avec des propriétés personnalisées : ```csharp // Initialize a custom builder for the Person object with specific values var customPersonBuilder = Builder.CreateNew() .With(p => p.Name = "Tom") .With(p => p.Email = "Tom@email.com"); // Build the custom person object with the specified properties var objTom = customPersonBuilder.Build(); ``` Le code ci-dessus crée un nouvel objet Person avec des propriétés personnalisées. Il initialise un customPersonBuilder pour un objet Person, définissant le Name à "Tom" et l'Email à "Tom@email.com". Enfin, il construit l'objet et l'assigne à objTom. #### Exemple 3 : Création d'une liste d'objets Person avec une valeur par défaut ```csharp // Create a list of 10 Person objects with default values using NBuilder var personList = Builder .CreateListOfSize(10) .Build(); ```
![Image 2](/static-assets/barcode/how-to/async-multithread/sample2.webp) ![NBuilder .NET (Comment cela fonctionne pour les développeurs) : Figure 4 - Liste d'objets Person](/static-assets/pdf/blog/nbuilder-net/nbuilder-net-4.webp) Ici, personList contient 10 objets avec leurs valeurs par défaut et les imprime. ```csharp // Creating a list of 10 Person objects with default values var personList = Builder .CreateListOfSize(10) .Build(); // Print details of each Person object in the list foreach (var person in personList) { Console.WriteLine($"{person.Id}, {person.Name}, {person.Email}, {person.IsMarried}"); } ``` ![NBuilder .NET (Comment cela fonctionne pour les développeurs) : Figure 5 - Attribution automatique des valeurs](/static-assets/pdf/blog/nbuilder-net/nbuilder-net-5.webp) #### Exemple 4 : Personnalisation des objets générés Parfois, vous pouvez avoir besoin de personnaliser les objets créés. Vous pouvez également personnaliser la valeur d'un objet en utilisant la méthode `With()`. ```csharp // Customize properties for all Person objects in the list var personList = Builder .CreateListOfSize(10) .All() .With(p => p.Name = "Kim") .With(p => p.Email = "abc@email.com") .With(p => p.IsMarried = false) .Build(); ``` Cela crée une `personList` avec chaque objet ayant sa valeur par défaut remplacée par Name = "Kim", Email = "abc@email.com" et IsMarried = false. #### Exemple 5 : Création d'une liste d'objets Person avec des données réalistes et aléatoires Pour obtenir des valeurs de données réalistes dans la liste Person, vous pouvez utiliser la bibliothèque Faker .NET pour générer des données réalistes. ```csharp // Creating a list of Person objects with random yet realistic values using Faker var personList = Builder .CreateListOfSize(10) .All() .With(p => p.Name = Faker.Name.FullName()) .With(p => p.Id = Faker.RandomNumber.Next(20, 60)) .Build(); ``` **Exemple 6 : Création d'une liste d'objets Person avec des données séquentielles** Il y a des moments où vous pourriez avoir besoin de générer des objets avec des données séquentielles. NBuilder .NET facilite cela en utilisant la méthode **Do**. ```csharp // Creating a list of 10 sequential Person objects using NBuilder var personList = Builder.CreateListOfSize(10) .All() .Do((p, i) => p.Id = 501 + i) .Do((p, i) => p.Name = $"Person {i + 1}") .Build(); ``` Ici, la méthode `All()` garantit que les opérations subséquentes s'appliquent aux 10 objets Person créés en mémoire. La méthode `Do()` exécute le délégué `Action` sur chaque objet `Person`. Cette configuration attribue la propriété `Id` séquentiellement à partir de 501, et nomme chaque personne séquentiellement de "Person 1" à "Person 10". ![NBuilder .NET (Comment cela fonctionne pour les développeurs) : Figure 6 - Données séquentielles](/static-assets/pdf/blog/nbuilder-net/nbuilder-net-6.webp) **Exemple 7 : NBuilder avec test unitaire en utilisant Xunit** NBuilder dans .NET est significativement utilisé dans les environnements de test, où les développeurs ont besoin de générer un ensemble de données réalistes et diversifiées pour les tests. Il rend les tests faciles et maintenables avec des objets complexes qui permettent aux développeurs de définir une logique d'initialisation personnalisée en utilisant des expressions lambda et des fonctions de délégué répondant à ceux qui s'intéressent à la génération de données de test efficaces et flexibles. #### Classe modèle et service pour les tests unitaires ```csharp class Person { public int Id { get; set; } public string Name { get; set; } public string Email { get; set; } public bool IsMarried { get; set; } } class PersonService { public string GetPersonEmail(Person person) { return person.Email; } } ``` Ici, la classe `Person` possède plusieurs propriétés telles que `Id`, `Name`, `Email` et `IsMarried`, tandis que `PersonService` contient une méthode `GetPersonEmail()` qui renvoie l'email d'un `Person` donné. #### Classes de test et données de test ```csharp using Xunit; public class PersonTests { [Fact] public void GetPersonEmail_ReturnCorrectEmail() { // Arrange var service = new PersonService(); string expectedEmail = "Tom@email.com"; // Create a person with specific name and email using NBuilder var person = Builder.CreateNew() .With(p => p.Name = "Tom") .With(p => p.Email = "Tom@email.com") .Build(); // Act var actualEmail = service.GetPersonEmail(person); // Assert Assert.Equal(expectedEmail, actualEmail); } } ``` Ce test unitaire vérifie que la méthode `GetPersonEmail` de la classe `PersonService` renvoie correctement l'adresse e-mail d'un objet `Person` avec l'email attendu "Tom@email.com". Il utilise le modèle Arrange-Act-Assert pour mettre en place les données de test, exécuter la méthode, puis vérifier que le résultat réel correspond au résultat attendu. ## Intégration de NBuilder avec IronPDF [En savoir plus sur IronPDF](/) est une puissante bibliothèque C# conçue pour [créer des PDF à partir de HTML](/tutorials/html-to-pdf/) dans les applications .NET. Avec son API intuitive, les développeurs peuvent intégrer parfaitement la fonctionnalité PDF dans leurs projets, qu'ils génèrent des factures, des rapports ou des formulaires interactifs. ![NBuilder .NET (Comment cela fonctionne pour les développeurs) : Figure 7 - IronPDF](/static-assets/pdf/blog/nbuilder-net/nbuilder-net-7.webp) ### Installer IronPDF Ouvrez la console du gestionnaire de packages NuGet, et exécutez la commande suivante: ```shell :ProductInstall ``` #### Remplir la liste de 5 objets Person ```csharp // Generating instances of the Person class with NBuilder var people = Builder.CreateListOfSize(5).Build(); ``` #### Création d'un document PDF en utilisant IronPDF Ce code définit la clé de licence IronPDF et génère du contenu HTML à partir d'une liste d'objets Person. ```csharp // Setting the IronPDF license key IronPdf.License.LicenseKey = "Your-License-Key"; // Building HTML content from Person object list var htmlContent = "

Person List

"; foreach (var person in people) { htmlContent += $"

Id: {person.Id}, Name: {person.Name}, Email: {person.Email}, IsMarried: {person.IsMarried}

"; } ``` La `IronPdf.License.LicenseKey` est définie avec une clé de licence spécifique pour activer les fonctionnalités d'IronPDF. Le contenu HTML est construit dynamiquement à partir de la liste `people`, ajoutant chaque détail de l'objet `Person` dans la structure HTML. #### Rendu de la liste Person dans le document PDF en utilisant IronPDF Ce code convertit le contenu HTML en un document PDF en utilisant le **ChromePdfRenderer** de IronPDF. ```csharp // Rendering HTML content into a PDF document using IronPDF var renderer = new ChromePdfRenderer(); var pdfDoc = renderer.RenderHtmlAsPdf(htmlContent); pdfDoc.SaveAs("PersonList.pdf"); ``` **ChromePdfRenderer** est instancié pour rendre le contenu HTML stocké dans `htmlContent` en un document PDF. Le document PDF résultant est enregistré dans le système de fichiers avec le nom "PersonList.pdf". ## Sortie Ci-dessous se trouve le résultat de la liste Person générée par IronPDF. Il contient cinq personnes, chacune avec des valeurs par défaut. ![NBuilder .NET (Comment cela fonctionne pour les développeurs) : Figure 8 - Résultat PDF](/static-assets/pdf/blog/nbuilder-net/nbuilder-net-8.webp) ## Conclusion En conclusion, NBuilder est un outil robuste et flexible pour générer des données de test dans .NET, rationalisant la création de graphiques d'objets complexes et améliorant l'efficacité des processus de test. En s'intégrant à IronPDF, les développeurs peuvent facilement étendre leurs applications pour inclure des [ fonctionnalités de génération de PDF ](/tutorials/html-to-pdf/) pour ceux qui le trouvent précieux pour leurs projets. Ensemble, NBuilder et IronPDF peuvent considérablement améliorer les flux de travail de développement, rendant les tests et la génération de documents fluides et efficaces.

Questions Fréquemment Posées

Comment puis-je générer des données de test en utilisant NBuilder dans .NET ?

NBuilder fournit une interface fluide qui permet aux développeurs de générer facilement des graphes d'objets complexes et des données de test. Vous pouvez utiliser des méthodes telles que CreateNew() et CreateListOfSize() pour générer des objets uniques ou des listes d'objets avec des valeurs par défaut ou personnalisées.

Comment installer NBuilder dans un projet .NET ?

Pour installer NBuilder, vous pouvez utiliser la Console du Gestionnaire de Packages NuGet avec la commande : Install-Package NBuilder. Cela téléchargera et installera NBuilder ainsi que ses dépendances nécessaires.

NBuilder peut-il être utilisé pour générer des données aléatoires et séquentielles ?

Oui, NBuilder prend en charge la génération de données à la fois aléatoires et séquentielles. Vous pouvez personnaliser les propriétés des objets avec des méthodes telles que With() pour des valeurs aléatoires ou utiliser Do() pour définir les propriétés de manière séquentielle.

Quels sont les avantages d'intégrer NBuilder avec IronPDF ?

Intégrer NBuilder avec IronPDF permet aux développeurs de créer des données de test complexes et de les exporter sous forme de PDF. Cela peut améliorer les applications .NET en permettant la génération dynamique de PDF à partir de données de test, optimisant ainsi les workflows de développement.

Comment NBuilder aide-t-il aux tests unitaires ?

NBuilder est précieux dans les tests unitaires en permettant aux développeurs de générer rapidement des données de test réalistes. Il simplifie la configuration des scénarios de test avec des graphes d'objets complexes, rendant les tests plus maintenables et efficaces.

Quel est l'avantage d'utiliser une interface fluide dans NBuilder ?

L'interface fluide dans NBuilder permet aux développeurs de chaîner des appels de méthodes pour créer des graphes d'objets complexes de manière lisible et concise. Cela améliore la clarté du code et réduit le code répétitif lors de la génération de données de test.

Comment puis-je créer une liste d'objets avec NBuilder ?

Vous pouvez créer une liste d'objets en utilisant la méthode CreateListOfSize() de NBuilder. Par exemple, Builder.CreateListOfSize(10).Build() génère une liste de 10 objets Person.

Quels sont quelques conseils de dépannage pour utiliser NBuilder ?

Assurez-vous que NBuilder est correctement installé via NuGet et vérifiez que vos références de projet sont à jour. Si vous rencontrez des problèmes, consulter le dépôt GitHub de NBuilder ou les forums communautaires peut fournir des idées et des solutions utiles.

Jacob Mellor, Directeur technique @ Team Iron
Directeur technique

Jacob Mellor est directeur technique chez Iron Software et un ingénieur visionnaire pionnier dans la technologie des PDF en C#. En tant que développeur original derrière la base de code principale d'Iron Software, il a façonné l'architecture du produit de l'entreprise depuis sa création, ...

Lire la suite