Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. Humanizer C#
.NET AIDE

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

Curtis Chau
Curtis Chau
Mis à jour:

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#.

Installation de Humanizer en 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 :

Install-Package Humanizer

Alternativement, si vous utilisez l'interface 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
$vbLabelText   $csharpLabel

Humanisation des Dates et Heures

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

Exemple : Humanisation du Temps Relatif

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
$vbLabelText   $csharpLabel

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

Humanizer C# (Comment Cela Fonctionne Pour les Développeurs) : Figure 1 - Sortie de Temps Relatif Humanisé

Humanisation des durées (TimeSpans)

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

Exemple : Humanisation de 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
$vbLabelText   $csharpLabel

Humanizer C# (Comment Cela Fonctionne Pour les Développeurs) : Figure 2 - Sortie de TimeSpan Humanisé

Travailler avec les Nombres

Humanizer fournit plusieurs méthodes pour convertir les nombres en mots lisibles par l'homme et pour gérer les nombres ordinaux.

Exemple : Conversion des Nombres en Mots

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
$vbLabelText   $csharpLabel

Humanizer C# (Comment Cela Fonctionne Pour les Développeurs) : Figure 3 - Sortie de Nombre en Mot

Exemple : Conversion des Nombres en Ordinaux

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
$vbLabelText   $csharpLabel

Humanizer C# (Comment Cela Fonctionne Pour les Développeurs) : Figure 4 - Sortie de Nombre en Ordinal

Pluralisation et Singularisation

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é.

Exemple : Pluralisation et Singularisation des Mots

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
$vbLabelText   $csharpLabel

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

Humanizer C# (Comment Cela Fonctionne Pour les Développeurs) : Figure 5 - Sortie Pluraliser et Singulariser

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 peut convertir les valeurs d'énumération en chaînes lisibles par l'homme.

Exemple : Humanisation des 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
$vbLabelText   $csharpLabel

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

Humanizer C# (Comment Cela Fonctionne Pour les Développeurs) : Figure 6 - Sortie Humaniser Enum

Humanisation des Tailles de Bytes

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.

Exemple : Humanisation des Tailles de 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
$vbLabelText   $csharpLabel

Humanizer C# (Comment Cela Fonctionne Pour les Développeurs) : Figure 7 - Sortie d'Humanisation des Tailles de Bytes

Scénarios Avancés

Humanizer n'est pas limité aux scénarios de base décrits ci-dessus. Il prend en charge une large gamme de fonctionnalités avancées telles que la méthode Truncate et de multiples langues et extensions.

Exemple : Humanisation des Décalages DateTime

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);
    }
}
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
$vbLabelText   $csharpLabel

Humanizer C# (Comment Cela Fonctionne Pour les Développeurs) : Figure 8 - Sortie d'Humanisation de DateTimeOffset

Considérations de performance

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 pour C#

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#.

Installation de IronPDF via le Gestionnaire de Packages NuGet

Suivez ces étapes pour installer IronPDF en utilisant le Gestionnaire de Packages NuGet :

  1. Ouvrez Votre Projet dans Visual Studio :
  • Lancez Visual Studio et ouvrez votre projet C# existant ou créez-en un nouveau.
  1. Ouvrez le Gestionnaire de Packages NuGet :
  • Faites un clic droit sur votre projet dans l'Explorateur de Solutions.
  • Sélectionnez "Gérer les Packages NuGet…" dans le menu contextuel.

Humanizer C# (Comment Cela Fonctionne Pour les Développeurs) : Figure 9 - Gestionnaire de Packages NuGet

  1. Installer IronPDF :
  • Dans le Gestionnaire de Packages NuGet, allez à l'onglet "Parcourir".
  • Recherchez IronPDF.
  • Sélectionnez le package IronPDF parmi les résultats de recherche.
  • Cliquez sur le bouton "Installer" pour ajouter IronPDF à votre projet.

Humanizer C# (Comment Cela Fonctionne Pour les Développeurs) : Figure 10 - IronPDF

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.

Exemple de Code C# avec Humanizer et 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
$vbLabelText   $csharpLabel

Humanizer C# (Comment Cela Fonctionne Pour les Développeurs) : Figure 11 - Sortie PDF

Conclusion

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.

Questions Fréquemment Posées

Quel est le but de la bibliothèque Humanizer en C# ?

La bibliothèque Humanizer en C# est conçue pour transformer des données en formats conviviaux, tels que la conversion de dates en chaînes de temps relatives, la pluralisation de mots, la mise en forme de chiffres en mots, et la gestion des énumérations. Elle aide les développeurs à présenter les données de manière plus lisible et accessible.

Comment puis-je convertir un DateTime en une chaîne de temps relative en C# ?

Vous pouvez utiliser la méthode Humanize de Humanizer pour convertir un objet DateTime en une chaîne de temps relative, telle que 'il y a 3 jours' ou 'dans 5 heures'.

Comment installer la bibliothèque Humanizer dans un projet C# ?

Pour installer la bibliothèque Humanizer dans un projet C#, vous pouvez utiliser la console NuGet Package Manager avec la commande Install-Package Humanizer ou utiliser la CLI .NET Core avec dotnet add package Humanizer.

Quels sont quelques exemples de transformations de données possibles avec Humanizer ?

Humanizer peut effectuer plusieurs transformations de données, telles que la conversion de chaînes en casse Pascal en phrases, la transformation de chaînes soulignées en casse de titre, et la troncature de textes longs à une longueur spécifiée.

Humanizer peut-il aider à la pluralisation des mots en C# ?

Oui, Humanizer fournit des méthodes pour pluraliser et singulariser les mots, gérant efficacement les formes régulières et irrégulières, comme la conversion de 'car' en 'cars' ou 'people' en 'person'.

Comment Humanizer gère-t-il les énumérations en C# ?

Humanizer peut convertir les valeurs d'énumération en chaînes lisibles par l'homme, ce qui facilite l'affichage des étiquettes conviviales dans les interfaces.

Quelles fonctionnalités une bibliothèque PDF en C# offre-t-elle ?

Une bibliothèque PDF en C# comme IronPDF offre des fonctionnalités telles que la création, la lecture, la modification, et l'extraction de contenu de fichiers PDF. Elle peut également convertir du HTML en PDF, fusionner des documents, et ajouter des filigranes.

Comment installer une bibliothèque PDF en C# dans mon projet ?

Pour installer une bibliothèque PDF en C#, vous pouvez utiliser le gestionnaire de packages NuGet en recherchant le nom de la bibliothèque, tel que IronPDF, dans l'onglet 'Parcourir' et en cliquant sur 'Installer'.

Quels sont les avantages de combiner Humanizer avec une bibliothèque PDF en C# ?

En combinant Humanizer avec une bibliothèque PDF comme IronPDF, les développeurs peuvent générer du contenu lisible par l'homme avec Humanizer et ensuite le rendre dans un document PDF, facilitant la création de rapports et de documentation PDF conviviaux.

Que devrais-je prendre en compte concernant les performances lors de l'utilisation de Humanizer ?

Bien que Humanizer soit conçu pour être efficace, les développeurs doivent considérer l'impact des opérations fréquentes d'humanisation dans les applications nécessitant de hautes performances avec de grands ensembles de données ou un traitement en temps réel.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Démarrer l'essai gratuit