Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. NBuilder .NET
.NET AIDE

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

Curtis Chau
Curtis Chau
Mis à jour:

NBuilder is a 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; }
}
Friend Class Person
	Public Property Id() As Integer
	Public Property Name() As String
	Public Property Email() As String
	Public Property IsMarried() As Boolean
End Class
$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
' Create a new person object with default values using NBuilder
Dim person = Builder(Of Person) .CreateNew().Build()
' By default, NBuilder can provide values like 
' Id = 1, Name = Name1, Email = Email1, IsMarried = false
$vbLabelText   $csharpLabel

Image d'exemple

NBuilder .NET (Comment cela fonctionne pour les développeurs) : Figure 3 - Objet Person avec des valeurs

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 :

// Initialize a custom builder for the Person object with specific values
var customPersonBuilder = Builder<Person>.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();
// Initialize a custom builder for the Person object with specific values
var customPersonBuilder = Builder<Person>.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();
' Initialize a custom builder for the Person object with specific values
Dim customPersonBuilder = Builder(Of Person).CreateNew().With(Sub(p) p.Name = "Tom").With(Sub(p) p.Email = "Tom@email.com")
' Build the custom person object with the specified properties
Dim objTom = customPersonBuilder.Build()
$vbLabelText   $csharpLabel

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

// Create a list of 10 Person objects with default values using NBuilder
var personList = Builder<Person>
                                     .CreateListOfSize(10)
                                     .Build();
// Create a list of 10 Person objects with default values using NBuilder
var personList = Builder<Person>
                                     .CreateListOfSize(10)
                                     .Build();
' Create a list of 10 Person objects with default values using NBuilder
Dim personList = Builder(Of Person) .CreateListOfSize(10).Build()
$vbLabelText   $csharpLabel

Image d'exemple

NBuilder .NET (Comment cela fonctionne pour les développeurs) : Figure 4 - Liste d'objets Person

Ici, personList contient 10 objets avec leurs valeurs par défaut et les imprime.

// Creating a list of 10 Person objects with default values
var personList = Builder<Person>
                                            .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}");
}
// Creating a list of 10 Person objects with default values
var personList = Builder<Person>
                                            .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}");
}
' Creating a list of 10 Person objects with default values
Dim personList = Builder(Of Person) .CreateListOfSize(10).Build()

' Print details of each Person object in the list
For Each person In personList
	Console.WriteLine($"{person.Id}, {person.Name}, {person.Email}, {person.IsMarried}")
Next person
$vbLabelText   $csharpLabel

NBuilder .NET (Comment cela fonctionne pour les développeurs) : Figure 5 - Attribution automatique des valeurs

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().

// Customize properties for all Person objects in the list
var personList = Builder<Person>
                .CreateListOfSize(10)
                .All()
                .With(p => p.Name = "Kim")
                .With(p => p.Email = "abc@email.com")
                .With(p => p.IsMarried = false)
                .Build();
// Customize properties for all Person objects in the list
var personList = Builder<Person>
                .CreateListOfSize(10)
                .All()
                .With(p => p.Name = "Kim")
                .With(p => p.Email = "abc@email.com")
                .With(p => p.IsMarried = false)
                .Build();
' Customize properties for all Person objects in the list
Dim personList = Builder(Of Person) .CreateListOfSize(10).All().With(Sub(p) p.Name = "Kim").With(Sub(p) p.Email = "abc@email.com").With(Sub(p) p.IsMarried = False).Build()
$vbLabelText   $csharpLabel

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.

// Creating a list of Person objects with random yet realistic values using Faker
var personList = Builder<Person>
                .CreateListOfSize(10)
                .All()
                .With(p => p.Name = Faker.Name.FullName())
                .With(p => p.Id = Faker.RandomNumber.Next(20, 60))
                .Build();
// Creating a list of Person objects with random yet realistic values using Faker
var personList = Builder<Person>
                .CreateListOfSize(10)
                .All()
                .With(p => p.Name = Faker.Name.FullName())
                .With(p => p.Id = Faker.RandomNumber.Next(20, 60))
                .Build();
' Creating a list of Person objects with random yet realistic values using Faker
Dim personList = Builder(Of Person) .CreateListOfSize(10).All().With(Sub(p) p.Name = Faker.Name.FullName()).With(Sub(p) p.Id = Faker.RandomNumber.Next(20, 60)).Build()
$vbLabelText   $csharpLabel

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.

// Creating a list of 10 sequential Person objects using NBuilder
var personList = Builder<Person>.CreateListOfSize(10)
                .All()
                .Do((p, i) => p.Id = 501 + i)
                .Do((p, i) => p.Name = $"Person {i + 1}")
                .Build();
// Creating a list of 10 sequential Person objects using NBuilder
var personList = Builder<Person>.CreateListOfSize(10)
                .All()
                .Do((p, i) => p.Id = 501 + i)
                .Do((p, i) => p.Name = $"Person {i + 1}")
                .Build();
' Creating a list of 10 sequential Person objects using NBuilder
Dim personList = Builder(Of Person).CreateListOfSize(10).All().Do(Sub(p, i) p.Id = 501 + i).Do(Sub(p, i) p.Name = $"Person {i + 1}").Build()
$vbLabelText   $csharpLabel

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

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

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;
    }
}
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;
    }
}
Friend Class Person
	Public Property Id() As Integer
	Public Property Name() As String
	Public Property Email() As String
	Public Property IsMarried() As Boolean
End Class

Friend Class PersonService
	Public Function GetPersonEmail(ByVal person As Person) As String
		Return person.Email
	End Function
End Class
$vbLabelText   $csharpLabel

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

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<Person>.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);
     }
}
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<Person>.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);
     }
}
Imports Xunit

Public Class PersonTests
	 <Fact>
	 Public Sub GetPersonEmail_ReturnCorrectEmail()
		 ' Arrange
		 Dim service = New PersonService()
		 Dim expectedEmail As String = "Tom@email.com"

		 ' Create a person with specific name and email using NBuilder
		 Dim person = Builder(Of Person).CreateNew().With(Sub(p) p.Name = "Tom").With(Sub(p) p.Email = "Tom@email.com").Build()

		 ' Act
		 Dim actualEmail = service.GetPersonEmail(person)

		 ' Assert
		 Assert.Equal(expectedEmail, actualEmail)
	 End Sub
End Class
$vbLabelText   $csharpLabel

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

Learn About IronPDF is a powerful C# library designed for créer des PDF à partir de HTML 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

Installer IronPDF

Ouvrez la console du gestionnaire de packages NuGet, et exécutez la commande suivante:

Install-Package IronPdf

Remplir la liste de 5 objets Person

// Generating instances of the Person class with NBuilder
var people = Builder<Person>.CreateListOfSize(5).Build();
// Generating instances of the Person class with NBuilder
var people = Builder<Person>.CreateListOfSize(5).Build();
' Generating instances of the Person class with NBuilder
Dim people = Builder(Of Person).CreateListOfSize(5).Build()
$vbLabelText   $csharpLabel

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.

// Setting the IronPDF license key
IronPdf.License.LicenseKey = "Your-License-Key";

// Building HTML content from Person object list
var htmlContent = "<h1>Person List</h1>";
foreach (var person in people)
{
    htmlContent += $"<p>Id: {person.Id}, Name: {person.Name}, Email: {person.Email}, IsMarried: {person.IsMarried}</p>";
}
// Setting the IronPDF license key
IronPdf.License.LicenseKey = "Your-License-Key";

// Building HTML content from Person object list
var htmlContent = "<h1>Person List</h1>";
foreach (var person in people)
{
    htmlContent += $"<p>Id: {person.Id}, Name: {person.Name}, Email: {person.Email}, IsMarried: {person.IsMarried}</p>";
}
' Setting the IronPDF license key
IronPdf.License.LicenseKey = "Your-License-Key"

' Building HTML content from Person object list
Dim htmlContent = "<h1>Person List</h1>"
For Each person In people
	htmlContent &= $"<p>Id: {person.Id}, Name: {person.Name}, Email: {person.Email}, IsMarried: {person.IsMarried}</p>"
Next person
$vbLabelText   $csharpLabel

Le IronPdf.License.LicenseKey est défini avec une clé de licence spécifique pour activer les fonctionnalités de IronPDF. Le contenu HTML est construit dynamiquement en itérant sur la liste people, en ajoutant les détails de chaque objet Person (Id, Name, Email, IsMarried) 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.

// Rendering HTML content into a PDF document using IronPDF
var renderer = new ChromePdfRenderer();
var pdfDoc = renderer.RenderHtmlAsPdf(htmlContent);
pdfDoc.SaveAs("PersonList.pdf");
// Rendering HTML content into a PDF document using IronPDF
var renderer = new ChromePdfRenderer();
var pdfDoc = renderer.RenderHtmlAsPdf(htmlContent);
pdfDoc.SaveAs("PersonList.pdf");
' Rendering HTML content into a PDF document using IronPDF
Dim renderer = New ChromePdfRenderer()
Dim pdfDoc = renderer.RenderHtmlAsPdf(htmlContent)
pdfDoc.SaveAs("PersonList.pdf")
$vbLabelText   $csharpLabel

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

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 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.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Démarrer l'essai gratuit