Humanizer ist eine leistungsstarke und flexible .NET-Bibliothek, die den Umgang mit Daten vereinfacht und menschlicher gestaltet, insbesondere wenn es darum geht, Informationen in einem benutzerfreundlichen Format anzuzeigen. Ob Sie Daten in relative Zeitstrings ("vor 3 Tagen") umwandeln, Wörter pluralisieren, Zahlen als Wörter formatieren oder mit Enums arbeiten, Strings anzeigen, Pascal-Case-Eingabestrings als Sätze mit benutzerdefinierten Beschreibungen, unterstrichene Eingabestrings in normale Titel-Case-Strings umwandeln und langen Text kürzen möchten, bietet Humanizer eine Fülle von Werkzeugen und Erweiterungsmethoden, um diese Aufgaben elegant in C#.NET zu bewältigen, um entmenschlichte Eingabestrings in Sätze umzuwandeln.
In diesem Artikel werden wir ein detailliertes Tutorial zu Humanizer in C# besprechen. Wir werden auch darüber sprechen, wie man PDF-Dokumente mit Humanizer und IronPDF für die C#-PDF-Bibliothek erstellt.
Um mit Humanizer zu beginnen, müssen Sie die Bibliothek über NuGet installieren. In Ihrem Projekt können Sie dies über die Package Manager-Konsole mit dem folgenden Befehl tun:
Alternativ, wenn Sie die .NET Core CLI verwenden, können Sie Humanizer mit folgendem Befehl hinzufügen:
Nach der Installation können Sie Humanizer verwenden, indem Sie den entsprechenden Namespace in Ihre C#-Dateien einfügen:
using Humanizer;Imports HumanizerEine der häufigsten Anwendungen von Humanizer ist die Umwandlung von Daten und Zeiten in ein menschenlesbares Format, Zeitspannen, Zahlen und Mengen unter Verwendung der Humanize-Methode. Dies ist besonders nützlich für die Anzeige relativer Zeiten, wie "vor 2 Stunden" oder "in 5 Tagen".
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 ClassDie Erweiterungsmethode von Humanizer verwaltet automatisch unterschiedliche Zeiteinheiten und passt sogar die grammatische Richtigkeit an.
Humanizer kann auch TimeSpan-Objekte humanisieren, was es einfach macht, Dauern in einem lesbaren Format anzuzeigen.
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 bietet mehrere Methoden, um Zahlen in menschlich lesbare Wörter umzurechnen und Ordnungszahlen zu handhaben.
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 macht es einfach, Wörter zwischen ihren Singular- und Pluralformen umzuwandeln, was nützlich ist, um dynamisch lange Texte basierend auf der Menge zu generieren.
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 verarbeitet auch unregelmäßige Pluralisierungen und Singularisierungen, was es für verschiedene Anwendungsfälle robust macht.
Enums werden häufig in C#-Anwendungen verwendet, um eine Reihe benannter Konstanten darzustellen. Humanizer kann Enum-Werte in menschlich lesbare Strings umwandeln.
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 ClassDiese Methode kann besonders nützlich sein, um benutzerfreundliche Labels in Benutzeroberflächen anzuzeigen.
Ein weiteres praktisches Feature von Humanizer ist die Möglichkeit, Byte-Größen zu humanisieren, indem große Byte-Werte in lesbare Formate wie KB, MB oder GB umgerechnet werden.
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 ist nicht auf die grundlegenden Szenarien beschränkt, die oben beschrieben wurden. Es unterstützt eine breite Palette fortschrittlicher Funktionen wie die Truncate-Methode sowie mehrere Sprachen und Erweiterungen.
Humanizer kann auch DateTimeOffset behandeln, was für Anwendungen nützlich ist, die mit Zeitzonen arbeiten.
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 ist effizient konzipiert, aber wie jede Bibliothek hängt seine Leistung davon ab, wie es verwendet wird. Für Anwendungen, die hohe Leistung erfordern, insbesondere solche, die mit großen Datensätzen oder Echtzeitverarbeitung umgehen, ist es wichtig, die Auswirkungen häufiger Humanisierungsoperationen zu berücksichtigen.
IronPDF ist eine umfassende Bibliothek zur PDF-Erstellung und -Bearbeitung for .NET-Anwendungen. Es ermöglicht Entwicklern, PDF-Dateien einfach zu erstellen, zu lesen, zu bearbeiten und Inhalte daraus zu extrahieren. IronPDF ist benutzerfreundlich gestaltet und bietet eine breite Palette an Funktionen, einschließlich der Konvertierung von HTML zu PDF, des Zusammenführens von Dokumenten, des Hinzufügens von Wasserzeichen und vielem mehr. Seine Vielseitigkeit und leistungsstarken Funktionen machen es zu einer ausgezeichneten Wahl für die Handhabung von PDF-Dokumenten in C#-Projekten.
Folgen Sie diesen Schritten, um IronPDF über den NuGet Package Manager zu installieren:
Öffnen Sie Ihr Projekt in Visual Studio:
Öffnen Sie den NuGet -Paketmanager:
Installieren Sie IronPDF:
Durch diese Schritte wird IronPDF installiert und in Ihrem C#-Projekt einsatzbereit, sodass Sie seine leistungsstarken Funktionen zur PDF-Bearbeitung nutzen können.
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 ist eine unverzichtbare Bibliothek für .NET-Entwickler, die Anwendungen erstellen möchten, die Informationen in einem benutzerfreundlichen und menschlich lesbaren Format präsentieren. Sein breites Spektrum an Funktionen, von der Datums- und Zeit-Humanisierung bis zur Zahl- und Enum-Formatierung, machen es zu einem vielseitigen Werkzeug zur Verbesserung der Benutzerfreundlichkeit von Anwendungen. Durch den Einsatz von Humanizer können Entwickler Zeit und Aufwand bei der Implementierung benutzerdefinierter Formatierungslogik sparen und sicherstellen, dass ihre Anwendungen Daten effektiver an Endbenutzer kommunizieren.
Ähnlich bietet IronPDF umfassende Funktionen zur PDF-Erstellung und -Bearbeitung, was es zu einer ausgezeichneten Wahl für die Erstellung und Handhabung von PDF-Dokumenten in C#-Projekten macht. Zusammen können Humanizer und IronPDF die Funktionalität und Präsentation von .NET-Anwendungen erheblich verbessern. Für weitere Informationen zur Lizenzierung von IronPDF lesen Sie bitte die IronPDF-Lizenzinformationen. Um mehr zu erfahren, sehen Sie sich unser Detailliertes Tutorial zur HTML-zu-PDF-Konvertierung an.
Jacob Mellor ist Chief Technology Officer bei Iron Software und ein visionärer Ingenieur, der Pionierarbeit in der C# PDF-Technologie leistet. Als der ursprüngliche Entwickler hinter der Kern-Codebasis von Iron Software hat er die Produktarchitektur des Unternehmens seit seiner Gründung geprägt und es zusammen mit CEO Cameron Rimington in ein Unternehmen mit mehr als 50 Mitarbeitern verwandelt, das die NASA, Tesla und globale Regierungsbehörden beliefert.
IronPDF ist ein Teil der IRONSUITE
10 .NET-API-Produkte für Ihre Bürodokumente
Wenn Ihr PDF wie HTML aussehen soll, schnell.
