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

Constructeur NB est unbibliothèque .NET simplifier la génération de données d'essai. Les développeurs peuvent créer des graphes d'objets complexes sans effort grâce à son interface fluide. Il offre flexibilité, efficacité et intégration transparente avec les cadres de test les plus courants. Dans cet article, nous allons explorer les fonctionnalités de NBuilder, comment l'installer, et démontrer ses capacités avec des exemples de code pratiques.

Caractéristiques de NBuilder

1. NBuilder est une bibliothèque .NET open source C# conçue pour simplifier la création d'objets à des fins de test et de mocking. Il permet aux développeurs de générer rapidement des objets avec des entrées par défaut ou personnalisées basées sur 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. Il s'agit de l'un des packages essentiels pour tester les types de données .NET intégrés et les objets complexes.

4. Il est utilisé 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 NuGet Package Manager, utilisez la commande suivante.

Install-Package Nbuilder

Install-Package Nbuilder

IRON VB CONVERTER ERROR developers@ironsoftware.com

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

Utilisation de NBuilder

NBuilder fournit une méthode fluide pour 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 de personne.

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; }
    }

IRON VB CONVERTER ERROR developers@ironsoftware.com

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

var person = Builder<Person>
                .CreateNew()
                .Build();
// person = { Id = 1, Name = Name1, Email = Email1 , IsMarried  = false }

var person = Builder<Person>
                .CreateNew()
                .Build();
// person = { Id = 1, Name = Name1, Email = Email1 , IsMarried  = false }

IRON VB CONVERTER ERROR developers@ironsoftware.com

Exemple d'image

Exemple 2 : Création d'objets avec un Custom Builder

Voici un exemple d'utilisation de NBuilder pour créer et configurer un objet Personne avec des propriétés personnalisées :

var customPersonBuilder = Builder<Person>.CreateNew()
                .With(p => p.Name = "Tom")
                .With(p => p.Email = "Tom@email.com");
var objTom = customPersonBuilder.Build();

var customPersonBuilder = Builder<Person>.CreateNew()
                .With(p => p.Name = "Tom")
                .With(p => p.Email = "Tom@email.com");
var objTom = customPersonBuilder.Build();

Dim customPersonBuilder = Builder(Of Person).CreateNew().With(Sub(p) p.Name = "Tom").With(Sub(p) p.Email = "Tom@email.com")
Dim objTom = customPersonBuilder.Build()

Le code ci-dessus crée un nouvel objet Personne avec des propriétés personnalisées. Il initialise un customPersonBuilder pour un objet Personne, en fixant le nom à "Tom" et l'adresse électronique à "Tom@email.com". Enfin, il construit l'objet et l'affecte à objTom.

Exemple 3 : Création d'une liste d'objets "personne" avec valeur par défaut

var personList = Builder<Person>
                                     .CreateListOfSize(10)
                                     .Build();

var personList = Builder<Person>
                                     .CreateListOfSize(10)
                                     .Build();

IRON VB CONVERTER ERROR developers@ironsoftware.com

Exemple d'image

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

var personList = Builder<Person>
                                            .CreateListOfSize(10)
                                            .Build();
// Here it creates the 10 objects of Person in personList
foreach (var person in personList)
{
    Console.WriteLine($"{person.Id}, {person.Name}, {person.Email}, {person.IsMarried}, ");
}

var personList = Builder<Person>
                                            .CreateListOfSize(10)
                                            .Build();
// Here it creates the 10 objects of Person in personList
foreach (var person in personList)
{
    Console.WriteLine($"{person.Id}, {person.Name}, {person.Email}, {person.IsMarried}, ");
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Exemple 4 : Personnalisation des objets générés

Il est parfois nécessaire de personnaliser les objets créés. Vous pouvez également personnaliser la valeur d'un objet en utilisant la méthode with() méthode.

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();
// Output:  
//    Id:  1, Name: Name1, Email: Email1, IsMarried False,
//    Id : 2, Name: Name2, Email: Email2, IsMarried True,
//    Id : 3, Name: Name3, Email: Email3, IsMarried False,
//    Id : 4, Name: Name4, Email: Email4, IsMarried True,
//    Id : 5, Name: Name5, Email: Email5, IsMarried False,
//    Id : 6, Name: Name6, Email: Email6, IsMarried True,
//    Id : 7, Name: Name7, Email: Email7, IsMarried False,
//    Id : 8, Name: Name8, Email: Email8, IsMarried True,
//    Id : 9, Name: Name9, Email: Email9, IsMarried False,
//    Id : 10, Name: Name10, Email: Email10, IsMarried True,

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();
// Output:  
//    Id:  1, Name: Name1, Email: Email1, IsMarried False,
//    Id : 2, Name: Name2, Email: Email2, IsMarried True,
//    Id : 3, Name: Name3, Email: Email3, IsMarried False,
//    Id : 4, Name: Name4, Email: Email4, IsMarried True,
//    Id : 5, Name: Name5, Email: Email5, IsMarried False,
//    Id : 6, Name: Name6, Email: Email6, IsMarried True,
//    Id : 7, Name: Name7, Email: Email7, IsMarried False,
//    Id : 8, Name: Name8, Email: Email8, IsMarried True,
//    Id : 9, Name: Name9, Email: Email9, IsMarried False,
//    Id : 10, Name: Name10, Email: Email10, IsMarried True,

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()
' Output:  
'    Id:  1, Name: Name1, Email: Email1, IsMarried False,
'    Id : 2, Name: Name2, Email: Email2, IsMarried True,
'    Id : 3, Name: Name3, Email: Email3, IsMarried False,
'    Id : 4, Name: Name4, Email: Email4, IsMarried True,
'    Id : 5, Name: Name5, Email: Email5, IsMarried False,
'    Id : 6, Name: Name6, Email: Email6, IsMarried True,
'    Id : 7, Name: Name7, Email: Email7, IsMarried False,
'    Id : 8, Name: Name8, Email: Email8, IsMarried True,
'    Id : 9, Name: Name9, Email: Email9, IsMarried False,
'    Id : 10, Name: Name10, Email: Email10, IsMarried True,

Cette opération crée une liste de personnes dont la valeur par défaut est Name = "Kim", Email = "abc@email.com" et IsMarried = false.

Exemple 5 : Création d'une liste d'objets-personnes avec des données aléatoires réalistes

Pour obtenir des valeurs de données réalistes dans Person List, vous pouvez utiliser la bibliothèque Faker .NET pour obtenir la valeur réelle des données.

var personList = Builder<Person>
                .CreateListOfSize(10)
                .All()
                .With(p => p.Name = Faker.Name.FullName())
                .With(p => p.Id = Faker.RandomNumber.Next(20, 60))
                .Build();

var personList = Builder<Person>
                .CreateListOfSize(10)
                .All()
                .With(p => p.Name = Faker.Name.FullName())
                .With(p => p.Id = Faker.RandomNumber.Next(20, 60))
                .Build();

IRON VB CONVERTER ERROR developers@ironsoftware.com

Exemple 6 : Création d'une liste d'objets-personnes avec des données séquentielles

Il peut arriver que vous deviez générer des objets contenant des données séquentielles. NBuilder .NET facilite cette opération en utilisant la méthode Do.

var personList = Builder<Person>.CreateListOfSize(10)
                .All()
                .Do((p, i) => p.Id = 501 + i)
                .Do((p, i) => p.Name = $"Person {i + 1}")
                .Build();

var personList = Builder<Person>.CreateListOfSize(10)
                .All()
                .Do((p, i) => p.Id = 501 + i)
                .Do((p, i) => p.Name = $"Person {i + 1}")
                .Build();

IRON VB CONVERTER ERROR developers@ironsoftware.com

Ici, l'équipe All() cette méthode est appliquée aux opérations suivantes sur les 10 objets personnes et crée une liste en mémoire. Le Do() est utilisée pour exécuter le délégué à l'action sur chaque objet Personne.

Dans ce cas, elle définit la propriété Id de chaque personne spécifiée par 501. Les expressions lambda(p, i) prend deux paramètres : p est la personne et i est l'indice de cet objet particulier dans la liste allant de(0 à 9) car la liste comporte respectivement 10 objets. En ajoutant la valeur i à la propriété Id, les propriétés sont définies séquentiellement de 501 à 510, et la propriété Name sera définie de Person 1 à Person 10.

Exemple 7 : NBuilder avec tests unitaires utilisant Xunit

NBuilder in .NET est largement utilisé dans les environnements de test, où les développeurs ont besoin de générer un ensemble réaliste et diversifié de données pour les tests. Il rend les tests faciles et faciles à maintenir grâce à des objets complexes qui permettent aux développeurs de définir une logique d'initialisation personnalisée à l'aide d'expressions lambda et de fonctions déléguées qui s'adressent à ceux qui sont intéressés par une génération de données de test efficace et flexible.

Modèle de classe et de 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

Ici, la classe Person a les propriétés suivantes, et PersonService n'a qu'une seule méthode publique GetPersonEmail() qui renvoie l'adresse électronique de la personne de cet objet particulier.

Classes de test et données de test

public class PersonTests
{
     [Fact]
     public void GetPersonEmail_ReturnCorrectEmail()
     {
         // Arrange
         var service = new PersonService();
         string expectedEmail = "Tom@email.com";
         var person = Builder<Person>.CreateNew()
             .With(p => p.Name = "Tom")
             .With(p => p.Email "Tom@email.com")
             .Build();
         // Act
         var actualEmail = service.GetPersonEmailById(person);
         // Assert
         Assert.Equal(actualEmail, expectedEmail);
     }
}

public class PersonTests
{
     [Fact]
     public void GetPersonEmail_ReturnCorrectEmail()
     {
         // Arrange
         var service = new PersonService();
         string expectedEmail = "Tom@email.com";
         var person = Builder<Person>.CreateNew()
             .With(p => p.Name = "Tom")
             .With(p => p.Email "Tom@email.com")
             .Build();
         // Act
         var actualEmail = service.GetPersonEmailById(person);
         // Assert
         Assert.Equal(actualEmail, expectedEmail);
     }
}

Public Class PersonTests
	 <Fact>
	 Public Sub GetPersonEmail_ReturnCorrectEmail()
		 ' Arrange
		 Dim service = New PersonService()
		 Dim expectedEmail As String = "Tom@email.com"
		 Dim person = Builder(Of Person).CreateNew().With(Sub(p) p.Name = "Tom").With(Function(p) p.Email "Tom@email.com").Build()
		 ' Act
		 Dim actualEmail = service.GetPersonEmailById(person)
		 ' Assert
		 Assert.Equal(actualEmail, expectedEmail)
	 End Sub
End Class

Ce test unitaire vérifie que la méthode GetPersonEmailById de la classe PersonService renvoie correctement l'adresse électronique d'un objet Person avec l'adresse électronique attendue "Tom@email.com". Il utilise le modèle Arrange-Act-Assert pour configurer les données de test, exécuter la méthode, puis vérifier que le résultat réel correspond au résultat escompté.

Intégration de NBuilder avec IronPDF

En savoir plus sur IronPDF est une puissante bibliothèque C# destinée àcréer des PDF à partir de HTML dans les applications .NET. Grâce à son API intuitive, les développeurs peuvent intégrer en toute transparence des fonctionnalités PDF dans leurs projets, qu'il s'agisse de générer des factures, des rapports ou des formulaires interactifs.

Installation d'IronPDF

Ouvrez la console NuGet Package Manager et exécutez la commande suivante :

Install-Package IronPdf

Install-Package IronPdf

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'Install-Package IronPdf

Remplir la liste de 5 objets Personne

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

Création d'un document PDF à l'aide d'IronPDF

Ce code définit la clé de licence IronPDF et génère du contenu HTML à partir d'une liste d'objets Personne.

IronPdf.License.LicenseKey = "Your-License-Key";
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>";
}

IronPdf.License.LicenseKey = "Your-License-Key";
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>";
}

IronPdf.License.LicenseKey = "Your-License-Key"
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

La clé de licence 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 par itération sur la liste des personnes, en ajoutant les détails de chaque objet Personne(Id, Nom, Email, IsMarried) dans la structure HTML.

Rendu de la liste des personnes dans un document PDF à l'aide d'IronPDF

Ce code convertit le contenu HTML en un document PDF en utilisant le ChromePdfRenderer d'IronPDF.

var renderer = new ChromePdfRenderer();
var pdfDoc = renderer.RenderHtmlAsPdf(htmlContent);
pdfDoc.SaveAs("PersonList.pdf");

var renderer = new ChromePdfRenderer();
var pdfDoc = renderer.RenderHtmlAsPdf(htmlContent);
pdfDoc.SaveAs("PersonList.pdf");

Dim renderer = New ChromePdfRenderer()
Dim 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 sous le nom "PersonList.pdf".

Sortie

Voici le résultat de la liste de personnes générée par IronPDF. Il contient cinq personnes, chacune avec des valeurs par défaut.

Conclusion

En conclusion, NBuilder est un outil robuste et flexible qui permet de générer des données de test dans .NET, de rationaliser la création de graphes d'objets complexes et d'améliorer l'efficacité des processus de test. En intégrant IronPDF, les développeurs peuvent facilement étendre leurs applications pour y inclureCapacités de génération de PDF pour ceux qui le jugent utile pour leurs projets. Ensemble, NBuilder et IronPDF peuvent améliorer considérablement les flux de travail de développement, en rendant les tests et la génération de documents transparents et efficaces.