NBuilder .NET (Funktionsweise für Entwickler)

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

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

Beispielfoto

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

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

Beispielfoto

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

Beispiel 4: Anpassen von generierten Objekten

Manchmal müssen Sie möglicherweise die zu erstellenden Objekte anpassen. Sie können auch den Wert eines Objekts mit der With()-Methode 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();

Dies erstellt eine personList, bei der jedes Objekt seinen Standardwert überschrieben hat, auf Name = "Kim", E-Mail = "abc@email.com" und IsMarried = false.

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

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

Hier stellt die All()-Methode sicher, dass die nachfolgenden Operationen auf alle 10 in den Speicher erstellten Personenobjekte angewendet werden. Die Do()-Methode führt den Action-Delegat auf jedem Person-Objekt aus. Dieses Setup weist die Id-Eigenschaft sequentiell beginnend bei 501 zu, und benennt jeder Person sequentiell von "Person 1" bis "Person 10".

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

Hier hat die Person-Klasse mehrere Eigenschaften wie Id, Name, Email und IsMarried, während PersonService eine Methode GetPersonEmail() enthält, die die E-Mail einer 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);
     }
}

Dieser Unit-Test überprüft, ob die Methode GetPersonEmail der PersonService-Klasse die E-Mail-Adresse eines Person-Objekts korrekt mit der erwarteten E-Mail "Tom@email.com" 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.

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

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

Der IronPdf.License.LicenseKey wird mit einem bestimmten Lizenzschlüssel gesetzt, um die Funktionen von IronPDF zu aktivieren. Der HTML-Inhalt wird dynamisch konstruiert, indem über die people-Liste iteriert wird 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");

ChromePdfRenderer wird instanziiert, um den im htmlContent gespeicherten HTML-Inhalt in ein PDF-Dokument zu rendern. Das resultierende PDF-Dokument wird mit dem Namen "PersonList.pdf" im Dateisystem gespeichert.