Humanizer C# (Cómo Funciona para Desarrolladores)
Humanizer es una biblioteca .NET poderosa y flexible que simplifica y humaniza el proceso de trabajar con datos, especialmente cuando se trata de mostrar información en un formato amigable para el usuario. Ya sea que necesites convertir fechas a cadenas de tiempo relativo ("hace 3 días"), pluralizar palabras, formatear números como palabras, o trabajar con enums, mostrando cadenas, cadenas de entrada en mayúscula tipo Pascal como oraciones con descripciones personalizadas, cadenas de entrada subrayadas a cadenas de título normal, y truncación de texto largo, Humanizer proporciona una multitud de herramientas y métodos de extensión para manejar estas tareas elegantemente en C#.NET para convertir cadenas de entrada deshumanizadas en oraciones.
En este artículo, discutiremos un tutorial detallado de Humanizer en C#. También discutiremos cómo generar documentos PDF usando Humanizer e IronPDF para la biblioteca PDF de C#.
Instalación de Humanizer en C
Para comenzar con Humanizer, necesitas instalar la biblioteca a través de NuGet. En tu proyecto, puedes hacerlo a través de la Consola del Administrador de Paquetes con el siguiente comando:
Install-Package Humanizer
Alternativamente, si estás usando la CLI de .NET Core, puedes agregar Humanizer con:
dotnet add package Humanizer
Después de la instalación, puedes comenzar a usar Humanizer incluyendo el espacio de nombres apropiado en tus archivos C#:
using Humanizer;
using Humanizer;
Imports Humanizer
Humanizar fechas y horas
Uno de los usos más comunes de Humanizer es convertir fechas y horas en formatos legibles para humanos, períodos de tiempo, números y cantidades utilizando el método Humanize. Esto es particularmente útil para mostrar tiempos relativos, como "hace 2 horas" o "en 5 días".
Ejemplo: Humanizar el tiempo relativo
using System;
class HumanizerDemo
{
static void Main()
{
DateTime pastDate = DateTime.Now.AddDays(-3);
// Humanize the past date, which converts it to a relative time format
string humanizedTime = pastDate.Humanize(); // Output: "3 days ago"
DateTime futureDate = DateTime.Now.AddHours(5);
// Humanize the future date, presenting it in relative time
string futureHumanizedTime = futureDate.Humanize(); // Output: "in 5 hours"
Console.WriteLine("Humanized Past Date: " + humanizedTime);
Console.WriteLine("Humanized Future Date: " + futureHumanizedTime);
}
}
using System;
class HumanizerDemo
{
static void Main()
{
DateTime pastDate = DateTime.Now.AddDays(-3);
// Humanize the past date, which converts it to a relative time format
string humanizedTime = pastDate.Humanize(); // Output: "3 days ago"
DateTime futureDate = DateTime.Now.AddHours(5);
// Humanize the future date, presenting it in relative time
string futureHumanizedTime = futureDate.Humanize(); // Output: "in 5 hours"
Console.WriteLine("Humanized Past Date: " + humanizedTime);
Console.WriteLine("Humanized Future Date: " + futureHumanizedTime);
}
}
Imports System
Friend Class HumanizerDemo
Shared Sub Main()
Dim pastDate As DateTime = DateTime.Now.AddDays(-3)
' Humanize the past date, which converts it to a relative time format
Dim humanizedTime As String = pastDate.Humanize() ' Output: "3 days ago"
Dim futureDate As DateTime = DateTime.Now.AddHours(5)
' Humanize the future date, presenting it in relative time
Dim futureHumanizedTime As String = futureDate.Humanize() ' Output: "in 5 hours"
Console.WriteLine("Humanized Past Date: " & humanizedTime)
Console.WriteLine("Humanized Future Date: " & futureHumanizedTime)
End Sub
End Class
El método de extensión de Humanizer maneja automáticamente diferentes unidades de tiempo e incluso ajusta para la corrección gramatical.

Humanizar los periodos de tiempo
Humanizer también puede humanizar objetos TimeSpan, lo que facilita la visualización de duraciones en un formato legible.
Ejemplo: Humanizar TimeSpan
using System;
class TimeSpanHumanizerDemo
{
static void Main()
{
TimeSpan timeSpan = TimeSpan.FromMinutes(123);
// Humanizing the TimeSpan into hours and minutes
string humanizedTimeSpan = timeSpan.Humanize(2); // Output: "2 hours, 3 minutes"
Console.WriteLine("Humanized TimeSpan: " + humanizedTimeSpan);
}
}
using System;
class TimeSpanHumanizerDemo
{
static void Main()
{
TimeSpan timeSpan = TimeSpan.FromMinutes(123);
// Humanizing the TimeSpan into hours and minutes
string humanizedTimeSpan = timeSpan.Humanize(2); // Output: "2 hours, 3 minutes"
Console.WriteLine("Humanized TimeSpan: " + humanizedTimeSpan);
}
}
Imports System
Friend Class TimeSpanHumanizerDemo
Shared Sub Main()
Dim timeSpan As TimeSpan = System.TimeSpan.FromMinutes(123)
' Humanizing the TimeSpan into hours and minutes
Dim humanizedTimeSpan As String = timeSpan.Humanize(2) ' Output: "2 hours, 3 minutes"
Console.WriteLine("Humanized TimeSpan: " & humanizedTimeSpan)
End Sub
End Class

Trabajar con números
Humanizer proporciona varios métodos para convertir números en palabras legibles y para manejar números ordinales.
Ejemplo: Conversión de números en palabras
using System;
class NumberHumanizerDemo
{
static void Main()
{
int number = 123;
// Convert number to words
string words = number.ToWords(); // Output: "one hundred and twenty-three"
Console.WriteLine("Number in Words: " + words);
}
}
using System;
class NumberHumanizerDemo
{
static void Main()
{
int number = 123;
// Convert number to words
string words = number.ToWords(); // Output: "one hundred and twenty-three"
Console.WriteLine("Number in Words: " + words);
}
}
Imports System
Friend Class NumberHumanizerDemo
Shared Sub Main()
Dim number As Integer = 123
' Convert number to words
Dim words As String = number.ToWords() ' Output: "one hundred and twenty-three"
Console.WriteLine("Number in Words: " & words)
End Sub
End Class

Ejemplo: Conversión de números a ordinales
using System;
class OrdinalHumanizerDemo
{
static void Main()
{
int number = 21;
// Convert number to ordinal words
string ordinal = number.ToOrdinalWords(); // Output: "twenty-first"
Console.WriteLine("Ordinal Number: " + ordinal);
}
}
using System;
class OrdinalHumanizerDemo
{
static void Main()
{
int number = 21;
// Convert number to ordinal words
string ordinal = number.ToOrdinalWords(); // Output: "twenty-first"
Console.WriteLine("Ordinal Number: " + ordinal);
}
}
Imports System
Friend Class OrdinalHumanizerDemo
Shared Sub Main()
Dim number As Integer = 21
' Convert number to ordinal words
Dim ordinal As String = number.ToOrdinalWords() ' Output: "twenty-first"
Console.WriteLine("Ordinal Number: " & ordinal)
End Sub
End Class

Pluralización y singularización
Humanizer facilita la conversión de palabras entre sus formas singular y plural, lo cual es útil para la generación dinámica de texto largo basado en la cantidad.
Ejemplo: Pluralizar y singularizar palabras
using System;
class PluralizationDemo
{
static void Main()
{
string singular = "car";
// Pluralize the word
string plural = singular.Pluralize(); // Output: "cars"
string word = "people";
// Singularize the word
string singularForm = word.Singularize(); // Output: "person"
Console.WriteLine("Plural of 'car': " + plural);
Console.WriteLine("Singular of 'people': " + singularForm);
}
}
using System;
class PluralizationDemo
{
static void Main()
{
string singular = "car";
// Pluralize the word
string plural = singular.Pluralize(); // Output: "cars"
string word = "people";
// Singularize the word
string singularForm = word.Singularize(); // Output: "person"
Console.WriteLine("Plural of 'car': " + plural);
Console.WriteLine("Singular of 'people': " + singularForm);
}
}
Imports System
Friend Class PluralizationDemo
Shared Sub Main()
Dim singular As String = "car"
' Pluralize the word
Dim plural As String = singular.Pluralize() ' Output: "cars"
Dim word As String = "people"
' Singularize the word
Dim singularForm As String = word.Singularize() ' Output: "person"
Console.WriteLine("Plural of 'car': " & plural)
Console.WriteLine("Singular of 'people': " & singularForm)
End Sub
End Class
Humanizer también maneja pluralizaciones y singularizaciones irregulares, haciéndolo robusto para varios casos de uso.

Formateo de Enums
Los enums se utilizan frecuentemente en aplicaciones C# para representar un conjunto de constantes nombradas. Humanizer puede convertir valores enum en cadenas legibles para los humanos.
Ejemplo: Humanizando Enums
using System;
public enum MyEnum
{
FirstValue,
SecondValue
}
class EnumHumanizerDemo
{
static void Main()
{
MyEnum enumValue = MyEnum.FirstValue;
// Humanizing enum to a readable format
string humanizedEnum = enumValue.Humanize(); // Output: "First value"
Console.WriteLine("Humanized Enum: " + humanizedEnum);
}
}
using System;
public enum MyEnum
{
FirstValue,
SecondValue
}
class EnumHumanizerDemo
{
static void Main()
{
MyEnum enumValue = MyEnum.FirstValue;
// Humanizing enum to a readable format
string humanizedEnum = enumValue.Humanize(); // Output: "First value"
Console.WriteLine("Humanized Enum: " + humanizedEnum);
}
}
Imports System
Public Enum MyEnum
FirstValue
SecondValue
End Enum
Friend Class EnumHumanizerDemo
Shared Sub Main()
Dim enumValue As MyEnum = MyEnum.FirstValue
' Humanizing enum to a readable format
Dim humanizedEnum As String = enumValue.Humanize() ' Output: "First value"
Console.WriteLine("Humanized Enum: " & humanizedEnum)
End Sub
End Class
Este método puede ser particularmente útil para mostrar etiquetas amigables para el usuario en las UIs.

Humanizar el tamaño de los bytes
Otra característica útil de Humanizer es la capacidad de humanizar tamaños de byte, convirtiendo grandes valores de byte en formatos legibles como KB, MB o GB.
Ejemplo: Humanizar el tamaño de los bytes
using System;
class ByteSizeHumanizerDemo
{
static void Main()
{
long bytes = 1048576;
// Humanize bytes to a readable size format
string humanizedBytes = bytes.Bytes().Humanize(); // Output: "1 MB"
Console.WriteLine("Humanized Byte Size: " + humanizedBytes);
}
}
using System;
class ByteSizeHumanizerDemo
{
static void Main()
{
long bytes = 1048576;
// Humanize bytes to a readable size format
string humanizedBytes = bytes.Bytes().Humanize(); // Output: "1 MB"
Console.WriteLine("Humanized Byte Size: " + humanizedBytes);
}
}
Imports System
Friend Class ByteSizeHumanizerDemo
Shared Sub Main()
Dim bytes As Long = 1048576
' Humanize bytes to a readable size format
Dim humanizedBytes As String = bytes.Bytes().Humanize() ' Output: "1 MB"
Console.WriteLine("Humanized Byte Size: " & humanizedBytes)
End Sub
End Class

Escenarios avanzados
Humanizer no se limita a los escenarios básicos descritos anteriormente. Admite una amplia gama de funciones avanzadas, como el método Truncate y varios idiomas y extensiones.
Ejemplo: Humanizar los desfases de DateTime
Humanizer también puede manejar DateTimeOffset, lo que resulta útil para aplicaciones que trabajan con zonas horarias.
using System;
class DateTimeOffsetHumanizerDemo
{
static void Main()
{
DateTimeOffset dateTimeOffset = DateTimeOffset.Now.AddDays(-2);
// Humanize DateTimeOffset
string humanizedDateTimeOffset = dateTimeOffset.Humanize(); // Output: "2 days ago"
Console.WriteLine("Humanized DateTimeOffset: " + humanizedDateTimeOffset);
}
}
using System;
class DateTimeOffsetHumanizerDemo
{
static void Main()
{
DateTimeOffset dateTimeOffset = DateTimeOffset.Now.AddDays(-2);
// Humanize DateTimeOffset
string humanizedDateTimeOffset = dateTimeOffset.Humanize(); // Output: "2 days ago"
Console.WriteLine("Humanized DateTimeOffset: " + humanizedDateTimeOffset);
}
}
Imports System
Friend Class DateTimeOffsetHumanizerDemo
Shared Sub Main()
Dim dateTimeOffset As DateTimeOffset = System.DateTimeOffset.Now.AddDays(-2)
' Humanize DateTimeOffset
Dim humanizedDateTimeOffset As String = dateTimeOffset.Humanize() ' Output: "2 days ago"
Console.WriteLine("Humanized DateTimeOffset: " & humanizedDateTimeOffset)
End Sub
End Class

Consideraciones sobre el rendimiento
Humanizer está diseñado para ser eficiente, pero como cualquier biblioteca, su rendimiento depende de cómo se use. Para aplicaciones que requieren alto rendimiento, especialmente aquellas que manejan grandes conjuntos de datos o procesamiento en tiempo real, es esencial considerar el impacto de las operaciones frecuentes de humanización.
IronPDF para C
IronPDF es una biblioteca integral de generación y manipulación de PDF para aplicaciones .NET. Permite a los desarrolladores crear, leer, editar y extraer contenido de archivos PDF con facilidad. IronPDF está diseñado para ser fácil de usar, ofreciendo una amplia gama de funcionalidades, incluyendo convertir HTML a PDF, fusionar documentos, añadir marcas de agua, y mucho más. Su versatilidad y potentes características lo convierten en una excelente opción para manejar documentos PDF en proyectos C#.
Instalación de IronPDF mediante el gestor de paquetes NuGet
Sigue estos pasos para instalar IronPDF usando el Administrador de Paquetes NuGet:
-
Abra su proyecto en Visual Studio:
- Inicia Visual Studio y abre tu proyecto C# existente o crea uno nuevo.
-
Abra el Administrador de paquetes NuGet :
- Haz clic derecho en tu proyecto en el Explorador de Soluciones.
- Selecciona "Administrar paquetes NuGet…" del menú context.

- Instalar IronPDF:
- En el Administrador de Paquetes NuGet, ve a la pestaña "Examinar".
- Busca IronPDF.
- Selecciona el paquete IronPDF de los resultados de búsqueda.
- Haz clic en el botón "Instalar" para añadir IronPDF a tu proyecto.

Siguiendo estos pasos, IronPDF se instalará y estará listo para usar en tu proyecto C#, permitiéndote aprovechar sus potentes capacidades de manipulación de PDF.
Ejemplo de código de C# Humanizer y IronPDF
using Humanizer;
using IronPdf;
using System;
using System.Collections.Generic;
class PDFGenerationDemo
{
static void Main()
{
// Instantiate the PDF renderer
var renderer = new ChromePdfRenderer();
// Generate humanized content
List<string> content = GenerateHumanizedContent();
// HTML content template for the PDF
string htmlContent = "<h1>Humanizer Examples</h1><ul>";
// Build the list items to add to the HTML content
foreach (var item in content)
{
htmlContent += $"<li>{item}</li>";
}
htmlContent += "</ul>";
// Render the HTML into a PDF document
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
// Save the PDF to a file
pdf.SaveAs("output.pdf");
Console.WriteLine("PDF document generated successfully: output.pdf");
}
/// <summary>
/// Generates a list of humanized content examples
/// </summary>
/// <returns>List of humanized content as strings</returns>
static List<string> GenerateHumanizedContent()
{
List<string> content = new List<string>();
// DateTime examples
DateTime pastDate = DateTime.Now.AddDays(-3);
DateTime futureDate = DateTime.Now.AddHours(5);
content.Add($"DateTime.Now: {DateTime.Now}");
content.Add($"3 days ago: {pastDate.Humanize()}");
content.Add($"In 5 hours: {futureDate.Humanize()}");
// TimeSpan examples
TimeSpan timeSpan = TimeSpan.FromMinutes(123);
content.Add($"TimeSpan of 123 minutes: {timeSpan.Humanize()}");
// Number examples
int number = 12345;
content.Add($"Number 12345 in words: {number.ToWords()}");
content.Add($"Ordinal of 21: {21.ToOrdinalWords()}");
// Pluralization examples
string singular = "car";
content.Add($"Plural of 'car': {singular.Pluralize()}");
string plural = "children";
content.Add($"Singular of 'children': {plural.Singularize()}");
// Byte size examples
long bytes = 1048576;
content.Add($"1,048,576 bytes: {bytes.Bytes().Humanize()}");
return content;
}
}
using Humanizer;
using IronPdf;
using System;
using System.Collections.Generic;
class PDFGenerationDemo
{
static void Main()
{
// Instantiate the PDF renderer
var renderer = new ChromePdfRenderer();
// Generate humanized content
List<string> content = GenerateHumanizedContent();
// HTML content template for the PDF
string htmlContent = "<h1>Humanizer Examples</h1><ul>";
// Build the list items to add to the HTML content
foreach (var item in content)
{
htmlContent += $"<li>{item}</li>";
}
htmlContent += "</ul>";
// Render the HTML into a PDF document
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
// Save the PDF to a file
pdf.SaveAs("output.pdf");
Console.WriteLine("PDF document generated successfully: output.pdf");
}
/// <summary>
/// Generates a list of humanized content examples
/// </summary>
/// <returns>List of humanized content as strings</returns>
static List<string> GenerateHumanizedContent()
{
List<string> content = new List<string>();
// DateTime examples
DateTime pastDate = DateTime.Now.AddDays(-3);
DateTime futureDate = DateTime.Now.AddHours(5);
content.Add($"DateTime.Now: {DateTime.Now}");
content.Add($"3 days ago: {pastDate.Humanize()}");
content.Add($"In 5 hours: {futureDate.Humanize()}");
// TimeSpan examples
TimeSpan timeSpan = TimeSpan.FromMinutes(123);
content.Add($"TimeSpan of 123 minutes: {timeSpan.Humanize()}");
// Number examples
int number = 12345;
content.Add($"Number 12345 in words: {number.ToWords()}");
content.Add($"Ordinal of 21: {21.ToOrdinalWords()}");
// Pluralization examples
string singular = "car";
content.Add($"Plural of 'car': {singular.Pluralize()}");
string plural = "children";
content.Add($"Singular of 'children': {plural.Singularize()}");
// Byte size examples
long bytes = 1048576;
content.Add($"1,048,576 bytes: {bytes.Bytes().Humanize()}");
return content;
}
}
Imports Humanizer
Imports IronPdf
Imports System
Imports System.Collections.Generic
Friend Class PDFGenerationDemo
Shared Sub Main()
' Instantiate the PDF renderer
Dim renderer = New ChromePdfRenderer()
' Generate humanized content
Dim content As List(Of String) = GenerateHumanizedContent()
' HTML content template for the PDF
Dim htmlContent As String = "<h1>Humanizer Examples</h1><ul>"
' Build the list items to add to the HTML content
For Each item In content
htmlContent &= $"<li>{item}</li>"
Next item
htmlContent &= "</ul>"
' Render the HTML into a PDF document
Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
' Save the PDF to a file
pdf.SaveAs("output.pdf")
Console.WriteLine("PDF document generated successfully: output.pdf")
End Sub
''' <summary>
''' Generates a list of humanized content examples
''' </summary>
''' <returns>List of humanized content as strings</returns>
Private Shared Function GenerateHumanizedContent() As List(Of String)
Dim content As New List(Of String)()
' DateTime examples
Dim pastDate As DateTime = DateTime.Now.AddDays(-3)
Dim futureDate As DateTime = DateTime.Now.AddHours(5)
content.Add($"DateTime.Now: {DateTime.Now}")
content.Add($"3 days ago: {pastDate.Humanize()}")
content.Add($"In 5 hours: {futureDate.Humanize()}")
' TimeSpan examples
Dim timeSpan As TimeSpan = System.TimeSpan.FromMinutes(123)
content.Add($"TimeSpan of 123 minutes: {timeSpan.Humanize()}")
' Number examples
Dim number As Integer = 12345
content.Add($"Number 12345 in words: {number.ToWords()}")
content.Add($"Ordinal of 21: {21.ToOrdinalWords()}")
' Pluralization examples
Dim singular As String = "car"
content.Add($"Plural of 'car': {singular.Pluralize()}")
Dim plural As String = "children"
content.Add($"Singular of 'children': {plural.Singularize()}")
' Byte size examples
Dim bytes As Long = 1048576
content.Add($"1,048,576 bytes: {bytes.Bytes().Humanize()}")
Return content
End Function
End Class

Conclusión
Humanizer es una biblioteca indispensable para desarrolladores .NET que apuntan a crear aplicaciones que presenten información en un formato amigable y legible por humanos. Su amplia gama de características, desde la humanización de fechas y horas hasta el formateo de números y enums, lo convierten en una herramienta versátil para mejorar la usabilidad de las aplicaciones. Al aprovechar Humanizer, los desarrolladores pueden ahorrar tiempo y esfuerzo en implementar lógica de formateo personalizada, garantizando que sus aplicaciones comuniquen datos de manera más efectiva a los usuarios finales.
De manera similar, IronPDF ofrece capacidades integrales de generación y manipulación de PDF, convirtiéndolo en una excelente opción para crear y manejar documentos PDF en proyectos C#. Juntos, Humanizer e IronPDF pueden mejorar significativamente la funcionalidad y presentación de las aplicaciones .NET. Para más detalles sobre las licencias de IronPDF, consulte la información sobre licencias de IronPDF. Para explorar más, consulte el tutorial de conversión de HTML a PDF.
Preguntas Frecuentes
¿Cuál es el propósito de la biblioteca Humanizer en C#?
La biblioteca Humanizer en C# está diseñada para transformar datos en formatos amigables para el ser humano, como convertir fechas a cadenas de tiempo relativo, pluralizar palabras, formatear números como palabras y manejar enums. Ayuda a los desarrolladores a presentar datos de una manera más legible y accesible.
¿Cómo puedo convertir un DateTime en una cadena de tiempo relativo en C#?
Puedes usar el método Humanize de Humanizer para convertir un objeto DateTime en una cadena de tiempo relativo, como 'hace 3 días' o 'en 5 horas'.
¿Cómo instalo la biblioteca Humanizer en un proyecto de C#?
Para instalar la biblioteca Humanizer en un proyecto de C#, puedes usar la consola del Administrador de Paquetes NuGet con el comando Install-Package Humanizer o usar la CLI de .NET Core con dotnet add package Humanizer.
¿Cuáles son algunos ejemplos de transformaciones de datos posibles con Humanizer?
Humanizer puede realizar varias transformaciones de datos, como convertir cadenas en mayúsculas a oraciones, transformar cadenas subrayadas a mayúsculas, y truncar texto largo a una longitud especificada.
¿Puede Humanizer ayudar con la pluralización de palabras en C#?
Sí, Humanizer proporciona métodos para pluralizar y singularizar palabras, manejando efectivamente tanto formas regulares como irregulares, como convertir 'car' a 'cars' o 'people' a 'person'.
¿Cómo maneja Humanizer los enums en C#?
Humanizer puede convertir valores de enums a cadenas legibles para los humanos, facilitando la visualización de etiquetas amigables para el usuario en interfaces.
¿Qué características ofrece una biblioteca PDF de C#?
Una biblioteca PDF de C# como IronPDF ofrece características como crear, leer, editar y extraer contenido de archivos PDF. También puede convertir HTML a PDF, fusionar documentos y añadir marcas de agua.
¿Cómo instalo una biblioteca PDF de C# en mi proyecto?
Para instalar una biblioteca PDF de C#, puedes usar el Administrador de Paquetes NuGet buscando el nombre de la biblioteca, como IronPDF, en la pestaña 'Browse' y haciendo clic en 'Install'.
¿Cuáles son los beneficios de combinar Humanizer con una biblioteca PDF en C#?
Al combinar Humanizer con una biblioteca PDF como IronPDF, los desarrolladores pueden generar contenido legible para los humanos con Humanizer y luego renderizarlo en un documento PDF, facilitando la creación de informes y documentación en PDF amigables para el usuario.
¿Qué debo considerar en cuanto al rendimiento cuando uso Humanizer?
Aunque Humanizer está diseñado para ser eficiente, los desarrolladores deben considerar el impacto de las operaciones de humanización frecuentes en aplicaciones que requieren un alto rendimiento con grandes cantidades de datos o procesamiento en tiempo real.




