NBuilder .NET (Wie es für Entwickler funktioniert)

NBuilder ist eine.NET-Bibliothek vereinfachung der Erzeugung von Testdaten. Entwickler können mit der fließenden Schnittstelle mühelos komplexe Objektgraphen erstellen. Es bietet Flexibilität, Effizienz und eine nahtlose Integration mit gängigen Test-Frameworks. In diesem Artikel werden wir uns mit den Funktionen von NBuilder beschäftigen, wie man ihn installiert und seine Fähigkeiten anhand von praktischen Codebeispielen demonstrieren.

Merkmale von NBuilder

1. NBuilder ist eine C#-Open-Source-.NET-Bibliothek, die die Erstellung von Objekten für Test- und Mocking-Zwecke vereinfacht. Sie ermöglicht es Entwicklern, schnell Objekte mit Standard- oder benutzerdefinierten Eingaben auf der Grundlage verschiedener Datentypen zu erzeugen.

2. Sie ist besonders nützlich für Unit-Tests, funktionale Tests und Integrationstests.

3. Es ist eines der wichtigsten Pakete zum Testen integrierter .NET-Datentypen und komplexer Objekte.

4. Es wird für die Erzeugung von Zufallsdaten verwendet. Sie können zu diesem Open-Source-Projekt beitragen.

5. Mit NBuilder können Sie mühelos Standardeigenschaften außer Kraft setzen und benutzerdefinierte Konfigurationen schreiben.

Installation von NBuilder

Um NBuilder über die NuGet Package Manager Console zu installieren, verwenden Sie den folgenden Befehl.

Install-Package Nbuilder

Install-Package Nbuilder

IRON VB CONVERTER ERROR developers@ironsoftware.com

Mit dem obigen Befehl wird NBuilder mit allen Abhängigkeiten installiert.

Verwendung von NBuilder

NBuilder bietet eine fließende Methode zur Erstellung von Objekten im laufenden Betrieb. Beginnen wir mit einem einfachen Beispiel für die Erstellung eines Objekts.

Hier ist der Quellcode der Person Model Class.

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

Beispiel 1: Erstellen eines Personenobjekts mit Standardwerten

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

Beispielbild

Beispiel 2: Erstellen von Objekten mit einem Custom Builder

Hier ein Beispiel für die Verwendung von NBuilder zum Erstellen und Konfigurieren eines Person-Objekts mit benutzerdefinierten Eigenschaften:

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

Der obige Code erstellt ein neues Person-Objekt mit benutzerdefinierten Eigenschaften. Er initialisiert einen customPersonBuilder für ein Person-Objekt und setzt den Namen auf "Tom" und die E-Mail auf "Tom@email.com". Schließlich wird das Objekt erstellt und objTom zugewiesen.

Beispiel 3: Erstellen einer Personenobjektliste mit Standardwert

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

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

IRON VB CONVERTER ERROR developers@ironsoftware.com

Beispielbild

Hier hat personList 10 Objekte mit ihren Standardwerten und gibt sie aus.

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

Beispiel 4: Anpassen von generierten Objekten

Manchmal müssen Sie eventuell erstellte Objekte anpassen. Sie können auch den Wert eines Objekts anpassen, indem Sie das With() methode.

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,

Dadurch wird eine personList mit den Standardwerten Name = "Kim", E-Mail = "abc@email.com" und IsMarried = false erstellt.

Beispiel 5: Erstellen einer Personenobjektliste mit realistischen Zufallsdaten

Um realistische Datenwerte in Person List zu erhalten, können Sie die Faker Library .NET verwenden, um den tatsächlichen Wert der Daten zu erhalten.

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

Beispiel 6: Erstellen einer Personenobjektliste mit sequentiellen Daten

Es kann vorkommen, dass Sie Objekte mit sequentiellen Daten erzeugen müssen. NBuilder .NET erleichtert dies mit der Methode 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

Hier wird die All() die Methode wird bei nachfolgenden Operationen auf alle 10 Personenobjekte angewendet und erstellt eine Liste im Speicher. Der Do() methode wird verwendet, um den Action Delegate für jedes Person-Objekt auszuführen.

In diesem Fall wird die Id-Eigenschaft jeder Person, die durch 501 angegeben wird, festgelegt. Die Lambda-Ausdrücke(p, i) nimmt zwei Parameter an: p ist die Person und i ist der Index dieses bestimmten Objekts in der Liste, die von(0 bis 9) da die Liste jeweils 10 Objekte enthält. Durch Hinzufügen des Werts i in der Id-Eigenschaft werden die Eigenschaften nacheinander von 501 bis 510 gesetzt, und die Eigenschaft Name wird auf Person 1 bis Person 10 gesetzt.

Beispiel 7: NBuilder mit Unit Testing mit Xunit

NBuilder in .NET wird häufig in Testumgebungen eingesetzt, in denen Entwickler einen realistischen und vielfältigen Datensatz für Tests erzeugen müssen. Es macht das Testen einfach und wartbar mit komplexen Objekten, die es Entwicklern ermöglichen, eine benutzerdefinierte Initialisierungslogik mit Lambda-Ausdrücken und Delegatenfunktionen zu definieren, die sich an diejenigen richten, die an einer effizienten und flexiblen Testdatengenerierung interessiert sind.

Modellklasse und Dienst für Einheitstests

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

Hier hat die Klasse Person die folgenden Eigenschaften, und PersonService hat nur eine öffentliche Methode GetPersonEmail() die die E-Mail der Person dieses bestimmten Objekts zurückgibt.

Testklassen und Testdaten

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

Dieser Unit-Test prüft, ob die Methode GetPersonEmailById der Klasse PersonService die E-Mail-Adresse eines Person-Objekts mit der erwarteten E-Mail "Tom@email.com" korrekt zurückgibt. Es verwendet das Muster Anordnen-Handeln-Einfügen, um die Testdaten einzurichten, die Methode auszuführen und dann zu prüfen, ob das tatsächliche Ergebnis mit dem erwarteten Ergebnis übereinstimmt.

Integration von NBuilder mit IronPDF

Erfahren Sie mehr über IronPDF ist eine leistungsstarke C#-Bibliothek, die fürerstellung von PDFs aus HTML innerhalb von .NET-Anwendungen. Mit der intuitiven API können Entwickler PDF-Funktionen nahtlos in ihre Projekte integrieren, egal ob sie Rechnungen, Berichte oder interaktive Formulare erstellen.

Installation von IronPDF

Öffnen Sie die NuGet Package Manager-Konsole und führen Sie den folgenden Befehl aus:

Install-Package IronPdf

Install-Package IronPdf

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

Die Liste der 5 Person-Objekte auffüllen

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

Erstellung von PDF-Dokumenten mit IronPDF

Dieser Code setzt den IronPDF-Lizenzschlüssel und erzeugt HTML-Inhalte aus einer Liste von Personenobjekten.

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

Der IronPdf.License.LicenseKey wird mit einem bestimmten Lizenzschlüssel versehen, um die Funktionen von IronPDF zu aktivieren.

Der HTML-Inhalt wird dynamisch durch Iteration über die Personenliste erstellt, wobei die Details jedes Personenobjekts angefügt werden(Id, Name, E-Mail, IsMarried) in die HTML-Struktur.

Rendering der Personenliste im PDF-Dokument mit IronPDF

Dieser Code konvertiert HTML-Inhalte in ein PDF-Dokument unter Verwendung des ChromePdfRenderer von 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")

der ChromePdfRenderer wird instanziiert, um den in htmlContent** gespeicherten HTML-Inhalt in ein PDF-Dokument zu übertragen. Das resultierende PDF-Dokument wird im Dateisystem unter dem Namen "PersonList.pdf" gespeichert.

Ausgabe

Nachfolgend sehen Sie die Ausgabe der von IronPDF generierten PersonList. Er enthält fünf Personen, die jeweils mit Standardwerten versehen sind.

Schlussfolgerung

Zusammenfassend lässt sich sagen, dass NBuilder ein robustes und flexibles Tool für die Generierung von Testdaten in .NET ist, das die Erstellung komplexer Objektgraphen rationalisiert und die Effizienz von Testprozessen steigert. Durch die Integration mit IronPDF können Entwickler ihre Anwendungen einfach erweitern, um Folgendes zu integrierenPDF-Erzeugungsfunktionen für diejenigen, die es für ihre Projekte nützlich finden. Zusammen können NBuilder und IronPDF die Arbeitsabläufe in der Entwicklung erheblich verbessern, indem sie Tests und Dokumentenerstellung nahtlos und effizient gestalten.