Humanizer est une bibliothèque .NET puissante et flexible qui simplifie et humanise le traitement des données, surtout lorsqu'il s'agit d'afficher des informations dans un format convivial. Que vous ayez besoin de convertir des dates en chaînes de temps relatives (" il y a 3 jours "), de mettre des mots au pluriel, de formater des nombres en mots, ou de travailler avec des énumérations, d'afficher des chaînes, des entrées en Pascal case sous forme de phrases avec des descriptions personnalisées, des chaînes d'entrée soulignées en chaînes en casse normalisée, et de troncature de texte long, Humanizer offre une pléthore d'outils et de méthodes d'extension pour gérer ces tâches élégamment en C#.NET pour convertir des chaînes d'entrée déshumanisées en phrases.
Dans cet article, nous discuterons d'un tutoriel détaillé de Humanizer en C#. Nous discuterons également de la génération de documents PDF en utilisant Humanizer et IronPDF pour la bibliothèque PDF C#.
Pour commencer avec Humanizer, vous devez installer la bibliothèque via NuGet. Dans votre projet, vous pouvez le faire via la Console du Gestionnaire de Packages avec la commande suivante :
Alternativement, si vous utilisez l'interface CLI de .NET Core, vous pouvez ajouter Humanizer avec :
Après l'installation, vous pouvez commencer à utiliser Humanizer en incluant l'espace de noms approprié dans vos fichiers C# :
using Humanizer;Imports HumanizerL'une des utilisations les plus courantes de Humanizer est de convertir les dates et les heures en formats lisibles par l'homme, les durées, les nombres et les quantités en utilisant la méthode Humanize. C'est particulièrement utile pour afficher des temps relatifs, comme "il y a 2 heures" ou "dans 5 jours".
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 ClassLa méthode d'extension Humanizer gère automatiquement les différentes unités de temps et ajuste même pour la correction grammaticale.
Humanizer peut également humaniser les objets TimeSpan, ce qui permet de facilement afficher les durées dans un format lisible.
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 fournit plusieurs méthodes pour convertir les nombres en mots lisibles par l'homme et pour gérer les nombres ordinaux.
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 facilite la conversion des mots entre leurs formes singulières et plurielles, ce qui est utile pour générer dynamiquement du texte long en fonction de la quantité.
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 gère également les pluralisations et singularisations irrégulières, le rendant robuste pour divers cas d'utilisation.
Les énumérations sont fréquemment utilisées dans les applications C# pour représenter un ensemble de constantes nommées. Humanizer peut convertir les valeurs d'énumération en chaînes lisibles par l'homme.
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 ClassCette méthode peut être particulièrement utile pour afficher des étiquettes conviviales dans les interfaces utilisateur.
Une autre fonctionnalité pratique de Humanizer est la capacité d'humaniser les tailles de bytes, en convertissant de grandes valeurs de bytes en formats lisibles comme Ko, Mo, ou Go.
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 n'est pas limité aux scénarios de base décrits ci-dessus. Il prend en charge un large éventail de fonctionnalités avancées telles que la méthode Truncate et plusieurs langues et extensions.
Humanizer peut également gérer DateTimeOffset, ce qui est utile pour les applications traitant des fuseaux horaires.
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 conçu pour être efficace, mais comme toute bibliothèque, ses performances dépendent de son utilisation. Pour les applications nécessitant des performances élevées, notamment celles traitant de grands ensembles de données ou de traitement en temps réel, il est essentiel de considérer l'impact des opérations d'humanisation fréquentes.
IronPDF est une bibliothèque complète de génération et de manipulation de PDF pour les applications .NET. Il permet aux développeurs de créer, lire, modifier et extraire du contenu des fichiers PDF facilement. IronPDF est conçu pour être convivial, offrant une large gamme de fonctionnalités incluant la conversion d'HTML en PDF, la fusion de documents, l'ajout de filigranes, et bien plus. Sa polyvalence et ses fonctionnalités puissantes en font un excellent choix pour la gestion des documents PDF dans les projets C#.
Suivez ces étapes pour installer IronPDF en utilisant le Gestionnaire de Packages NuGet :
En suivant ces étapes, IronPDF sera installé et prêt à être utilisé dans votre projet C#, vous permettant de tirer parti de ses capacités puissantes de manipulation 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 est une bibliothèque indispensable pour les développeurs .NET visant à créer des applications qui présentent des informations dans un format convivial et lisible par l'homme. Sa large gamme de fonctionnalités, de l'humanisation des dates et heures au formatage des nombres et enum, en fait un outil polyvalent pour améliorer l'utilisabilité des applications. En tirant parti de Humanizer, les développeurs peuvent économiser du temps et des efforts en implémentant une logique de formatage personnalisée, assurant que leurs applications communiquent plus efficacement les données aux utilisateurs finaux.
De même, IronPDF offre des capacités complètes de génération et de manipulation de PDF, faisant de lui un excellent choix pour la création et la gestion de documents PDF dans les projets C#. Ensemble, Humanizer et IronPDF peuvent améliorer considérablement la fonctionnalité et la présentation des applications .NET. Pour plus de détails sur la licence IronPDF, référez-vous à l'Informations de Licence IronPDF. Pour explorer davantage, consultez notre Tutoriel Détaillé sur la Conversion d'HTML en PDF.
Jacob Mellor est directeur de la technologie chez Iron Software et un ingénieur visionnaire pionnier de la technologie C# PDF. En tant que développeur à l'origine de la base de code centrale d'Iron Software, il a façonné l'architecture des produits de l'entreprise depuis sa création, la transformant aux côtés du PDG Cameron Rimington en une entreprise de plus de 50 personnes au service de la NASA, de Tesla et d'agences gouvernementales mondiales.
IronPDF fait partie de IRONSUITE
10 API .NET pour vos documents
Lorsque vous avez besoin que votre PDF ressemble à HTML, rapidement.
