Humanizer é uma biblioteca .NET poderosa e flexível que simplifica e humaniza o processo de trabalho com dados, especialmente quando se trata de exibir informações em um formato amigável ao usuário. Seja para converter datas em strings de tempo relativo ("há 3 dias"), pluralizar palavras, formatar números como palavras ou trabalhar com enumerações, exibir strings, converter strings de entrada em PascalCase em frases com descrições personalizadas, converter strings de entrada com sublinhados em strings com letras maiúsculas e minúsculas e truncar textos longos, o Humanizer oferece uma variedade de ferramentas e métodos de extensão para lidar com essas tarefas de forma elegante em C# .NET , convertendo strings de entrada desumanizadas em frases.
Neste artigo, discutiremos um tutorial detalhado sobre o Humanizer em C#. Também discutiremos como gerar documentos PDF usando o Humanizer e o IronPDF para a biblioteca PDF em C#.
Para começar a usar o Humanizer, você precisa instalar a biblioteca via NuGet. No seu projeto, você pode fazer isso através do Console do Gerenciador de Pacotes com o seguinte comando:
Alternativamente, se você estiver usando a CLI do .NET Core , poderá adicionar o Humanizer com:
Após a instalação, você pode começar a usar o Humanizer incluindo o namespace apropriado em seus arquivos C#:
using Humanizer;Imports HumanizerUm dos usos mais comuns do Humanizer é converter datas e horários em formatos legíveis para humanos, períodos de tempo, números e quantidades usando o método Humanize. Isso é particularmente útil para exibir tempos relativos, como "2 horas atrás" ou "em 5 dias".
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 ClassO método de extensão Humanizer lida automaticamente com diferentes unidades de tempo e até mesmo ajusta a correção gramatical.
O Humanizer também pode humanizar objetos TimeSpan, facilitando a exibição de durações em um formato legível.
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
O Humanizer oferece diversos métodos para converter números em palavras legíveis para humanos e para lidar com números ordinais.
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
O Humanizer facilita a conversão de palavras entre suas formas singular e plural, o que é útil para gerar textos longos dinamicamente com base na quantidade.
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 ClassO Humanizer também lida com pluralizações e singularizações irregulares, tornando-o robusto para diversos casos de uso.
Enums são frequentemente usados em aplicações C# para representar um conjunto de constantes nomeadas. O Humanizer pode converter valores de enumeração em strings legíveis para 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 ClassEsse método pode ser particularmente útil para exibir rótulos fáceis de usar em interfaces de usuário.
Outra funcionalidade útil do Humanizer é a capacidade de humanizar tamanhos de bytes, convertendo valores grandes em formatos legíveis como KB, MB ou 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
O Humanizer não se limita aos cenários básicos descritos acima. Ele suporta uma ampla gama de recursos avançados, como o método Truncate e múltiplos idiomas e extensões.
O Humanizer também pode lidar com DateTimeOffset, o que é útil para aplicações que lidam com fusos horários.
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
O Humanizer foi projetado para ser eficiente, mas, como qualquer biblioteca, seu desempenho depende de como é utilizado. Para aplicações que exigem alto desempenho, especialmente aquelas que lidam com grandes conjuntos de dados ou processamento em tempo real, é essencial considerar o impacto de operações frequentes de humanização.
IronPDF é uma biblioteca completa para geração e manipulação de PDFs em aplicações .NET . Permite aos desenvolvedores criar, ler, editar e extrair conteúdo de arquivos PDF com facilidade. O IronPDF foi projetado para ser fácil de usar, oferecendo uma ampla gama de funcionalidades, incluindo conversão de HTML para PDF, mesclagem de documentos, adição de marcas d'água e muito mais. Sua versatilidade e recursos poderosos fazem dele uma excelente escolha para lidar com documentos PDF em projetos C#.
Siga estes passos para instalar o IronPDF usando o Gerenciador de Pacotes NuGet :
Abra seu projeto no Visual Studio:
Abra o Gerenciador de Pacotes NuGet :
Instale o IronPDF:
Seguindo estes passos, o IronPDF será instalado e estará pronto para uso em seu projeto C#, permitindo que você aproveite seus poderosos recursos de manipulação 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 é uma biblioteca indispensável para desenvolvedores .NET que desejam criar aplicativos que apresentem informações em um formato amigável e legível para humanos. Sua ampla gama de recursos, desde a humanização de datas e horas até a formatação de números e enumerações, a torna uma ferramenta versátil para melhorar a usabilidade de aplicativos. Ao utilizar o Humanizer, os desenvolvedores podem economizar tempo e esforço na implementação de lógica de formatação personalizada, garantindo que seus aplicativos comuniquem dados de forma mais eficaz aos usuários finais.
Da mesma forma, o IronPDF oferece recursos abrangentes de geração e manipulação de PDFs, tornando-o uma excelente opção para criar e gerenciar documentos PDF em projetos C#. Em conjunto, o Humanizer e o IronPDF podem melhorar significativamente a funcionalidade e a apresentação de aplicações .NET . Para obter mais detalhes sobre o licenciamento do IronPDF , consulte as Informações de Licenciamento do IronPDF . Para explorar mais a fundo, confira nosso Tutorial Detalhado sobre Conversão de HTML para PDF .
Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais bem estruturados e visualmente atraentes.
IronPDF faz parte do IRON SUITE.
10 produtos de API .NET para seus documentos de escritório
Quando você precisa que seu PDF tenha a aparência de HTML, rapidamente.
