NBuilder .NET (Cómo Funciona para Desarrolladores)

NBuilder proporciona una forma fluida de crear objetos sobre la marcha. Comencemos con un ejemplo simple de creación de un objeto.

Aquí está el código fuente de la Clase del Modelo Persona.

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

Ejemplo 1: Creación de un objeto Persona con valores predeterminados

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

Imagen de muestra

Ejemplo 2: Creación de objetos con un constructor personalizado

Aquí hay un ejemplo de cómo usar NBuilder para crear y configurar un objeto Persona con propiedades personalizadas:

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

El código anterior crea un nuevo objeto Persona con propiedades personalizadas. Inicializa un customPersonBuilder para un objeto Persona, configurando el Nombre como "Tom" y el Correo Electrónico como "Tom@email.com". Finalmente, construye el objeto y lo asigna a objTom.

Ejemplo 3: Creación de una lista de objetos persona con valor predeterminado

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

Imagen de muestra

Aquí personList tiene 10 objetos con sus valores predeterminados y los imprime.

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

Ejemplo 4: Personalización de objetos generados

A veces puede que necesites personalizar los objetos que se están creando. También puedes personalizar el valor de un objeto utilizando el método 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();

Esto crea una personList con cada objeto teniendo su valor predeterminado sobrescrito a Nombre = "Kim", Correo Electrónico = "abc@email.com", y Estado Civil = falso.

Ejemplo 5: Creación de una lista de objetos persona con datos aleatorios realistas

Para obtener valores de datos realistas en la Lista de Personas, puedes usar la Biblioteca Faker .NET para generar datos realistas.

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

Ejemplo 6: Creación de una Lista de Objetos Persona con Datos Secuenciales

Hay momentos en que podrías necesitar generar objetos con datos secuenciales. NBuilder .NET facilita esto usando el método 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();

Aquí, el método All() asegura que las operaciones subsecuentes se apliquen a todos los 10 objetos de persona creados en memoria. El método Do() ejecuta el delegado Action en cada objeto Person. Esta configuración asigna la propiedad Id secuencialmente comenzando desde 501, y de manera similar, denomina a cada persona secuencialmente como "Persona 1" a "Persona 10".

Ejemplo 7: NBuilder con Pruebas Unitarias usando Xunit

NBuilder en .NET se utiliza significativamente en entornos de prueba, donde los desarrolladores necesitan generar un conjunto realista y diverso de datos para las pruebas. Facilita las pruebas haciéndolas fáciles y mantenibles con objetos complejos que permiten a los desarrolladores definir lógica de inicialización personalizada usando expresiones lambda y funciones delegadas para aquellos interesados en la generación eficiente y flexible de datos de prueba.

Clase modelo y servicio para pruebas unitarias

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

Aquí, la clase Person tiene varias propiedades como Id, Nombre, Correo Electrónico y Estado Civil, mientras que PersonService contiene un método GetPersonEmail() que devuelve el correo electrónico de un Person dado.

Clases de prueba y datos de prueba

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

Esta prueba unitaria verifica que el método GetPersonEmail de la clase PersonService devuelve correctamente la dirección de correo electrónico de un objeto Person con el correo electrónico esperado "Tom@email.com". Utiliza el patrón Arrange-Act-Assert para configurar los datos de prueba, ejecutar el método y luego verificar que el resultado actual coincida con el resultado esperado.

Abra la consola del Administrador de Paquetes NuGet, y ejecute el siguiente comando:

Install-Package IronPdf

Rellenar la lista de 5 objetos Persona

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

Creación de un documento PDF con IronPDF

Este código establece la clave de licencia de IronPDF y genera contenido HTML a partir de una lista de objetos Persona.

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

La IronPdf.License.LicenseKey se establece con una clave de licencia específica para habilitar las características de IronPDF. El contenido HTML se construye dinámicamente iterando sobre la lista people, agregando los detalles de cada objeto Person (Id, Nombre, Correo Electrónico, Estado Civil) a la estructura HTML.

Renderización de la lista de personas en un documento PDF utilizando IronPDF

Este código convierte contenido HTML a un documento PDF usando el ChromePdfRenderer de 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 se instancia para renderizar el contenido HTML almacenado en htmlContent en un documento PDF. El documento PDF resultante se guarda en el sistema de archivos con el nombre "PersonList.pdf".