Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. .NET Hilfe
  4. Humanizer C#
.NET HILFE

Humanizer C# (Funktionsweise für Entwickler)

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
Aktualisiert:

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.

Einrichten von Humanizer in C#35;

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:

Install-Package Humanizer

Alternativ, wenn Sie die .NET Core CLI verwenden, können Sie Humanizer mit folgendem Befehl hinzufügen:

dotnet add package Humanizer

Nach der Installation können Sie Humanizer verwenden, indem Sie den entsprechenden Namespace in Ihre C#-Dateien einfügen:

using Humanizer;
using Humanizer;
$vbLabelText   $csharpLabel

Datums- und Zeitangaben vermenschlichen

Eine der häufigsten Anwendungen von Humanizer ist die Umwandlung von Daten und Zeiten in menschlich lesbare Formate, Zeitspannen, Zahlen und Mengen mit der Humanize-Methode. Dies ist besonders nützlich, um relative Zeiten anzuzeigen, wie "vor 2 Stunden" oder "in 5 Tagen".

Beispiel: Vermenschlichung der relativen Zeit

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

Die Erweiterungsmethode von Humanizer verwaltet automatisch unterschiedliche Zeiteinheiten und passt sogar die grammatische Richtigkeit an.

Humanizer C# (Wie es für Entwickler funktioniert): Abbildung 1 - Relative Zeit Ausgabe humanisieren

Menschliche Zeitspannen

Humanizer kann auch TimeSpan-Objekte humanisieren, sodass es einfach ist, Zeitdauern in einem lesbaren Format anzuzeigen.

Beispiel: Vermenschlichung von 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);
    }
}
$vbLabelText   $csharpLabel

Humanizer C# (Wie es für Entwickler funktioniert): Abbildung 2 - TimeSpan Ausgabe humanisieren

Arbeiten mit Zahlen

Humanizer bietet mehrere Methoden, um Zahlen in menschlich lesbare Wörter umzurechnen und Ordnungszahlen zu handhaben.

Beispiel: Konvertierung von Zahlen in Wörter

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

Humanizer C# (Wie es für Entwickler funktioniert): Abbildung 3 - Zahl zu Wort Ausgabe

Beispiel: Konvertierung von Zahlen in Ordnungszahlen

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

Humanizer C# (Wie es für Entwickler funktioniert): Abbildung 4 - Zahl zu Ordnungszahl Ausgabe

Pluralisierung und Singularisierung

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.

Beispiel: Pluralisierung und Singularisierung von Wörtern

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

Humanizer verarbeitet auch unregelmäßige Pluralisierungen und Singularisierungen, was es für verschiedene Anwendungsfälle robust macht.

Humanizer C# (Wie es für Entwickler funktioniert): Abbildung 5 - Plural und Singular Ausgabe

Formatierung von Enums

Enums werden häufig in C#-Anwendungen verwendet, um eine Reihe benannter Konstanten darzustellen. Humanizer kann Enum-Werte in menschlich lesbare Strings umwandeln.

Beispiel: Vermenschlichung von 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);
    }
}
$vbLabelText   $csharpLabel

Diese Methode kann besonders nützlich sein, um benutzerfreundliche Labels in Benutzeroberflächen anzuzeigen.

Humanizer C# (Wie es für Entwickler funktioniert): Abbildung 6 - Enum Ausgabe humanisieren

Bytegrößen menschlich machen

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.

Beispiel: Vermenschlichung von Byte-Größen

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

Humanizer C# (Wie es für Entwickler funktioniert): Abbildung 7 - Byte-Größe Ausgabe humanisieren

Erweiterte Szenarien

Humanizer ist nicht auf die grundlegenden Szenarien beschränkt, die oben beschrieben wurden. Es unterstützt eine Vielzahl von erweiterten Funktionen wie die Truncate-Methode sowie mehrere Sprachen und Erweiterungen.

Beispiel: Vermenschlichung von DateTime Offsets

Humanizer kann auch mit DateTimeOffset umgehen, 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);
    }
}
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);
    }
}
$vbLabelText   $csharpLabel

Humanizer C# (Wie es für Entwickler funktioniert): Abbildung 8 - DateTime Offset Ausgabe humanisieren

Erwägungen zur Leistung

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 für C#

IronPDF ist eine umfassende Bibliothek zur PDF-Erstellung und -Bearbeitung für .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.

Installation von IronPDF über NuGet Package Manager

Folgen Sie diesen Schritten, um IronPDF über den NuGet Package Manager zu installieren:

  1. Öffnen Sie Ihr Projekt in Visual Studio:

    • Starten Sie Visual Studio und öffnen Sie Ihr vorhandenes C#-Projekt oder erstellen Sie ein neues.

  2. Öffnen Sie den NuGet-Paketmanager:

    • Klicken Sie mit der rechten Maustaste auf Ihr Projekt im Solution Explorer.
    • Wählen Sie im Kontextmenü "NuGet-Pakete verwalten…" aus.

Humanizer C# (Wie es für Entwickler funktioniert): Abbildung 9 - NuGet Package Manager

  1. Installieren Sie IronPDF:

    • Gehen Sie im NuGet Package Manager zum Tab "Durchsuchen".
    • Suchen Sie nach IronPDF.
    • Wählen Sie das IronPDF-Paket aus den Suchergebnissen.
    • Klicken Sie auf die Schaltfläche "Installieren", um IronPDF zu Ihrem Projekt hinzuzufügen.

Humanizer C# (Wie es für Entwickler funktioniert): Abbildung 10 - IronPDF

Durch diese Schritte wird IronPDF installiert und in Ihrem C#-Projekt einsatzbereit, sodass Sie seine leistungsstarken Funktionen zur PDF-Bearbeitung nutzen können.

C# Humanizer und IronPDF Code Beispiel

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

Humanizer C# (Wie es für Entwickler funktioniert): Abbildung 11 - PDF-Ausgabe

Abschluss

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.

Häufig gestellte Fragen

Was ist der Zweck der Humanizer-Bibliothek in C#?

Die Humanizer-Bibliothek in C# wurde entwickelt, um Daten in benutzerfreundliche Formate zu transformieren, wie z.B. das Umwandeln von Daten in relative Zeitangaben, das Pluralisieren von Wörtern, das Formatieren von Zahlen als Wörter und das Verarbeiten von Enums. Sie hilft Entwicklern, Daten auf eine lesbarere und zugänglichere Weise zu präsentieren.

Wie kann ich einen DateTime in einen relativen Zeitstring in C# umwandeln?

Sie können die Methode Humanize von Humanizer verwenden, um ein DateTime-Objekt in einen relativen Zeitstring wie 'vor 3 Tagen' oder 'in 5 Stunden' umzuwandeln.

Wie installiere ich die Humanizer-Bibliothek in einem C#-Projekt?

Um die Humanizer-Bibliothek in einem C#-Projekt zu installieren, können Sie die NuGet-Paket-Manager-Konsole mit dem Befehl Install-Package Humanizer verwenden oder die .NET Core CLI mit dotnet add package Humanizer nutzen.

Welche Datenumwandlungen sind mit Humanizer möglich?

Humanizer kann mehrere Datenumwandlungen durchführen, wie z.B. das Umwandeln von Pascal Case Strings in Sätze, das Transformieren von unterstrichenen Strings in Titelcase und das Kürzen von langen Texten auf eine bestimmte Länge.

Kann Humanizer bei der Pluralisierung von Wörtern in C# helfen?

Ja, Humanizer bietet Methoden zur Pluralisierung und Singularisierung von Wörtern, die sowohl reguläre als auch unregelmäßige Formen effektiv handhaben, wie z.B. das Umwandeln von 'car' in 'cars' oder 'people' in 'person'.

Wie verarbeitet Humanizer Enums in C#?

Humanizer kann Enum-Werte in menschenlesbare Strings umwandeln, wodurch es einfacher wird, benutzerfreundliche Beschriftungen in Schnittstellen anzuzeigen.

Welche Funktionen bietet eine C# PDF-Bibliothek?

Eine C# PDF-Bibliothek wie IronPDF bietet Funktionen wie das Erstellen, Lesen, Bearbeiten und Extrahieren von Inhalten aus PDF-Dateien. Sie kann auch HTML in PDF konvertieren, Dokumente zusammenführen und Wasserzeichen hinzufügen.

Wie installiere ich eine C# PDF-Bibliothek in meinem Projekt?

Um eine C# PDF-Bibliothek zu installieren, können Sie den NuGet Package Manager verwenden, indem Sie im 'Browse'-Tab nach dem Bibliotheksnamen, wie IronPDF, suchen und auf 'Installieren' klicken.

Welche Vorteile hat die Kombination von Humanizer mit einer PDF-Bibliothek in C#?

Durch die Kombination von Humanizer mit einer PDF-Bibliothek wie IronPDF können Entwickler menschenlesbare Inhalte mit Humanizer generieren und sie dann in ein PDF-Dokument rendern, was die Erstellung benutzerfreundlicher PDF-Berichte und -Dokumentationen erleichtert.

Was sollte ich in Bezug auf die Leistung beachten, wenn ich Humanizer verwende?

Obwohl Humanizer effizient ausgelegt ist, sollten Entwickler den Einfluss häufiger Humanisierungsoperationen in Anwendungen berücksichtigen, die eine hohe Leistung mit großen Datenmengen oder Echtzeitverarbeitung erfordern.

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
  Jetzt mit dem Ingenieurteam chatten
Chief Technology Officer

Jacob Mellor ist Chief Technology Officer bei Iron Software und ein visionärer Ingenieur, der führend in der C# PDF-Technologie ist. Als ursprünglicher Entwickler der Iron Software-Kerncodebasis hat er die Produktarchitektur des Unternehmens seit seiner Gründung gestaltet und zusammen mit CEO Cameron Rimington in ein Unternehmen ...

Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Gratis testen