Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. .NET Hilfe
  4. NBuilder .NET
.NET HILFE

NBuilder .NET (Funktionsweise für Entwickler)

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
Aktualisiert:

NBuilder ist eine .NET-Bibliothek, die die Generierung von Testdaten vereinfacht. Entwickler können mit seiner Fluent-Interface komplexe Objektstrukturen mühelos erstellen. Es bietet Flexibilität, Effizienz und nahtlose Integration mit beliebten Testframeworks. In diesem Artikel werden wir die Funktionen von NBuilder erkunden, wie man es installiert und seine Fähigkeiten mit praktischen Codebeispielen demonstrieren.

NBuilder .NET (So funktioniert es für Entwickler): Abbildung 1 - NBuilder

Funktionen von NBuilder

  1. NBuilder ist eine C# Open-Source .NET-Bibliothek, die zur Vereinfachung der Erstellung von Objekten für Test- und Mocking-Zwecke entwickelt wurde. Es ermöglicht es Entwicklern, Objekte schnell mit Standard- oder benutzerdefinierten Eingaben basierend auf verschiedenen Datentypen zu generieren.
  2. Es ist besonders nützlich für Unit-Tests, Funktionstests und Integrationstests.
  3. Es ist eines der wesentlichen Pakete für das Testen eingebauter .NET-Datentypen und komplexer Objekte.
  4. Es wird für die Generierung zufälliger Daten verwendet. Sie können zu diesem Open-Source-Projekt beitragen.
  5. Mit NBuilder können Sie mühelos Standardattribute überschreiben und benutzerdefinierte Konfigurationen schreiben.

Installation von NBuilder

Um NBuilder in der NuGet-Paket-Manager-Konsole zu installieren, verwenden Sie den folgenden Befehl.

Install-Package NBuilder

Der obige Befehl installiert NBuilder mit all seinen Abhängigkeiten.

NBuilder .NET (So funktioniert es für Entwickler): Abbildung 2 - NBuilder installieren

Benutzung von NBuilder

NBuilder bietet eine flüssige Möglichkeit, Objekte spontan zu erstellen. Lassen Sie uns mit einem einfachen Beispiel zur Erstellung eines Objekts beginnen.

Hier ist der Quellcode der Person Model Klasse.

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

Beispiel 1: Erstellen eines Person-Objekts mit Standardwerten

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

Beispielfoto

NBuilder .NET (So funktioniert es für Entwickler): Abbildung 3 - Person-Objekt mit Werten

Beispiel 2: Erstellen von Objekten mit einem Custom Builder

Hier ist ein Beispiel zur Nutzung von NBuilder, um ein Person-Objekt mit benutzerdefinierten Eigenschaften zu erstellen und zu konfigurieren:

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

Der obige Code erstellt ein neues Person-Objekt mit benutzerdefinierten Eigenschaften. Es initialisiert einen customPersonBuilder für ein Person-Objekt, wobei der Name auf "Tom" und die E-Mail auf "Tom@email.com" gesetzt wird. Schließlich wird das Objekt erstellt und objTom zugewiesen.

Beispiel 3: Erstellen einer Person Objektliste mit Standardwert

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

Beispielfoto

NBuilder .NET (So funktioniert es für Entwickler): Abbildung 4 - Personenobjektliste

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

// 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 (So funktioniert es für Entwickler): Abbildung 5 - Automatisches Zuweisen von Werten

Beispiel 4: Anpassen von generierten Objekten

Manchmal müssen Sie möglicherweise die zu erstellenden Objekte anpassen. Sie können den Wert eines Objekts auch mit der Methode With() anpassen.

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

Dadurch wird ein personList erstellt, wobei für jedes Objekt der Standardwert auf Name = "Kim", Email = "abc@email.com", und IsMarried = false überschrieben wird.

Beispiel 5: Erstellen einer Personenobjektliste mit realistischen Zufallsdaten

Um realistische Datenwerte in der Person List zu erhalten, können Sie die Faker Library .NET nutzen, um realistische Daten zu generieren.

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

Beispiel 6: Erstellung einer Liste von Person-Objekten mit sequentiellen Daten

Es gibt Zeiten, in denen Sie Objekte mit sequentiellen Daten erzeugen müssen. NBuilder .NET erleichtert dies durch die Verwendung der Do-Methode.

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

Hier stellt die Methode All() sicher, dass die nachfolgenden Operationen auf alle 10 im Speicher erstellten Personenobjekte angewendet werden. Die Methode Do() führt den Delegaten Action auf jedem Person Objekt aus. Diese Konfiguration weist die Eigenschaft Id fortlaufend ab 501 zu und benennt analog dazu jede Person fortlaufend als "Person 1" bis "Person 10".

NBuilder .NET (So funktioniert es für Entwickler): Abbildung 6 - Sequenzielle Daten

Beispiel 7: NBuilder mit Unit Testing unter Verwendung von Xunit

NBuilder wird in .NET erheblich in Testumgebungen verwendet, in denen Entwickler realistische und diverse Datenmengen für Tests generieren müssen. Es erleichtert das Testen und ist einfach zu warten mit komplexen Objekten, die es Entwicklern ermöglichen, benutzerdefinierte Initialisierungslogiken mit Lambda-Ausdrücken und Delegatfunktionen zu definieren, für diejenigen, die an einer effizienten und flexiblen Testdatengenerierung interessiert sind.

Modellklasse und Dienst für Unit Testing

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

Hierbei verfügt die Klasse Person über mehrere Eigenschaften wie Id, Name, Email und IsMarried, während PersonService eine Methode GetPersonEmail() enthält, die die E-Mail-Adresse eines gegebenen Person zurückgibt.

Testklassen und Testdaten

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

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

Integration von NBuilder mit IronPDF

Erfahren Sie mehr über IronPDF ist eine leistungsstarke C#-Bibliothek, die für die Erstellung von PDFs aus HTML in .NET-Anwendungen entwickelt wurde. Mit seiner intuitiven API können Entwickler nahtlos PDF-Funktionen in ihre Projekte integrieren, sei es beim Erstellen von Rechnungen, Berichten oder interaktiven Formularen.

NBuilder .NET (So funktioniert es für Entwickler): Abbildung 7 - IronPDF

Installation von IronPDF

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

Install-Package IronPdf

Füllen Sie die Liste der 5 Personenobjekte aus

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

Erstellung von PDF-Dokumenten mit IronPDF

Dieser Code setzt den IronPDF-Lizenzschlüssel und generiert HTML-Inhalte aus einer Liste von Person-Objekten.

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

Der Code IronPdf.License.LicenseKey ist mit einem spezifischen Lizenzschlüssel versehen, um die Funktionen von IronPDF zu aktivieren. Der HTML-Inhalt wird dynamisch erstellt, indem die Liste people durchlaufen und die Details jedes Person-Objekts (Id, Name, Email, IsMarried) in die HTML-Struktur eingefügt werden.

Personenliste im PDF-Dokument mit IronPDF rendern

Dieser Code konvertiert HTML-Inhalt in ein PDF-Dokument unter Verwendung des ChromePdfRenderer von 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 wird instanziiert, um den in htmlContent gespeicherten HTML-Inhalt in ein PDF-Dokument umzuwandeln. Das resultierende PDF-Dokument wird mit dem Namen "PersonList.pdf" im Dateisystem gespeichert.

Ausgabe

Unten ist die Ausgabe der von IronPDF generierten PersonList. Es enthält fünf Personen, jede mit Standardwerten.

NBuilder .NET (So funktioniert es für Entwickler): Abbildung 8 - PDF-Ausgabe

Abschluss

Zusammenfassend ist NBuilder ein robustes und flexibles Werkzeug zur Generierung von Testdaten in .NET, das die Erstellung komplexer Objektstrukturen vereinfacht und die Effizienz von Testprozessen verbessert. Durch die Integration mit IronPDF können Entwickler ihre Anwendungen mühelos erweitern, um PDF-Erstellungsmöglichkeiten einzuschließen, die für ihre Projekte von Wert sind. Gemeinsam können NBuilder und IronPDF die Entwicklungsabläufe erheblich verbessern, wodurch Tests und Dokumentengenerierung nahtlos und effizient erfolgen.

Häufig gestellte Fragen

Wie kann ich Testdaten mit NBuilder in .NET generieren?

NBuilder bietet eine Fluent-Schnittstelle, die es Entwicklern ermöglicht, komplexe Objektgrafen und Testdaten mühelos zu generieren. Sie können Methoden wie CreateNew() und CreateListOfSize() verwenden, um einzelne Objekte oder Listen von Objekten mit Standard- oder benutzerdefinierten Werten zu erstellen.

Wie installiere ich NBuilder in einem .NET-Projekt?

Um NBuilder zu installieren, können Sie die NuGet-Paket-Manager-Konsole mit dem Befehl Install-Package NBuilder verwenden. Dadurch werden NBuilder und seine erforderlichen Abhängigkeiten heruntergeladen und installiert.

Kann NBuilder verwendet werden, um zufällige und sequenzielle Daten zu generieren?

Ja, NBuilder unterstützt die Generierung sowohl zufälliger als auch sequenzieller Daten. Sie können Objekt-Eigenschaften mit Methoden wie With() für zufällige Werte anpassen oder Do() verwenden, um Eigenschaften sequenziell festzulegen.

Welche Vorteile hat die Integration von NBuilder mit IronPDF?

Die Integration von NBuilder mit IronPDF ermöglicht es Entwicklern, komplexe Testdaten zu erstellen und als PDFs auszugeben. Dies kann .NET-Anwendungen erweitern, indem es die dynamische PDF-Generierung aus Testdaten ermöglicht und Entwicklungs-Workflows optimiert.

Wie unterstützt NBuilder beim Unit-Testen?

NBuilder ist wertvoll beim Unit-Testen, da es Entwicklern ermöglicht, schnell realistische Testdaten zu generieren. Es vereinfacht die Einrichtung von Testszenarien mit komplexen Objektgrafen, wodurch Tests wartbarer und effektiver werden.

Was ist der Vorteil der Verwendung einer Fluent-Schnittstelle in NBuilder?

Die Fluent-Schnittstelle in NBuilder ermöglicht es Entwicklern, Methodenaufrufe für die Erstellung komplexer Objektgrafen auf eine lesbare und prägnante Weise zu verketten. Dies verbessert die Codeklarheit und reduziert Boilerplate-Code bei der Testdatengenerierung.

Wie kann ich eine Liste von Objekten mit NBuilder erstellen?

Sie können eine Liste von Objekten mit der CreateListOfSize()-Methode von NBuilder erstellen. Zum Beispiel generiert Builder.CreateListOfSize(10).Build() eine Liste von 10 Person-Objekten.

Was sind einige Tipps zur Fehlerbehebung bei der Verwendung von NBuilder?

Stellen Sie sicher, dass NBuilder korrekt über NuGet installiert ist und überprüfen Sie, ob Ihre Projektverweise auf dem neuesten Stand sind. Wenn Sie auf Probleme stoßen, kann ein Blick ins NBuilder GitHub-Repository oder in die Community-Foren hilfreiche Einblicke und Lösungen liefern.

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
  Jetzt mit dem Ingenieurteam chatten
Chief Technology Officer

Jacob Mellor ist Chief Technology Officer bei Iron Software und ein visionärer Ingenieur, der Pionierarbeit in der C# PDF-Technologie leistet. Als der ursprüngliche Entwickler hinter der Kern-Codebasis von Iron Software hat er die Produktarchitektur des Unternehmens seit seiner Gründung geprägt und es zusammen mit CEO ...

Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Gratis testen

Iron Support Team

Wir sind 24 Stunden am Tag, 5 Tage die Woche online.
Chat
E-Mail
Rufen Sie mich an