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#.
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:
Alternativamente, si estás usando la CLI de .NET Core, puedes agregar Humanizer con:
Después de la instalación, puedes comenzar a usar Humanizer incluyendo el espacio de nombres apropiado en tus archivos C#:
using Humanizer;Imports HumanizerUno 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".
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 ClassEl método de extensión de Humanizer maneja automáticamente diferentes unidades de tiempo e incluso ajusta para la corrección gramatical.
Humanizer también puede humanizar objetos TimeSpan, facilitando mostrar las duraciones en un formato legible.
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
Humanizer proporciona varios métodos para convertir números en palabras legibles y para manejar números ordinales.
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
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
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.
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 ClassHumanizer también maneja pluralizaciones y singularizaciones irregulares, haciéndolo robusto para varios casos de uso.
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.
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 ClassEste método puede ser particularmente útil para mostrar etiquetas amigables para el usuario en las UIs.
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.
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
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
Humanizer no se limita a los escenarios básicos descritos anteriormente. Admite una amplia gama de funciones avanzadas como el método Truncate y múltiples idiomas y extensiones.
Humanizer también puede manejar DateTimeOffset, lo cual es útil para aplicaciones que tratan 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);
}
}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
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 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#.
Sigue estos pasos para instalar IronPDF usando el Administrador de Paquetes NuGet:
Abra su proyecto en Visual Studio:
Abra el Administrador de paquetes NuGet :
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.
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
Class PDFGenerationDemo
Shared Sub Main()
' Instantiate the PDF renderer
Dim renderer As 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
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>
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 = 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
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, consulta la Información sobre Licencias de IronPDF. Para explorar más, consulta nuestro Tutorial Detallado sobre la Conversión de HTML a PDF.
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.
