Ikona wiadomości
Przejdź do treści stopki
  1. IronPDF
  2. Blog IronPDF
  3. Pomoc .NET
  4. NBuilder .NET
POMOC .NET

NBuilder .NET (jak to działa dla programistów)

Jacob Mellor, Dyrektor Technologiczny @ Team Iron
Jacob Mellor
Zaktualizowano:

NBuilder to biblioteka .NET upraszczająca generowanie danych testowych. Dzięki płynnemu interfejsowi programiści mogą bez wysiłku tworzyć złożone grafy obiektów. Zapewnia elastyczność, wydajność i płynną integrację z popularnymi frameworkami testowymi. W tym artykule omówimy funkcje NBuilder, sposób jego instalacji oraz zademonstrujemy jego możliwości na praktycznych przykładach kodu.

NBuilder .NET (Jak to działa dla programistów): Rysunek 1 – NBuilder

Funkcje NBuilder

  1. NBuilder to biblioteka .NET typu open source napisana w języku C#, zaprojektowana w celu uproszczenia tworzenia obiektów do testowania i symulacji. Pozwala to programistom na szybkie generowanie obiektów z danymi domyślnymi lub niestandardowymi w oparciu o różne typy danych.
  2. Jest to szczególnie przydatne w przypadku testów jednostkowych, testów funkcjonalnych i testów integracyjnych.
  3. Jest to jeden z niezbędnych pakietów do testowania wbudowanych typów danych .NET i złożonych obiektów.
  4. Służy do generowania danych losowych. Możesz wnieść swój wkład w ten projekt open source.
  5. Dzięki NBuilder możesz bez wysiłku nadpisywać domyślne właściwości i tworzyć własne konfiguracje.

Instalacja NBuilder

Aby zainstalować NBuilder w konsoli menedżera pakietów NuGet, użyj następującego polecenia.

Install-Package NBuilder

Powyższe polecenie zainstaluje NBuilder wraz ze wszystkimi jego zależnościami.

NBuilder .NET (Jak to działa dla programistów): Rysunek 2 – Zainstaluj NBuilder

Zastosowanie NBuilder

NBuilder zapewnia płynny sposób tworzenia obiektów w locie. Zacznijmy od prostego przykładu tworzenia obiektu.

Oto kod źródłowy klasy Person Model.

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

Przykład 1: Tworzenie obiektu Person z wartościami domyślnymi

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

Przykładowy obrazek

NBuilder .NET (Jak to działa dla programistów): Rysunek 3 – Obiekt Person z wartościami

Przykład 2: Tworzenie obiektów za pomocą niestandardowego Builders

Oto przykład wykorzystania NBuilder do utworzenia i skonfigurowania obiektu Person z niestandardowymi właściwościami:

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

Powyższy kod tworzy nowy obiekt Person z niestandardowymi właściwościami. Inicjuje obiekt customPersonBuilder dla obiektu Person, ustawiając imię na "Tom", a adres e-mail na "Tom@email.com". Na koniec tworzy obiekt i przypisuje go do objTom.

Przykład 3: Tworzenie listy obiektów Person z wartością domyślną

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

Przykładowy obrazek

NBuilder .NET (Jak to działa dla programistów): Rysunek 4 – Lista obiektów typu Person

W tym przypadku personList zawiera 10 obiektów z wartościami domyślnymi i PRINTuje je.

// 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 (Jak to działa dla programistów): Rysunek 5 – Automatyczne przypisywanie wartości

Przykład 4: Dostosowywanie wygenerowanych obiektów

Czasami może zaistnieć potrzeba dostosowania tworzonych obiektów. Można również dostosować wartość obiektu za pomocą metody 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

Powoduje to utworzenie personList, gdzie dla każdego obiektu domyślne wartości są nadpisane na Name = "Kim", Email = "abc@email.com" oraz IsMarried = false.

Przykład 5: Tworzenie listy obiektów typu Person z realistycznymi danymi losowymi

Aby uzyskać realistyczne wartości danych w liście osób, można użyć biblioteki Faker Library .NET do generowania realistycznych danych.

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

Przykład 6: Tworzenie listy obiektów typu Person z danymi sekwencyjnymi

Czasami może zaistnieć potrzeba generowania obiektów zawierających dane sekwencyjne. NBuilder .NET ułatwia to dzięki metodzie 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

W tym przypadku metoda All() zapewnia, że kolejne operacje mają zastosowanie do wszystkich 10 obiektów typu Person utworzonych w pamięci. Metoda Do() wykonuje delegat Action na każdym obiekcie Person. Ta konfiguracja przypisuje właściwość Id sekwencyjnie, zaczynając od 501, i podobnie nazywa każdą osobę sekwencyjnie jako "Osoba 1" do "Osoba 10".

NBuilder .NET (Jak to działa dla programistów): Rysunek 6 – Dane sekwencyjne

Przykład 7: NBuilder z testowaniem jednostkowym przy użyciu Xunit

NBuilder w środowisku .NET jest szeroko stosowany w środowiskach testowych, gdzie programiści muszą generować realistyczny i zróżnicowany zestaw danych do testów. Ułatwia to testowanie i konserwację złożonych obiektów, które pozwalają programistom definiować niestandardową logikę inicjalizacji przy użyciu wyrażeń lambda i funkcji delegujących, co jest przydatne dla osób zainteresowanych wydajnym i elastycznym generowaniem danych testowych.

Klasa modelowa i usługa do testowania jednostkowego

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

W tym przypadku klasa Person posiada kilka właściwości, takich jak Id, Name, Email oraz IsMarried, natomiast PersonService zawiera metodę GetPersonEmail(), która zwraca adres e-mail danego Person.

Klasy testowe i dane testowe

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

Ten test jednostkowy sprawdza, czy metoda GetPersonEmail klasy PersonService poprawnie zwraca adres e-mail obiektu Person z oczekiwanym adresem "Tom@email.com". Wykorzystuje wzorzec Arrange-Act-Assert do skonfigurowania danych testowych, wykonania metody, a następnie sprawdzenia, czy rzeczywisty wynik jest zgodny z oczekiwanym.

Integracja NBuilder z IronPDF

Dowiedz się więcej o IronPDF – potężnej bibliotece C# przeznaczonej do tworzenia plików PDF z HTML w aplikacjach .NET. Dzięki intuicyjnemu interfejsowi API programiści mogą płynnie zintegrować funkcje PDF ze swoimi projektami, niezależnie od tego, czy generują faktury, raporty czy interaktywne formularze.

NBuilder .NET (Jak to działa dla programistów): Rysunek 7 – IronPDF

Instalacja IronPDF

Otwórz konsolę NuGet Package Manager i uruchom następujące polecenie:

Install-Package IronPdf

Wypełnij listę 5 obiektów typu 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

Tworzenie dokumentu PDF przy użyciu IronPDF

Ten kod ustawia klucz licencyjny IronPDF i generuje zawartość HTML na podstawie listy obiektów 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

IronPdf.License.LicenseKey jest ustawiony z konkretnym kluczem licencyjnym, aby umożliwić korzystanie z funkcji IronPDF. Treść HTML jest tworzona dynamicznie poprzez iterację nad listą people, dołączając szczegóły każdego obiektu Person (Id, Name, Email, IsMarried) do struktury HTML.

Renderowanie listy osób w dokumencie PDF przy użyciu IronPDF

Ten kod konwertuje zawartość HTML na dokument PDF przy użyciu biblioteki ChromePdfRenderer firmy 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 jest instancjonowany w celu renderowania treści HTML przechowywanej w htmlContent do dokumentu PDF. Powstały dokument PDF jest zapisywany w systemie plików pod nazwą "PersonList.pdf".

Wynik

Poniżej znajduje się wynik działania funkcji PersonList wygenerowany przez IronPDF. Zawiera pięć osób, z których każda ma wartości domyślne.

NBuilder .NET (Jak to działa dla programistów): Rysunek 8 – Wynik w formacie PDF

Wnioski

Podsumowując, NBuilder to solidne i elastyczne narzędzie do generowania danych testowych w środowisku .NET, usprawniające tworzenie złożonych grafów obiektów i zwiększające wydajność procesów testowania. Dzięki integracji z IronPDF programiści mogą w łatwy sposób rozszerzyć swoje aplikacje o funkcje generowania plików PDF dla tych, którzy uznają to za przydatne w swoich projektach. W połączeniu NBuilder i IronPDF mogą znacznie usprawnić procesy programistyczne, sprawiając, że testowanie i generowanie dokumentów przebiega płynnie i wydajnie.

Często Zadawane Pytania

Jak mogę wygenerować dane testowe używając NBuilder w .NET?

NBuilder zapewnia płynny interfejs, który pozwala deweloperom na bezwysiłkowe generowanie złożonych grafów obiektów i danych testowych. Możesz używać metod takich jak CreateNew() i CreateListOfSize(), aby wygenerować pojedyncze obiekty lub listy obiektów z domyślnymi lub niestandardowymi wartościami.

Jak zainstalować NBuilder w projekcie .NET?

Aby zainstalować NBuilder, możesz użyć konsoli menedżera pakietów NuGet z poleceniem: Install-Package NBuilder. To pobierze i zainstaluje NBuilder wraz z jego potrzebnymi zależnościami.

Czy NBuilder może być używany do generowania danych losowych i sekwencyjnych?

Tak, NBuilder obsługuje generowanie zarówno danych losowych, jak i sekwencyjnych. Możesz dostosować właściwości obiektów za pomocą metod takich jak With() dla wartości losowych lub użyć Do() do ustawiania właściwości sekwencyjnie.

Jakie są korzyści z integracji NBuilder z IronPDF?

Integracja NBuilder z IronPDF pozwala deweloperom na tworzenie złożonych danych testowych i ich eksportowanie jako pliki PDF. To może ulepszyć aplikacje .NET poprzez umożliwienie dynamicznego generowania PDF z danych testowych, upraszczając procesy rozwojowe.

Jak NBuilder pomaga w testach jednostkowych?

NBuilder jest cenny w testach jednostkowych, ponieważ pozwala deweloperom szybko generować realistyczne dane testowe. Upraszcza konfigurację scenariuszy testowych ze złożonymi grafami obiektów, co sprawia, że testy są bardziej pielęgnowalne i skuteczne.

Jaka jest zaleta korzystania z płynnego interfejsu w NBuilder?

Płynny interfejs w NBuilder pozwala deweloperom łączyć wywołania metod w celu tworzenia złożonych grafów obiektów w czytelny i zwięzły sposób. To poprawia klarowność kodu i redukuje redundantny kod przy generowaniu danych testowych.

Jak mogę stworzyć listę obiektów za pomocą NBuilder?

Możesz stworzyć listę obiektów, używając metody CreateListOfSize() z NBuilder. Na przykład, Builder.CreateListOfSize(10).Build() generuje listę 10 obiektów Person.

Jakie są wskazówki dotyczące rozwiązywania problemów z NBuilder?

Upewnij się, że NBuilder jest poprawnie zainstalowany za pośrednictwem NuGet i zweryfikuj, że twoje referencje projektowe są aktualne. Jeśli napotkasz problemy, kontrola repozytorium GitHub NBuilder lub fora społeczności mogą dostarczyć przydatnych informacji i rozwiązań.

Jacob Mellor, Dyrektor Technologiczny @ Team Iron
Jacob Mellor
  Czat z zespołem inżynierów teraz
Dyrektor ds. technologii

Jacob Mellor jest Chief Technology Officer w Iron Software i wizjonerskim inżynierem, pionierem technologii C# PDF. Jako pierwotny deweloper głównej bazy kodowej Iron Software, kształtuje architekturę produktów firmy od jej początku, przekształcając ją wspólnie z CEO Cameron Rimington w firmę liczą...

Czytaj więcej

Powiązane artykuły

30-dniowy okres próbny → Pełna wersja produktu. Bez ograniczeń. Bez karty. Bezpłatna próba

Zespol wsparcia Iron

Jestesmy online 24 godziny, 5 dni w tygodniu.
Czat
Email
Zadzwon do mnie