Humanizer C# (Comment ça marche pour les développeurs)

Humanizer est une bibliothèque .NET puissante et flexible qui simplifie et humanise le processus de travail avec les données, en particulier lorsqu'il s'agit d'afficher des informations dans un format convivial. Si vous devez convertir des dates en chaînes de temps relatives("Il y a 3 jours")humanizer fournit une pléthore d'outils et de méthodes d'extension pour traiter ces tâches de manière élégante en C#.NET afin de convertir les chaînes de saisie déshumanisées en phrases.

Dans cet article, nous allons aborder un tutoriel détaillé de Humanizer en C#. Nous verrons également comment générer des documents PDF à l'aide d'Humanizer et d'IronPDF pour la bibliothèque PDF C#.

Configuration de Humanizer en C

Pour commencer à utiliser Humanizer, vous devez installer la bibliothèque via NuGet. Dans votre projet, vous pouvez le faire via la console du gestionnaire de paquets avec la commande suivante :

Install-Package Humanizer

Install-Package Humanizer

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'Install-Package Humanizer

Alternativement, si vous utilisez le CLI de .NET Core, vous pouvez ajouter Humanizer avec :

dotnet add package Humanizer

Après l'installation, vous pouvez commencer à utiliser Humanizer en incluant l'espace de noms approprié dans vos fichiers C# :

using Humanizer;

using Humanizer;

Imports Humanizer

Dates et heures d'humanisation

L'une des utilisations les plus courantes de Humanizer consiste à convertir des dates et des heures en formats lisibles par l'homme, des périodes, des nombres et des quantités en utilisant la méthode Humanize. Cette fonction est particulièrement utile pour afficher des temps relatifs, tels que "il y a 2 heures" ou "dans 5 jours".

Exemple : Humaniser le temps relatif

DateTime pastDate = DateTime.Now.AddDays(-3);
string humanizedTime = pastDate.Humanize(); // Output: "3 days ago"
DateTime futureDate = DateTime.Now.AddHours(5);
string futureHumanizedTime = futureDate.Humanize(); // Output: "in 5 hours"

DateTime pastDate = DateTime.Now.AddDays(-3);
string humanizedTime = pastDate.Humanize(); // Output: "3 days ago"
DateTime futureDate = DateTime.Now.AddHours(5);
string futureHumanizedTime = futureDate.Humanize(); // Output: "in 5 hours"

Dim pastDate As DateTime = DateTime.Now.AddDays(-3)
Dim humanizedTime As String = pastDate.Humanize() ' Output: "3 days ago"
Dim futureDate As DateTime = DateTime.Now.AddHours(5)
Dim futureHumanizedTime As String = futureDate.Humanize() ' Output: "in 5 hours"

La méthode d'extension Humanizer gère automatiquement les différentes unités de temps et s'adapte même à la correction grammaticale.

Humaniser les périodes de temps

Humanizer peut également humaniser les objets TimeSpan, ce qui facilite l'affichage des durées dans un format lisible.

Exemple : Humanisation de l'intervalle de temps

TimeSpan timeSpan = TimeSpan.FromMinutes(123);
string humanizedTimeSpan = timeSpan.Humanize(2); // Output: "2 hours, 3 minutes"

TimeSpan timeSpan = TimeSpan.FromMinutes(123);
string humanizedTimeSpan = timeSpan.Humanize(2); // Output: "2 hours, 3 minutes"

Dim timeSpan As TimeSpan = System.TimeSpan.FromMinutes(123)
Dim humanizedTimeSpan As String = timeSpan.Humanize(2) ' Output: "2 hours, 3 minutes"

Travailler avec des nombres

Humanizer propose plusieurs méthodes pour convertir les nombres en mots lisibles par l'homme et pour traiter les nombres ordinaux.

Exemple : Convertir des nombres en mots

int number = 123;
string words = number.ToWords(); // Output: "one hundred and twenty-three"

int number = 123;
string words = number.ToWords(); // Output: "one hundred and twenty-three"

Dim number As Integer = 123
Dim words As String = number.ToWords() ' Output: "one hundred and twenty-three"

Exemple : Conversion des nombres en ordinaux

int number = 21;
string ordinal = number.ToOrdinalWords(); // Output: "twenty-first"

int number = 21;
string ordinal = number.ToOrdinalWords(); // Output: "twenty-first"

Dim number As Integer = 21
Dim ordinal As String = number.ToOrdinalWords() ' Output: "twenty-first"

Pluralisation et singularisation

Humanizer facilite la conversion des mots entre le singulier et le pluriel, ce qui est utile pour générer dynamiquement des textes longs en fonction de la quantité.

Exemple : Pluralisation et singularisation des mots

string singular = "car";
string plural = singular.Pluralize(); // Output: "cars"
string word = "people";
string singularForm = word.Singularize(); // Output: "person"

string singular = "car";
string plural = singular.Pluralize(); // Output: "cars"
string word = "people";
string singularForm = word.Singularize(); // Output: "person"

Dim singular As String = "car"
Dim plural As String = singular.Pluralize() ' Output: "cars"
Dim word As String = "people"
Dim singularForm As String = word.Singularize() ' Output: "person"

Humanizer gère également les pluralisations et singularisations irrégulières, ce qui le rend robuste pour divers cas d'utilisation.

Formatage des Enums

Les énumérations sont fréquemment utilisées dans les applications C# pour représenter un ensemble de constantes nommées. Humanizer permet de convertir les valeurs des enums en chaînes lisibles par l'homme.

Exemple : Humaniser les Enums

MyEnum enumValue = MyEnum.FirstValue;
string humanizedEnum = enumValue.Humanize();
System.Console.WriteLine(humanizedEnum);
public enum MyEnum
{
    FirstValue,
    SecondValue
} // Output: "First value"

MyEnum enumValue = MyEnum.FirstValue;
string humanizedEnum = enumValue.Humanize();
System.Console.WriteLine(humanizedEnum);
public enum MyEnum
{
    FirstValue,
    SecondValue
} // Output: "First value"

Private enumValue As MyEnum = MyEnum.FirstValue
Private humanizedEnum As String = enumValue.Humanize()
System.Console.WriteLine(humanizedEnum)
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'public enum MyEnum
'{
'	FirstValue,
'	SecondValue
'} ' Output: "First value"

Cette méthode peut être particulièrement utile pour afficher des étiquettes conviviales dans les interfaces utilisateur.

Humanisation de la taille des octets

Une autre fonction pratique de Humanizer est la possibilité d'humaniser les tailles d'octets, en convertissant les grandes valeurs d'octets en formats lisibles tels que KB, MB ou GB.

Exemple : Humanisation de la taille des octets

long bytes = 1048576;
string humanizedBytes = bytes.Bytes().Humanize(); // Output: "1 MB"

long bytes = 1048576;
string humanizedBytes = bytes.Bytes().Humanize(); // Output: "1 MB"

Dim bytes As Long = 1048576
Dim humanizedBytes As String = bytes.Bytes().Humanize() ' Output: "1 MB"

Scénarios avancés

Humanizer ne se limite pas aux scénarios de base décrits ci-dessus. Il prend en charge un large éventail de fonctions avancées telles que la méthode Truncate et plusieurs langues et extensions.

Exemple : Humaniser les décalages de date et d'heure

Humanizer peut également gérer DateTimeOffset, ce qui est utile pour les applications traitant des fuseaux horaires.

DateTimeOffset dateTimeOffset = DateTimeOffset.Now.AddDays(-2);
string humanizedDateTimeOffset = dateTimeOffset.Humanize(); // Output: "2 days ago"

DateTimeOffset dateTimeOffset = DateTimeOffset.Now.AddDays(-2);
string humanizedDateTimeOffset = dateTimeOffset.Humanize(); // Output: "2 days ago"

Dim dateTimeOffset As DateTimeOffset = System.DateTimeOffset.Now.AddDays(-2)
Dim humanizedDateTimeOffset As String = dateTimeOffset.Humanize() ' Output: "2 days ago"

Considérations sur les performances

Humanizer est conçu pour être efficace, mais comme toute bibliothèque, ses performances dépendent de la manière dont il est utilisé. Pour les applications nécessitant des performances élevées, en particulier celles qui traitent de grands ensembles de données ou en temps réel, il est essentiel de prendre en compte l'impact des opérations d'humanisation fréquentes.

IronPDF pour C

IronPDF est une bibliothèque complète de génération et de manipulation de fichiers PDF pour les applications .NET. Il permet aux développeurs de créer, de lire, de modifier et d'extraire le contenu des fichiers PDF en toute simplicité. IronPDF est conçu pour être convivial et offre un large éventail de fonctionnalités, notamment la conversion de HTML en PDF, la fusion de documents, l'ajout de filigranes, et bien plus encore. Sa polyvalence et ses puissantes fonctionnalités en font un excellent choix pour traiter les documents PDF dans les projets C#.

Installation d'IronPDF via le gestionnaire de paquets NuGet

Suivez les étapes suivantes pour installer IronPDF à l'aide du gestionnaire de paquets NuGet :

1. Ouvrez votre projet dans Visual Studio :

   • Lancez Visual Studio et ouvrez votre projet C# existant ou créez-en un nouveau.

2. Ouvrez le gestionnaire de paquets NuGet :

   • Cliquez avec le bouton droit de la souris sur votre projet dans l'explorateur de solutions.

   • Sélectionnez "Manage NuGet Packages..." dans le menu contextuel.

   

3. Installer IronPDF :

   • Dans le gestionnaire de paquets NuGet, cliquez sur l'onglet "Parcourir".

   • Rechercher IronPDF.

   • Sélectionnez le paquet IronPDF dans les résultats de la recherche.

   • Cliquez sur le bouton "Installer" pour ajouter IronPDF à votre projet.

   

   En suivant ces étapes, IronPDF sera installé et prêt à être utilisé dans votre projet C#, ce qui vous permettra de tirer parti de ses puissantes capacités de manipulation des PDF.

Exemple de code C# Humanizer et IronPDF

using Humanizer;
using IronPdf;
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // Instantiate Renderer
        var renderer = new ChromePdfRenderer();
        List<string> content = GenerateHumanizedContent();
        string htmlContent = "<h1>Humanizer Examples</h1><ul>";

        // Iterate over each item in the List and add it to the HTML string
        foreach (var item in content)
        {
            htmlContent += $"<li>{item}</li>";
        }
        htmlContent += "</ul>";

        // Create a PDF from an HTML string using C#
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);

        // Export to a file or stream
        pdf.SaveAs("output.pdf");
    }

    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 Program
{
    static void Main()
    {
        // Instantiate Renderer
        var renderer = new ChromePdfRenderer();
        List<string> content = GenerateHumanizedContent();
        string htmlContent = "<h1>Humanizer Examples</h1><ul>";

        // Iterate over each item in the List and add it to the HTML string
        foreach (var item in content)
        {
            htmlContent += $"<li>{item}</li>";
        }
        htmlContent += "</ul>";

        // Create a PDF from an HTML string using C#
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);

        // Export to a file or stream
        pdf.SaveAs("output.pdf");
    }

    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 Program
	Shared Sub Main()
		' Instantiate Renderer
		Dim renderer = New ChromePdfRenderer()
		Dim content As List(Of String) = GenerateHumanizedContent()
		Dim htmlContent As String = "<h1>Humanizer Examples</h1><ul>"

		' Iterate over each item in the List and add it to the HTML string
		For Each item In content
			htmlContent &= $"<li>{item}</li>"
		Next item
		htmlContent &= "</ul>"

		' Create a PDF from an HTML string using C#
		Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)

		' Export to a file or stream
		pdf.SaveAs("output.pdf")
	End Sub

	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

Conclusion

Humanizer est une bibliothèque indispensable pour les développeurs .NET qui souhaitent créer des applications présentant des informations dans un format convivial et lisible par l'homme. Son large éventail de fonctionnalités, allant de l'humanisation de la date et de l'heure au formatage des nombres et des énumérations, en fait un outil polyvalent permettant d'améliorer la convivialité des applications. En s'appuyant sur Humanizer, les développeurs peuvent gagner du temps et de l'énergie dans la mise en œuvre d'une logique de formatage personnalisée, garantissant ainsi que leurs applications communiquent les données de manière plus efficace aux utilisateurs finaux.

De même, IronPDF offre des capacités complètes de génération et de manipulation de PDF, ce qui en fait un excellent choix pour la création et la manipulation 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 les licences d'IronPDF, reportez-vous à la sectionInformations sur les licences IronPDF. Pour en savoir plus, consultez notreTutoriel détaillé sur la conversion de HTML en PDF.