NBuilder es una biblioteca .NET que simplifica la generación de datos de prueba. Los desarrolladores pueden crear gráficos de objetos complejos sin esfuerzo con su interfaz fluida. Ofrece flexibilidad, eficiencia e integración perfecta con marcos de prueba populares. En este artículo, exploraremos las características de NBuilder, cómo instalarlo y demostramos sus capacidades con ejemplos de código prácticos.
Para instalar NBuilder en la Consola del Administrador de Paquetes NuGet, utiliza el siguiente comando.
El comando anterior instalará NBuilder con todas sus dependencias.
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; }
}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// 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
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
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()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.
// 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()
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
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
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
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()Esto crea un personList con cada objeto teniendo su valor predeterminado sobrescrito a Nombre = "Kim", Email = "abc@email.com", y IsMarried = false.
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
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()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
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()Aquí, el método All() asegura que las operaciones subsiguientes se apliquen a los 10 objetos persona creados en memoria. El método Do() ejecuta el delegado Action en cada objeto Person. Esta configuración asigna la propiedad Id secuencialmente empezando desde 501, y de manera similar, nombra 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.
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 ClassAquí, la clase Person tiene varias propiedades como Id, Name, Email, y IsMarried, mientras que PersonService contiene un método GetPersonEmail() que retorna el email de un Person dado.
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(Function(p) p.Name = "Tom") _
.With(Function(p) p.Email = "Tom@email.com") _
.Build()
' Act
Dim actualEmail = service.GetPersonEmail(person)
' Assert
Assert.Equal(expectedEmail, actualEmail)
End Sub
End ClassEsta prueba unitaria verifica que el método GetPersonEmail de la clase PersonService retorne correctamente la dirección de correo de un objeto Person con el email 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.
Aprende sobre IronPDF es una poderosa biblioteca en C# diseñada para crear PDFs desde HTML dentro de aplicaciones .NET. Con su API intuitiva, los desarrolladores pueden integrar funcionalidad PDF sin problemas en sus proyectos, ya sea que estén generando facturas, informes o formularios interactivos.
Abra la consola del Administrador de Paquetes NuGet, y ejecute el siguiente comando:
// 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()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
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 personEl IronPdf.License.LicenseKey se configura con una clave de licencia específica para habilitar las funciones de IronPDF. El contenido HTML se construye dinámicamente iterando sobre la lista people, agregando los detalles de cada objeto Person (Id, Nombre, Email, IsMarried) a la estructura HTML.
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
Dim renderer = New ChromePdfRenderer()
Dim 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".
A continuación se muestra la salida de la PersonList generada por IronPDF. Contiene cinco personas, cada una con valores predeterminados.
En conclusión, NBuilder es una herramienta robusta y flexible para generar datos de prueba en .NET, agilizando la creación de gráficos de objetos complejos y mejorando la eficiencia de los procesos de prueba. Al integrarse con IronPDF, los desarrolladores pueden extender fácilmente sus aplicaciones para incluir capacidades de generación de PDF para aquellos que lo consideren valioso para sus proyectos. Juntos, NBuilder e IronPDF pueden mejorar significativamente los flujos de trabajo de desarrollo, haciendo que las pruebas y la generación de documentos sean fluidas y eficientes.
Jacob Mellor es Director de Tecnología de Iron Software y un ingeniero visionario pionero en la tecnología C# PDF. Como desarrollador original de la base de código principal de Iron Software, ha dado forma a la arquitectura de productos de la empresa desde su creación, transformándola, junto con el director ejecutivo Cameron Rimington, en una empresa de más de 50 personas que presta servicios a la NASA, Tesla y organismos gubernamentales de todo el mundo.
IronPDF es parte de IRONSUITE
10 productos API .NET para tus documentos de oficina
Cuando necesitas que tu PDF se parezca al HTML, rápido.
