Humanizer
v3.0.0-beta.54
HumanizerHumanizer erfüllt alle Ihre .NET -Anforderungen zum Manipulieren und Anzeigen von Strings, Enum, Datteln, Zeiten, Zeitspanen, Zahlen und Mengen.
Sie können Humanizer als Nuget -Paket installieren:
Nur Englisch : Humanizer.Core
Alle Sprachen: Humanizer
Die folgenden Frameworks werden unterstützt: net4.8, net6, net7 und net8
Hinweis: Der Nuget zielt auch auf NetSpandard2 ab. Dies soll ein Szenario aktivieren, in dem NetSpandard2 erforderlich ist. Zum Beispiel Roslyn -Analysatoren oder MSBuild -Aufgaben. Andere Frameworks (außer oben aufgeführt), die NetSpandard2 (Beispiel Net4.6.1 bis Net 4.7.2) konsumieren können, werden nicht unterstützt. Zum Beispiel werden Net4.6.1 bis Net4.7.2 nicht unterstützt.
Außerdem werden Humanizer -Symbole mit Sourcelink indexiert und im Paket enthalten, sodass Sie Humanizer Code durchlaufen können, während Sie Ihren Code debuggen.
Sie wählen die Pakete basierend auf welchen NUGET -Paket (en), die Sie installieren. Standardmäßig installiert das Hauptpaket Humanizer 2.0 alle unterstützten Sprachen genau wie in 1.x. Wenn Sie sich nicht sicher sind, verwenden Sie einfach das Hauptpaket Humanizer .
Hier sind die Optionen:
Humanizer . Dies zieht Humanizer.Core und alle Sprachpakete an.Humanizer.Core -Paket. Nur die englischsprachigen Ressourcen sind verfügbar seinHumanizer.Core.fr . Sie können mehrere Sprachen einfügen, indem Sie so viele Sprachpakete installieren, die Sie möchten.Die detaillierte Erklärung dafür, wie dies funktioniert, finden Sie in den Kommentaren hier.
Humanize Streichererweiterungen können Sie eine ansonsten computergestützte Zeichenfolge in eine lesbarer menschenfreundlichere verwandeln. Die Grundlage davon wurde im BDDFY -Framework eingestellt, in dem Klassennamen, Methodamen und Eigenschaften in menschlich lesbare Sätze verwandelt werden.
"PascalCaseInputStringIsTurnedIntoSentence" . Humanize ( ) => "Pascal case input string is turned into sentence"
"Underscored_input_string_is_turned_into_sentence" . Humanize ( ) => "Underscored input string is turned into sentence"
"Underscored_input_String_is_turned_INTO_sentence" . Humanize ( ) => "Underscored input String is turned INTO sentence" Beachten Sie, dass eine Zeichenfolge, die nur obere Fallbuchstaben enthält und nur aus einem Wort besteht, immer als Akronym behandelt wird (unabhängig von seiner Länge). Um sicherzustellen, dass eine beliebige Zeichenfolge immer humanisiert wird, müssen Sie eine Transformation verwenden (siehe Transform Methode unten):
// acronyms are left intact
"HTML" . Humanize ( ) => "HTML "
// any unbroken upper case string is treated as an acronym
" HUMANIZER" . Humanize ( ) => "HUMANIZER"
"HUMANIZER" . Transform ( To . LowerCase , To . TitleCase ) => "Humanizer"Sie können auch das gewünschte Buchstabengehäuse angeben:
"CanReturnTitleCase" . Humanize ( LetterCasing . Title ) => "Can Return Title Case "
" Can_return_title_Case" . Humanize ( LetterCasing . Title ) => "Can Return Title Case"
"CanReturnLowerCase" . Humanize ( LetterCasing . LowerCase ) => "can return lower case"
"CanHumanizeIntoUpperCase" . Humanize ( LetterCasing . AllCaps ) => "CAN HUMANIZE INTO UPPER CASE"Die
LetterCasing-API und die Methoden, die sie akzeptieren, sind das Vermächtnis aus der Zeit v0.2 und werden in Zukunft veraltet sein. Anstelle davon können Sie die unten erläuterteTransform-Methode verwenden.
Ähnlich wie Sie eine computerfreundliche in menschlichen freundlichen Saite humanisieren können, können Sie eine menschliche freundliche Saite zu einem computerfreundlichen entmenschlichen:
"Pascal case input string is turned into sentence" . Dehumanize ( ) => "PascalCaseInputStringIsTurnedIntoSentence" Es gibt eine Transform , die Überlastungen, LetterCasing annehmen, die LetterCasing ersetzt, ApplyCase und Humanize . Die Signatur der Transformationsmethode ist wie folgt:
string Transform ( this string input , params IStringTransformer [ ] transformers ) Und es gibt einige aus dem Kastenimplementierungen von IStringTransformer für das Buchstabengehäuse:
"Sentence casing" . Transform ( To . LowerCase ) => "sentence casing "
" Sentence casing ".Transform(To.SentenceCase) => " Sentence casing "
"Sentence casing" . Transform ( To . TitleCase ) => "Sentence Casing"
"Sentence casing" . Transform ( To . UpperCase ) => "SENTENCE CASING" LowerCase ist ein öffentliches statisches Eigentum To Klasse, das eine Instanz privater ToLowerCase -Klasse zurückgibt, die IStringTransformer implementiert und weiß, wie man eine Zeichenfolge in einen niedrigeren Fall verwandelt.
Der Vorteil der Verwendung Transform und IStringTransformer Over ApplyCase und LetterCasing besteht darin, dass LetterCasing ein Enum ist und Sie beschränkt sind, was sich im Framework befindet, während IStringTransformer eine Schnittstelle ist, die Sie einmal in Ihrem Codebasis implementieren können, und sie mit Transform verwenden können, um eine einfache Erweiterung zu ermöglichen.
Sie können eine string mit der Truncate -Methode abschneiden:
"Long text to truncate" . Truncate ( 10 ) => "Long text…" Standardmäßig wird das Zeichen '…' verwendet, um Saiten abzuschneiden. Der Vorteil der Verwendung des Zeichens '…' anstelle von "..." besteht darin, dass der erstere nur ein einzelnes Zeichen nimmt und somit mehr Text vor der Kürzung angezeigt wird. Wenn Sie möchten, können Sie auch Ihre eigene Kürzungszeichenfolge angeben:
"Long text to truncate" . Truncate ( 10 , "---" ) => "Long te -- - " Die Standard -Truncationsstrategie, Truncator.FixedLength , besteht darin, die Eingangszeichenfolge auf eine bestimmte Länge einschließlich der Länge der Kürzungszeichenfolge abzuschneiden. Es gibt zwei weitere Strategien für Truncator-Strategien: eine für eine feste Anzahl von (alpha-numerischen) Zeichen und eine für eine feste Anzahl von Wörtern. Um einen bestimmten Kürzer beim Abschneiden zu verwenden, haben die beiden in den vorherigen Beispielen gezeigten Truncate eine Überlastung, mit der Sie die ITruncator -Instanz für die Kürzung angeben können. Hier finden Sie Beispiele zur Verwendung der drei bereitgestellten Kürzer:
"Long text to truncate" . Truncate ( 10 , Truncator . FixedLength ) => "Long text…"
"Long text to truncate" . Truncate ( 10 , "---" , Truncator . FixedLength ) => "Long te---"
"Long text to truncate" . Truncate ( 6 , Truncator . FixedNumberOfCharacters ) => "Long t…"
"Long text to truncate" . Truncate ( 6 , "---" , Truncator . FixedNumberOfCharacters ) => "Lon---"
"Long text to truncate" . Truncate ( 2 , Truncator . FixedNumberOfWords ) => "Long text…"
"Long text to truncate" . Truncate ( 2 , "---" , Truncator . FixedNumberOfWords ) => "Long text---" Beachten Sie, dass Sie auch Ihren eigenen Truncator erstellen können, indem Sie die ITruncator -Schnittstelle implementieren.
Es gibt auch die Option zu wählen, ob die Zeichenfolge von Anfang an ( TruncateFrom.Left ) oder das Ende ( TruncateFrom.Right ) abgeschnitten werden soll. Standard ist das Recht, wie in den obigen Beispielen gezeigt. Die folgenden Beispiele zeigen, wie man vom Beginn der Zeichenfolge abschneidet:
"Long text to truncate" . Truncate ( 10 , Truncator . FixedLength , TruncateFrom . Left ) => "… truncate"
"Long text to truncate" . Truncate ( 10 , "---" , Truncator . FixedLength , TruncateFrom . Left ) => "---runcate"
"Long text to truncate" . Truncate ( 10 , Truncator . FixedNumberOfCharacters , TruncateFrom . Left ) => "…o truncate"
"Long text to truncate" . Truncate ( 16 , "---" , Truncator . FixedNumberOfCharacters , TruncateFrom . Left ) => "---ext to truncate"
"Long text to truncate" . Truncate ( 2 , Truncator . FixedNumberOfWords , TruncateFrom . Left ) => "…to truncate"
"Long text to truncate" . Truncate ( 2 , "---" , Truncator . FixedNumberOfWords , TruncateFrom . Left ) => "---to truncate" Das Aufrufen ToString direkt auf Enum -Mitgliedern führt normalerweise zu einer idealen Ausgabe für Benutzer. Die Lösung hierfür besteht normalerweise darin, die Annotation DescriptionAttribute -Daten zu verwenden und dann zu lesen, um eine freundlichere Ausgabe zu erhalten. Das ist eine großartige Lösung; Aber meistens müssen wir nur einen Platz zwischen den Worten eines Enum -Mitglieds einstellen - was String.Humanize() gut macht. Für einen Aufzähler wie:
public enum EnumUnderTest
{
[ Description ( "Custom description" ) ]
MemberWithDescriptionAttribute ,
MemberWithoutDescriptionAttribute ,
ALLCAPITALS
}Sie werden:
// DescriptionAttribute is honored
EnumUnderTest . MemberWithDescriptionAttribute . Humanize ( ) => "Custom description"
// In the absence of Description attribute string.Humanizer kicks in
EnumUnderTest . MemberWithoutDescriptionAttribute . Humanize ( ) => "Member without description attribute"
// Of course you can still apply letter casing
EnumUnderTest . MemberWithoutDescriptionAttribute . Humanize ( ) . Transform ( To . TitleCase ) => "Member Without Description Attribute" Sie sind nicht auf DescriptionAttribute für benutzerdefinierte Beschreibung beschränkt. Jedes Attribut, das auf Enum -Mitglieder mit einer string Description des Eigenschaft angewendet wird, zählt. Dies soll bei Plattformen mit fehlender DescriptionAttribute und Auch bei der Ermöglichung von Unterklassen der DescriptionAttribute helfen.
Sie können sogar den Namen der Eigenschaft von Attibute als Beschreibung konfigurieren.
Configurator.EnumDescriptionPropertyLocator = p => p.Name == "Info"
Wenn Sie lokalisierte Beschreibungen angeben müssen, können Sie stattdessen die Annotation von DisplayAttribute verwenden.
public enum EnumUnderTest
{
[ Display ( Description = "EnumUnderTest_Member" , ResourceType = typeof ( Project . Resources ) ) ]
Member
}Sie werden:
EnumUnderTest . Member . Humanize ( ) => "content" // from Project.Resources found under "EnumUnderTest_Member" resource keyHoffentlich hilft dies zu vermeiden, dass Überleuchtung mit unnötigen Attributen zu vermeiden ist!
Entmenschlicht eine Schnur in die Aufzählung, aus der sie ursprünglich humanisiert wurde! Die API sieht aus:
public static TTargetEnum DehumanizeTo < TTargetEnum > ( this string input )Und die Verwendung ist:
"Member without description attribute" . DehumanizeTo < EnumUnderTest > ( ) => EnumUnderTest . MemberWithoutDescriptionAttribute Und genau wie die humanisierte API ehrt es das Description . Sie müssen nicht das Gehäuse bereitstellen, das Sie während der Humanisierung zur Verfügung gestellt haben: Es findet es heraus.
Es gibt auch ein nicht generisches Gegenstück, wenn der ursprüngliche Enum zur Kompilierung nicht bekannt ist:
public static Enum DehumanizeTo ( this string input , Type targetEnum , NoMatch onNoMatch = NoMatch . ThrowsException )die verwendet werden können wie:
"Member without description attribute" . DehumanizeTo ( typeof ( EnumUnderTest ) ) => EnumUnderTest . MemberWithoutDescriptionAttribute Standardmäßig werfen beide Methoden eine NoMatchFoundException aus, wenn sie nicht mit der bereitgestellten Eingabe gegen die Zielumum übereinstimmen können. In der nicht generischen Methode können Sie die Methode auch bitten, NULL zurückzugeben, indem Sie den zweiten optionalen Parameter auf NoMatch.ReturnsNull einstellen.
Sie können eine Instanz von DateTime oder DateTimeOffset Humanize und eine Zeichenfolge zurückerhalten, die in der Zeit zurück oder weiterleitet, das heißt:
DateTime . UtcNow . AddHours ( - 30 ) . Humanize ( ) => "yesterday"
DateTime . UtcNow . AddHours ( - 2 ) . Humanize ( ) => "2 hours ago"
DateTime . UtcNow . AddHours ( 30 ) . Humanize ( ) => "tomorrow"
DateTime . UtcNow . AddHours ( 2 ) . Humanize ( ) => "2 hours from now"
DateTimeOffset . UtcNow . AddHours ( 1 ) . Humanize ( ) => "an hour from now" Humanizer unterstützt sowohl lokale als auch UTC -Daten sowie Daten mit Offset ( DateTimeOffset ). Sie können auch das Datum angeben, mit dem das Eingabedatum verglichen werden soll. Wenn NULL, wird das aktuelle Datum als Vergleichsbasis verwendet. Außerdem kann die Verwendung von Kultur explizit angegeben werden. Wenn dies nicht der Fall ist, wird die aktuelle UI -Kultur des aktuellen Threads verwendet. Hier ist die API -Signatur:
public static string Humanize ( this DateTime input , bool utcDate = true , DateTime ? dateToCompareAgainst = null , CultureInfo culture = null )
public static string Humanize ( this DateTimeOffset input , DateTimeOffset ? dateToCompareAgainst = null , CultureInfo culture = null )Für diese Methode stehen viele Lokalisierungen zur Verfügung. Hier sind einige Beispiele:
// In ar culture
DateTime . UtcNow . AddDays ( - 1 ) . Humanize ( ) => "أمس"
DateTime . UtcNow . AddDays ( - 2 ) . Humanize ( ) => "منذ يومين"
DateTime . UtcNow . AddDays ( - 3 ) . Humanize ( ) => "منذ 3 أيام"
DateTime . UtcNow . AddDays ( - 11 ) . Humanize ( ) => "منذ 11 يوم"
// In ru-RU culture
DateTime . UtcNow . AddMinutes ( - 1 ) . Humanize ( ) => "минуту назад"
DateTime . UtcNow . AddMinutes ( - 2 ) . Humanize ( ) => "2 минуты назад"
DateTime . UtcNow . AddMinutes ( - 10 ) . Humanize ( ) => "10 минут назад"
DateTime . UtcNow . AddMinutes ( - 21 ) . Humanize ( ) => "21 минуту назад"
DateTime . UtcNow . AddMinutes ( - 22 ) . Humanize ( ) => "22 минуты назад"
DateTime . UtcNow . AddMinutes ( - 40 ) . Humanize ( ) => "40 минут назад" Es gibt zwei Strategien für DateTime.Humanize . Um die präzisionsbasierte Strategie zu verwenden, müssen Sie sie konfigurieren:
Configurator . DateTimeHumanizeStrategy = new PrecisionDateTimeHumanizeStrategy ( precision : .75 ) ;
Configurator . DateTimeOffsetHumanizeStrategy = new PrecisionDateTimeOffsetHumanizeStrategy ( precision : .75 ) ; // configure when humanizing DateTimeOffsetDie Standardgenauigkeit ist auf 0,75 gesetzt, aber Sie können auch Ihre gewünschte Präzision übergeben. Mit Präzision auf 0,75 eingestellt:
44 seconds => 44 seconds ago / from now
45 seconds => one minute ago / from now
104 seconds => one minute ago / from now
105 seconds => two minutes ago / from now
25 days => a month ago / from now Keine Entmenschlichung für Daten als Humanize ist eine verletzte Transformation und das menschliche freundliche Datum ist nicht reversibel
Sie können Humanize auf einer TimeSpan anrufen, um eine menschliche freundliche Darstellung dafür zu erhalten:
TimeSpan . FromMilliseconds ( 1 ) . Humanize ( ) => "1 millisecond"
TimeSpan . FromMilliseconds ( 2 ) . Humanize ( ) => "2 milliseconds"
TimeSpan . FromDays ( 1 ) . Humanize ( ) => "1 day"
TimeSpan . FromDays ( 16 ) . Humanize ( ) => "2 weeks" Es gibt einen optionalen precision für TimeSpan.Humanize . Der Standardwert der precision beträgt 1, was bedeutet, dass nur die größte Zeiteinheit zurückgegeben wird, wie Sie es in TimeSpan.FromDays(16).Humanize() . Hier sind einige Beispiele für die Angabe von Präzision:
TimeSpan . FromDays ( 1 ) . Humanize ( precision : 2 ) => "1 day" // no difference when there is only one unit in the provided TimeSpan
TimeSpan . FromDays ( 16 ) . Humanize ( 2 ) => "2 weeks, 2 days"
// the same TimeSpan value with different precision returns different results
TimeSpan . FromMilliseconds ( 1299630020 ) . Humanize ( ) => "2 weeks"
TimeSpan . FromMilliseconds ( 1299630020 ) . Humanize ( 3 ) => "2 weeks, 1 day, 1 hour"
TimeSpan . FromMilliseconds ( 1299630020 ) . Humanize ( 4 ) => "2 weeks, 1 day, 1 hour, 30 seconds"
TimeSpan . FromMilliseconds ( 1299630020 ) . Humanize ( 5 ) => "2 weeks, 1 day, 1 hour, 30 seconds, 20 milliseconds" Bei standardmäßiger Verwendung precision werden leere Zeiteinheiten nicht auf die Genauigkeit des zurückgegebenen Werts gezählt. Wenn dieses Verhalten für Sie nicht erwünscht ist, können Sie die überlastete TimeSpan.Humanize verwenden. Humanisieren Sie die Methode mit dem Parameter countEmptyUnits . Die Führung leerer Zeiteinheiten zählt nie. Hier ist ein Beispiel, das den Unterschied zum Zählen leerer Einheiten zeigt:
TimeSpan . FromMilliseconds ( 3603001 ) . Humanize ( 3 ) => "1 hour, 3 seconds, 1 millisecond"
TimeSpan . FromMilliseconds ( 3603001 ) . Humanize ( 3 , countEmptyUnits : true ) => "1 hour, 3 seconds"Für diese Methode stehen viele Lokalisierungen zur Verfügung:
// in de-DE culture
TimeSpan . FromDays ( 1 ) . Humanize ( ) => "Ein Tag"
TimeSpan . FromDays ( 2 ) . Humanize ( ) => "2 Tage"
// in sk-SK culture
TimeSpan . FromMilliseconds ( 1 ) . Humanize ( ) => "1 milisekunda"
TimeSpan . FromMilliseconds ( 2 ) . Humanize ( ) => "2 milisekundy"
TimeSpan . FromMilliseconds ( 5 ) . Humanize ( ) => "5 milisekúnd"Die zu verwendende Kultur kann explizit angegeben werden. Wenn dies nicht der Fall ist, wird die aktuelle UI -Kultur des aktuellen Threads verwendet. Beispiel:
TimeSpan . FromDays ( 1 ) . Humanize ( culture : "ru-RU" ) => "один день"Darüber hinaus kann eine minimale Zeiteinheit angegeben werden, um zu vermeiden, dass das Rollen in ein kleineres Gerät zurückgeführt wird. Zum Beispiel:
TimeSpan . FromMilliseconds ( 122500 ) . Humanize ( minUnit : TimeUnit . Second ) => "2 minutes, 2 seconds" // instead of 2 minutes, 2 seconds, 500 milliseconds
TimeSpan . FromHours ( 25 ) . Humanize ( minUnit : TimeUnit . Day ) => "1 Day" //instead of 1 Day, 1 HourDarüber hinaus kann eine maximale Zeiteinheit angegeben werden, um zu vermeiden, dass das nächstgrößte Gerät rollt. Zum Beispiel:
TimeSpan . FromDays ( 7 ) . Humanize ( maxUnit : TimeUnit . Day ) => "7 days" // instead of 1 week
TimeSpan . FromMilliseconds ( 2000 ) . Humanize ( maxUnit : TimeUnit . Millisecond ) => "2000 milliseconds" // instead of 2 seconds Das Standard -Maxunit ist TimeUnit.Week , da er genaue Ergebnisse liefert. Sie können diesen Wert auf TimeUnit.Month oder TimeUnit.Year erhöhen. Daher wechseln die Monate zwischen 30 und 31 Tagen in der Länge und jedes vierte Jahr sind 366 Tage lang.
TimeSpan . FromDays ( 486 ) . Humanize ( maxUnit : TimeUnit . Year , precision : 7 ) => "1 year, 3 months, 29 days" // One day further is 1 year, 4 month
TimeSpan . FromDays ( 517 ) . Humanize ( maxUnit : TimeUnit . Year , precision : 7 ) => "1 year, 4 months, 30 days" // This month has 30 days and one day further is 1 year, 5 months Wenn es mehrere Zeiteinheiten gibt, werden sie mit der String ", " String" kombiniert:
TimeSpan . FromMilliseconds ( 1299630020 ) . Humanize ( 3 ) => "2 weeks, 1 day, 1 hour" Wenn TimeSpan Null ist, gibt das Standardverhalten "0" plus, unabhängig von der Mindestzeiteinheit zurück. Wenn Sie jedoch toWords beim Aufrufen Humanize true zuweisen, gibt die Methode "keine Zeit" zurück. Zum Beispiel:
TimeSpan . Zero . Humanize ( 1 ) => "0 milliseconds"
TimeSpan . Zero . Humanize ( 1 , toWords : true ) => "no time"
TimeSpan . Zero . Humanize ( 1 , minUnit : Humanizer . Localisation . TimeUnit . Second ) => "0 seconds" Mit dem Parameter collectionSeparator können Sie Ihre eigene Separatorzeichenfolge angeben:
TimeSpan . FromMilliseconds ( 1299630020 ) . Humanize ( 3 , collectionSeparator : " - " ) => "2 weeks - 1 day - 1 hour" Es ist auch möglich, das Sammelformatierer der aktuellen Kultur zu verwenden, um die Zeiteinheiten zu kombinieren. Geben Sie dazu null als Parameter für den collectionSeparator an:
// in en-US culture
TimeSpan . FromMilliseconds ( 1299630020 ) . Humanize ( 3 , collectionSeparator : null ) => "2 weeks, 1 day, and 1 hour"
// in de-DE culture
TimeSpan . FromMilliseconds ( 1299630020 ) . Humanize ( 3 , collectionSeparator : null ) => "2 Wochen, Ein Tag und Eine Stunde" Wenn Wörter Zahlen bevorzugt werden, kann ein toWords: true Parameter so eingestellt werden, dass die Zahlen in einer humanisierten Zeitspannweite in Wörter umwandeln:
TimeSpan . FromMilliseconds ( 1299630020 ) . Humanize ( 3 , toWords : true ) => "two weeks, one day, one hour" Durch den Anruf von ToAge kann ein TimeSpan auch als Alter ausgedrückt werden. Für Kulturen, die einen Altersausdruck nicht definieren, ist das Ergebnis das gleiche wie das Aufrufen Humanize (jedoch mit einem Standard maxUnit , der der TimeUnit.Year entspricht .
// in en-US culture
TimeSpan . FromDays ( 750 ) . ToAge ( ) => "2 years old"
// in fr culture
TimeSpan . FromDays ( 750 ) . ToAge ( ) => "2 ans" Sie können Humanize auf jedem IEnumerable anrufen, um eine schön formatierte Zeichenfolge zu erhalten, die die Objekte in der Sammlung darstellt. Standardmäßig wird ToString() auf jedes Element aufgerufen, um seine Darstellung zu erhalten, aber stattdessen kann eine Formatierungsfunktion Humanize werden. Zusätzlich wird ein Standardabscheider bereitgestellt ("und" in englischer Sprache), aber ein anderer Separator kann in Humanize übergeben werden.
Zum Beispiel:
class SomeClass
{
public string SomeString ;
public int SomeInt ;
public override string ToString ( )
{
return "Specific String" ;
}
}
string FormatSomeClass ( SomeClass sc )
{
return string . Format ( "SomeObject #{0} - {1}" , sc . SomeInt , sc . SomeString ) ;
}
var collection = new List < SomeClass >
{
new SomeClass { SomeInt = 1 , SomeString = "One" } ,
new SomeClass { SomeInt = 2 , SomeString = "Two" } ,
new SomeClass { SomeInt = 3 , SomeString = "Three" }
} ;
collection . Humanize ( ) // "Specific String, Specific String, and Specific String"
collection . Humanize ( "or" ) // "Specific String, Specific String, or Specific String"
collection . Humanize ( FormatSomeClass ) // "SomeObject #1 - One, SomeObject #2 - Two, and SomeObject #3 - Three"
collection . Humanize ( sc => sc . SomeInt . Ordinalize ( ) , "or" ) // "1st, 2nd, or 3rd"Die Artikel sind beschnitten und leer (Nullorwhitespace) Elemente werden übersprungen. Dies führt zu einer sauberen Interpunktion mit sauberer Komma. (Wenn es eine benutzerdefinierte Formatterfunktion gibt, gilt dies nur für die Ausgabe des Formaters.)
Sie können Ihr eigenes Sammelformatierer bereitstellen, indem Sie ICollectionFormatter implementieren und mit Configurator.CollectionFormatters registrieren.
Es gibt auch einige Inflüssigkeitsmethoden:
Pluralize pluralisiere den bereitgestellten Eingang und berücksichtige unregelmäßige und unzählige Wörter:
"Man" . Pluralize ( ) => "Men "
" string" . Pluralize ( ) => "strings" Normalerweise würden Sie Pluralize auf einem einzigartigen Wort anrufen, aber wenn Sie sich über die Singularität des Wortes nicht sicher sind, können Sie die Methode mit dem optionalen inputIsKnownToBeSingular -Argument aufrufen:
"Men" . Pluralize ( inputIsKnownToBeSingular : false ) => "Men "
" Man" . Pluralize ( inputIsKnownToBeSingular : false ) => "Men"
"string" . Pluralize ( inputIsKnownToBeSingular : false ) => "strings" Die Überlastung von Pluralize mit plurality ist veraltet und wurde in Version 2.0 entfernt.
Singularize Singularisiert den bereitgestellten Input und berücksichtigt unregelmäßige und unzählige Wörter:
"Men" . Singularize ( ) => "Man "
" strings" . Singularize ( ) => "string" Normalerweise nennen Sie Singularize ein Pluralwort, aber wenn Sie sich nicht sicher sind, können Sie die Methode mit dem optionalen Argument inputIsKnownToBePlural die Methode aufrufen:
"Men" . Singularize ( inputIsKnownToBePlural : false ) => "Man "
" Man" . Singularize ( inputIsKnownToBePlural : false ) => "Man"
"strings" . Singularize ( inputIsKnownToBePlural : false ) => "string" Die Überlastung von Singularize mit plurality -Argument ist veraltet und wurde in Version 2.0 entfernt.
Manchmal müssen Sie möglicherweise eine Regel aus dem Vokabular der Singularisation/Pluralisierung hinzufügen (die folgenden Beispiele befinden sich bereits in der von Inflector verwendeten DefaultVocabulary ):
// Adds a word to the vocabulary which cannot easily be pluralized/singularized by RegEx.
// Will match both "salesperson" and "person".
Vocabularies . Default . AddIrregular ( "person" , "people" ) ;
// To only match "person" and not "salesperson" you would pass false for the 'matchEnding' parameter.
Vocabularies . Default . AddIrregular ( "person" , "people" , matchEnding : false ) ;
// Adds an uncountable word to the vocabulary. Will be ignored when plurality is changed:
Vocabularies . Default . AddUncountable ( "fish" ) ;
// Adds a rule to the vocabulary that does not follow trivial rules for pluralization:
Vocabularies . Default . AddPlural ( "bus" , "buses" ) ;
// Adds a rule to the vocabulary that does not follow trivial rules for singularization
// (will match both "vertices" -> "vertex" and "indices" -> "index"):
Vocabularies . Default . AddSingular ( "(vert|ind)ices$" , "$1ex" ) ; Oft möchten Sie Singularize nennen und Pluralize , um ein Wort mit einer Nummer zu präfixen. zB "2 Anfragen", "3 Männer". ToQuantity PREFIXE Das bereitgestellte Wort mit der Nummer und pluralisiert das Wort entsprechend oder singular:
"case" . ToQuantity ( 0 ) => "0 cases"
"case" . ToQuantity ( 1 ) => "1 case"
"case" . ToQuantity ( 5 ) => "5 cases"
"man" . ToQuantity ( 0 ) => "0 men"
"man" . ToQuantity ( 1 ) => "1 man"
"man" . ToQuantity ( 2 ) => "2 men" ToQuantity kann herausfinden, ob das Eingangswort einzigartig oder plural ist und nach Bedarf singularisiert oder pluralisiert:
"men" . ToQuantity ( 2 ) => "2 men"
"process" . ToQuantity ( 2 ) => "2 processes"
"process" . ToQuantity ( 1 ) => "1 process"
"processes" . ToQuantity ( 2 ) => "2 processes"
"processes" . ToQuantity ( 1 ) => "1 process" Sie können auch ein zweites Argument, ShowQuantityAs , an ToQuantity weitergeben, um anzugeben, wie die bereitgestellte Menge ausgegeben werden soll. Der Standardwert ist ShowQuantityAs.Numeric Was wir oben gesehen haben. Die anderen beiden Werte sind ShowQuantityAs.Words und ShowQuantityAs.None .
"case" . ToQuantity ( 5 , ShowQuantityAs . Words ) => "five cases "
" case" . ToQuantity ( 5 , ShowQuantityAs . None ) => "cases"Es gibt auch eine Überladung, mit der Sie die Nummer formatieren können. Sie können im Format und der zu verwendenden Kultur passieren.
"dollar" . ToQuantity ( 2 , "C0" , new CultureInfo ( "en-US" ) ) => "$2 dollars"
"dollar" . ToQuantity ( 2 , "C2" , new CultureInfo ( "en-US" ) ) => "$2.00 dollars"
"cases" . ToQuantity ( 12000 , "N0" ) => "12,000 cases" Ordinalize verwandelt eine Zahl in eine Ordnungszeichenfolge, die verwendet wird, um die Position in einer geordneten Sequenz wie 1., 2., 3., 4. zu bezeichnen:
1 . Ordinalize ( ) => "1st"
5 . Ordinalize ( ) => "5th" Sie können auch Ordinalize auf einer numerischen Zeichenfolge aufrufen und dasselbe Ergebnis erzielen: "21".Ordinalize() => "21st"
Ordinalize unterstützt auch das grammatikalische Geschlecht für beide Formen. Sie können ein Argument zur Ordinalize verabschieden, um anzugeben, in welchem Geschlecht die Zahl ausgeben sollte. Die möglichen Werte sind GrammaticalGender.Masculine GrammaticalGender.Feminine GrammaticalGender.Neuter
// for Brazilian Portuguese locale
1 . Ordinalize ( GrammaticalGender . Masculine ) => "1º"
1 . Ordinalize ( GrammaticalGender . Feminine ) => "1ª"
1 . Ordinalize ( GrammaticalGender . Neuter ) => "1º"
"2" . Ordinalize ( GrammaticalGender . Masculine ) => "2º"
"2" . Ordinalize ( GrammaticalGender . Feminine ) => "2ª"
"2" . Ordinalize ( GrammaticalGender . Neuter ) => "2º"Offensichtlich gilt dies nur für einige Kulturen. Für andere, die das Geschlecht in den Vorgehen oder gar nicht übergeben haben, macht das Ergebnis keinen Unterschied.
Darüber hinaus unterstützt Ordinalize Variationen, die einige Kulturen je nach Position der ordinalisierten Zahl in einem Satz anwenden. Verwenden Sie die Argument wordForm um das eine oder andere Ergebnis zu erhalten. Mögliche Werte sind WordForm.Abbreviation WordForm.Normal Sie können wordForm mit dem Geschlecht kombinieren, aber dieses Argument übergeben, wenn es nicht zutreffend ist, macht keinen Unterschied im Ergebnis.
// Spanish locale
1 . Ordinalize ( WordForm . Abbreviation ) => "1.er" // As in "Vivo en el 1.er piso"
1 . Ordinalize ( WordForm . Normal ) => "1.º" // As in "He llegado el 1º"
"3" . Ordinalize ( GrammaticalGender . Feminine , WordForm . Abbreviation ) => "3.ª"
"3" . Ordinalize ( GrammaticalGender . Feminine , WordForm . Normal ) => "3.ª"
"3" . Ordinalize ( GrammaticalGender . Masculine , WordForm . Abbreviation ) => "3.er"
"3" . Ordinalize ( GrammaticalGender . Masculine , WordForm . Normal ) => "3.º" Titleize konvertiert die Eingangswörter in das Titelgehäuse. Äquivalent zu "some title".Humanize(LetterCasing.Title)
Pascalize konvertiert die Eingangswörter in Uppercamelcase und entfernen auch Unterstriche und Räume:
"some_title for something" . Pascalize ( ) => "SomeTitleForSomething" Camelize verhält sich identisch mit Pascalize , außer dass der erste Charakter niedrigerer Fall ist:
"some_title for something" . Camelize ( ) => "someTitleForSomething" Underscore trennt die Eingangswörter mit Unterstrich:
"SomeTitle" . Underscore ( ) => "some_title" Dasherize und Hyphenate ersetzen Unterstriche durch Striche in der Zeichenfolge:
"some_title" . Dasherize ( ) => "some-title"
"some_title" . Hyphenate ( ) => "some-title" Kebaberize trennt die Eingangswörter mit Bindestrichen und alle Wörter werden in Kleinbuchstaben umgewandelt
"SomeText" . Kebaberize ( ) => "some-text" Humanizer bietet eine fließende API, die sich wie folgt mit DateTime und TimeSpan befasst:
TimeSpan :
2 . Milliseconds ( ) => TimeSpan . FromMilliseconds ( 2 )
2 . Seconds ( ) => TimeSpan . FromSeconds ( 2 )
2 . Minutes ( ) => TimeSpan . FromMinutes ( 2 )
2 . Hours ( ) => TimeSpan . FromHours ( 2 )
2 . Days ( ) => TimeSpan . FromDays ( 2 )
2 . Weeks ( ) => TimeSpan . FromDays ( 14 )Es gibt keine fließenden APIs für Monat oder Jahr, da ein Monat zwischen 28 und 31 Tagen und ein Jahr 365 oder 366 Tage betragen könnte.
Sie können diese Methoden verwenden, um beispielsweise zu ersetzen
DateTime . Now . AddDays ( 2 ) . AddHours ( 3 ) . AddMinutes ( - 5 )mit
DateTime . Now + 2 . Days ( ) + 3 . Hours ( ) - 5 . Minutes ( ) Es gibt auch drei Kategorien fließender Methoden, um mit DateTime umzugehen:
In . TheYear ( 2010 ) // Returns the first of January of 2010
In . January // Returns 1st of January of the current year
In . FebruaryOf ( 2009 ) // Returns 1st of February of 2009
In . One . Second // DateTime.UtcNow.AddSeconds(1);
In . Two . SecondsFrom ( DateTime dateTime )
In . Three . Minutes // With corresponding From method
In . Three . Hours // With corresponding From method
In . Three . Days // With corresponding From method
In . Three . Weeks // With corresponding From method
In . Three . Months // With corresponding From method
In . Three . Years // With corresponding From method
On . January . The4th // Returns 4th of January of the current year
On . February . The ( 12 ) // Returns 12th of Feb of the current yearund einige Erweiterungsmethoden:
var someDateTime = new DateTime ( 2011 , 2 , 10 , 5 , 25 , 45 , 125 ) ;
// Returns new DateTime(2008, 2, 10, 5, 25, 45, 125) changing the year to 2008
someDateTime . In ( 2008 )
// Returns new DateTime(2011, 2, 10, 2, 25, 45, 125) changing the hour to 2:25:45.125
someDateTime . At ( 2 )
// Returns new DateTime(2011, 2, 10, 2, 20, 15, 125) changing the time to 2:20:15.125
someDateTime . At ( 2 , 20 , 15 )
// Returns new DateTime(2011, 2, 10, 12, 0, 0) changing the time to 12:00:00.000
someDateTime . AtNoon ( )
// Returns new DateTime(2011, 2, 10, 0, 0, 0) changing the time to 00:00:00.000
someDateTime . AtMidnight ( ) Offensichtlich könnten Sie auch die Methoden anketten; EG On.November.The13th.In(2010).AtNoon + 5.Minutes()
Humanizer bietet eine fließende API, die (normalerweise große) Zahlen klarer erzeugt:
1.25 . Billions ( ) => 1250000000
3 . Hundreds ( ) . Thousands ( ) => 300000 Humanizer kann Zahlen in Wörtern mithilfe der ToWords -Erweiterung ändern:
1 . ToWords ( ) => "one"
10 . ToWords ( ) => "ten"
11 . ToWords ( ) => "eleven"
122 . ToWords ( ) => "one hundred and twenty-two"
3501 . ToWords ( ) => "three thousand five hundred and one" Sie können auch ein zweites Argument, GrammaticalGender GrammaticalGender.Masculine an ToWords weitergeben, GrammaticalGender.Feminine festzulegen GrammaticalGender.Neuter in welchem Geschlecht die Zahl ausgeben sollte.
// for Russian locale
1 . ToWords ( GrammaticalGender . Masculine ) => "один"
1 . ToWords ( GrammaticalGender . Feminine ) => "одна"
1 . ToWords ( GrammaticalGender . Neuter ) => "одно" // for Arabic locale
1 . ToWords ( GrammaticalGender . Masculine ) => "واحد"
1 . ToWords ( GrammaticalGender . Feminine ) => "واحدة"
1 . ToWords ( GrammaticalGender . Neuter ) => "واحد"
( - 1 ) . ToWords ( ) => "ناقص واحد"Offensichtlich gilt dies nur für einige Kulturen. Für andere macht das Geschlecht keinen Unterschied im Ergebnis.
Außerdem kann die Verwendung von Kultur explizit angegeben werden. Wenn dies nicht der Fall ist, wird die aktuelle UI -Kultur des aktuellen Threads verwendet. Hier ist ein Beispiel:
11 . ToWords ( new CultureInfo ( "en" ) ) => "eleven"
1 . ToWords ( GrammaticalGender . Masculine , new CultureInfo ( "ru" ) ) => "один"Eine weitere Überladung der Methode ermöglicht es Ihnen, ein Bool zu übergeben, um das "und" vor der letzten Nummer hinzugefügt werden zu können:
3501 . ToWords ( false ) => "three thousand five hundred one"
102 . ToWords ( false ) => "one hundred two"Diese Methode kann zum Beispiel zum Schreiben von Schecks nützlich sein.
Darüber hinaus unterstützt ToWords Variationen, die einige Kulturen je nach Position der Anzahl in einem Satz anwenden. Verwenden Sie die Argument wordForm um das eine oder andere Ergebnis zu erhalten. Mögliche Werte sind WordForm.Abbreviation WordForm.Normal Dieses Argument kann mit dem Rest der oben dargestellten Argumente kombiniert werden. Das Übergeben von wordForm in Wenn es nicht anwendbar ist, macht das Ergebnis keinen Unterschied.
// Spanish locale
21501 . ToWords ( WordForm . Abbreviation , GrammaticalGender . Masculine ) => "veintiún mil quinientos un"
21501 . ToWords ( WordForm . Normal , GrammaticalGender . Masculine ) => "veintiún mil quinientos uno"
21501 . ToWords ( WordForm . Abbreviation , GrammaticalGender . Feminine ) => "veintiuna mil quinientas una"
// English US locale
21501 . ToWords ( WordForm . Abbreviation , GrammaticalGender . Masculine , new CultureInfo ( "en-US" ) ) => "twenty-one thousand five hundred and one" Dies ist eine Art ToWords mit Ordinalize . Sie können ToOrdinalWords auf einer Nummer anrufen, um eine ordinale Darstellung der Nummer in Wörtern zu erhalten! Zum Beispiel:
0 . ToOrdinalWords ( ) => "zeroth"
1 . ToOrdinalWords ( ) => "first"
2 . ToOrdinalWords ( ) => "second"
8 . ToOrdinalWords ( ) => "eighth"
10 . ToOrdinalWords ( ) => "tenth"
11 . ToOrdinalWords ( ) => "eleventh"
12 . ToOrdinalWords ( ) => "twelfth"
20 . ToOrdinalWords ( ) => "twentieth"
21 . ToOrdinalWords ( ) => "twenty first"
121 . ToOrdinalWords ( ) => "hundred and twenty first" ToOrdinalWords unterstützt auch das grammatikalische Geschlecht. Sie können ein zweites Argument an ToOrdinalWords weitergeben, um das Geschlecht der Ausgabe anzugeben. Die GrammaticalGender.Neuter Werte sind GrammaticalGender.Masculine GrammaticalGender.Feminine
// for Brazilian Portuguese locale
1 . ToOrdinalWords ( GrammaticalGender . Masculine ) => "primeiro"
1 . ToOrdinalWords ( GrammaticalGender . Feminine ) => "primeira"
1 . ToOrdinalWords ( GrammaticalGender . Neuter ) => "primeiro"
2 . ToOrdinalWords ( GrammaticalGender . Masculine ) => "segundo"
2 . ToOrdinalWords ( GrammaticalGender . Feminine ) => "segunda"
2 . ToOrdinalWords ( GrammaticalGender . Neuter ) => "segundo" // for Arabic locale
1 . ToOrdinalWords ( GrammaticalGender . Masculine ) => "الأول"
1 . ToOrdinalWords ( GrammaticalGender . Feminine ) => "الأولى"
1 . ToOrdinalWords ( GrammaticalGender . Neuter ) => "الأول"
2 . ToOrdinalWords ( GrammaticalGender . Masculine ) => "الثاني"
2 . ToOrdinalWords ( GrammaticalGender . Feminine ) => "الثانية"
2 . ToOrdinalWords ( GrammaticalGender . Neuter ) => "الثاني"Offensichtlich gilt dies nur für einige Kulturen. Für andere macht das Geschlecht keinen Unterschied im Ergebnis.
Außerdem kann die Verwendung von Kultur explizit angegeben werden. Wenn dies nicht der Fall ist, wird die aktuelle UI -Kultur des aktuellen Threads verwendet. Hier ist ein Beispiel:
10 . ToOrdinalWords ( new CultureInfo ( "en-US" ) ) => "tenth"
1 . ToOrdinalWords ( GrammaticalGender . Masculine , new CulureInfo ( "pt-BR" ) ) => "primeiro" ToOrdinalWords unterstützt auch Variationen, die einige Kulturen je nach Position der ordinalisierten Zahl in einem Satz anwenden. Verwenden Sie die Argument wordForm um das eine oder andere Ergebnis zu erhalten. Mögliche Werte sind WordForm.Abbreviation WordForm.Normal Kombinieren Sie dieses Argument mit dem Rest der oben dargestellten Argumente. Das Übergeben von wordForm in Wenn es nicht anwendbar ist, macht das Ergebnis keinen Unterschied.
// Spanish locale
43 . ToOrdinalWords ( WordForm . Normal , GrammaticalGender . Masculine ) => "cuadragésimo tercero"
43 . ToOrdinalWords ( WordForm . Abbreviation , GrammaticalGender . Masculine ) => "cuadragésimo tercer"
43 . ToOrdinalWords ( WordForm . Abbreviation , GrammaticalGender . Feminine ) => "cuadragésima tercera"
// English locale
43 . ToOrdinalWords ( GrammaticalGender . Masculine , WordForm . Abbreviation , new CultureInfo ( "en" ) ) => "forty-third"Dies ist eine Art Erweiterung von Ordinalize
// for English UK locale
new DateTime ( 2015 , 1 , 1 ) . ToOrdinalWords ( ) => "1st January 2015"
new DateTime ( 2015 , 2 , 12 ) . ToOrdinalWords ( ) => "12th February 2015"
new DateTime ( 2015 , 3 , 22 ) . ToOrdinalWords ( ) => "22nd March 2015"
// for English US locale
new DateTime ( 2015 , 1 , 1 ) . ToOrdinalWords ( ) => "January 1st, 2015"
new DateTime ( 2015 , 2 , 12 ) . ToOrdinalWords ( ) => "February 12th, 2015"
new DateTime ( 2015 , 3 , 22 ) . ToOrdinalWords ( ) => "March 22nd, 2015" ToOrdinalWords unterstützt auch den grammatikalischen Fall. Sie können ein zweites Argument an ToOrdinalWords weitergeben, um den Fall der Ausgabe anzugeben. GrammaticalCase.Accusative GrammaticalCase.Dative GrammaticalCase.Instrumental GrammaticalGender.Prepositional GrammaticalCase.Nominative GrammaticalCase.Genitive
Offensichtlich gilt dies nur für einige Kulturen. Für andere, die in den Fall in den Fall sind, macht das Ergebnis keinen Unterschied.
Erstreckt sich zeitlich, um es einer Uhrbenachrichtigung auf die Humanisierung zu ermöglichen
// for English US locale
new TimeOnly ( 3 , 0 ) . ToClockNotation ( ) => "three o'clock"
new TimeOnly ( 12 , 0 ) . ToClockNotation ( ) => "noon"
new TimeOnly ( 14 , 30 ) . ToClockNotation ( ) => "half past two"
// for Brazilian Portuguese locale
new TimeOnly ( 3 , 0 ) . ToClockNotation ( ) => "três em ponto"
new TimeOnly ( 12 , 0 ) . ToClockNotation ( ) => "meio-dia"
new TimeOnly ( 14 , 30 ) . ToClockNotation ( ) => "duas e meia" Humanizer kann die Zahlen mit der ToRoman Erweiterung in römische Ziffern ändern. Die Zahlen 1 bis 10 können in römischen Ziffern wie folgt ausgedrückt werden:
1 . ToRoman ( ) => "I"
2 . ToRoman ( ) => "II"
3 . ToRoman ( ) => "III"
4 . ToRoman ( ) => "IV"
5 . ToRoman ( ) => "V"
6 . ToRoman ( ) => "VI"
7 . ToRoman ( ) => "VII"
8 . ToRoman ( ) => "VIII"
9 . ToRoman ( ) => "IX"
10 . ToRoman ( ) => "X" Auch der umgekehrte Betrieb mit der FromRoman -Erweiterung.
"I" . FromRoman ( ) => 1
"II" . FromRoman ( ) => 2
"III" . FromRoman ( ) => 3
"IV" . FromRoman ( ) => 4
"V" . FromRoman ( ) => 5Beachten Sie, dass nur Ganzzahlen kleinere als 4000 in römische Ziffern umgewandelt werden können.
Humanizer kann die Zahlen mit der ToMetric Erweiterung in metrische Ziffern ändern. Die Zahlen 1, 1230 und 0,1 können in metrischen Ziffern wie folgt ausgedrückt werden:
1d . ToMetric ( ) => "1"
1230d . ToMetric ( ) => "1.23k"
0.1d . ToMetric ( ) => "100m" Auch der umgekehrte Betrieb mit der FromMetric -Erweiterung.
"1" . FromMetric ( ) => 1
"1.23k" . FromMetric ( ) => 1230
"100m" . FromMetric ( ) => 0.1 Humanizer enthält einen Port der brillanten Bytesize -Bibliothek. Es werden einige Änderungen und Ergänzungen in ByteSize vorgenommen, um die Interaktion mit ByteSize einfacher und besser mit der Humanizer -API zu vereinfachen. Hier sind einige Beispiele dafür, wie Sie von Zahlen in Bytegrößen und zwischen Größengrößen konvertieren können:
var fileSize = ( 10 ) . Kilobytes ( ) ;
fileSize . Bits => 81920
fileSize . Bytes => 10240
fileSize . Kilobytes => 10
fileSize . Megabytes => 0.009765625
fileSize . Gigabytes => 9.53674316e-6
fileSize . Terabytes => 9.31322575e-9Es gibt einige Erweiterungsmethoden, mit denen Sie eine Zahl in eine Bytesize -Instanz verwandeln können:
3 . Bits ( ) ;
5 . Bytes ( ) ;
( 10.5 ) . Kilobytes ( ) ;
( 2.5 ) . Megabytes ( ) ;
( 10.2 ) . Gigabytes ( ) ;
( 4.7 ) . Terabytes ( ) ;Sie können die Werte auch mit +/- Operatoren hinzufügen/subtrahieren und Methoden hinzufügen/subtrahieren:
var total = ( 10 ) . Gigabytes ( ) + ( 512 ) . Megabytes ( ) - ( 2.5 ) . Gigabytes ( ) ;
total . Subtract ( ( 2500 ) . Kilobytes ( ) ) . Add ( ( 25 ) . Megabytes ( ) ) ; Ein ByteSize -Objekt enthält zwei Eigenschaften, die das größte metrische Präfix -Symbol und -wert darstellen:
var maxFileSize = ( 10 ) . Kilobytes ( ) ;
maxFileSize . LargestWholeNumberSymbol ; // "KB"
maxFileSize . LargestWholeNumberValue ; // 10 Wenn Sie eine String -Darstellung wünschen, können Sie ToString aufrufen oder austauschbar auf der ByteSize -Instanz Humanize :
7 . Bits ( ) . ToString ( ) ; // 7 b
8 . Bits ( ) . ToString ( ) ; // 1 B
( .5 ) . Kilobytes ( ) . Humanize ( ) ; // 512 B
( 1000 ) . Kilobytes ( ) . ToString ( ) ; // 1000 KB
( 1024 ) . Kilobytes ( ) . Humanize ( ) ; // 1 MB
( .5 ) . Gigabytes ( ) . Humanize ( ) ; // 512 MB
( 1024 ) . Gigabytes ( ) . ToString ( ) ; // 1 TB Sie können optional auch ein Format für die erwartete String -Darstellung bereitstellen. Das Formatierer kann das Symbol des zu zeigen: b , B , KB , MB , GB , TB . Das Formatierer verwendet die integrierte double.ToString -Methode mit #.## als Standardformat, das die Nummer auf zwei Dezimalstellen rundet:
var b = ( 10.505 ) . Kilobytes ( ) ;
// Default number format is #.##
b . ToString ( "KB" ) ; // 10.52 KB
b . Humanize ( "MB" ) ; // .01 MB
b . Humanize ( "b" ) ; // 86057 b
// Default symbol is the largest metric prefix value >= 1
b . ToString ( "#.#" ) ; // 10.5 KB
// All valid values of double.ToString(string format) are acceptable
b . ToString ( "0.0000" ) ; // 10.5050 KB
b . Humanize ( "000.00" ) ; // 010.51 KB
// You can include number format and symbols
b . ToString ( "#.#### MB" ) ; // .0103 MB
b . Humanize ( "0.00 GB" ) ; // 0 GB
b . Humanize ( "#.## B" ) ; // 10757.12 B Wenn Sie eine String -Darstellung mit vollständigen Wörtern wünschen, können Sie ToFullWords in der ByteSize -Instanz aufrufen:
7 . Bits ( ) . ToFullWords ( ) ; // 7 bits
8 . Bits ( ) . ToFullWords ( ) ; // 1 byte
( .5 ) . Kilobytes ( ) . ToFullWords ( ) ; // 512 bytes
( 1000 ) . Kilobytes ( ) . ToFullWords ( ) ; // 1000 kilobytes
( 1024 ) . Kilobytes ( ) . ToFullWords ( ) ; // 1 megabyte
( .5 ) . Gigabytes ( ) . ToFullWords ( ) ; // 512 megabytes
( 1024 ) . Gigabytes ( ) . ToFullWords ( ) ; // 1 terabyte Es gibt keine Dehumanize Methode, um eine String -Darstellung wieder in eine ByteSize -Instanz zu verwandeln. Aber Sie können Parse und TryParse auf ByteSize verwendet werden. Wie bei anderen TryParse -Methoden gibt ByteSize.TryParse den boolean Wert zurück, der angibt, ob die Parsen erfolgreich war oder nicht. Wenn der Wert analysiert wird, wird er für den ausgelieferten out -Parameter ausgegeben:
ByteSize output ;
ByteSize . TryParse ( "1.5mb" , out output ) ;
// Invalid
ByteSize . Parse ( "1.5 b" ) ; // Can't have partial bits
// Valid
ByteSize . Parse ( "5b" ) ;
ByteSize . Parse ( "1.55B" ) ;
ByteSize . Parse ( "1.55KB" ) ;
ByteSize . Parse ( "1.55 kB " ) ; // Spaces are trimmed
ByteSize . Parse ( "1.55 kb" ) ;
ByteSize . Parse ( "1.55 MB" ) ;
ByteSize . Parse ( "1.55 mB" ) ;
ByteSize . Parse ( "1.55 mb" ) ;
ByteSize . Parse ( "1.55 GB" ) ;
ByteSize . Parse ( "1.55 gB" ) ;
ByteSize . Parse ( "1.55 gb" ) ;
ByteSize . Parse ( "1.55 TB" ) ;
ByteSize . Parse ( "1.55 tB" ) ;
ByteSize . Parse ( "1.55 tb" ) ; Wenn Sie schließlich die Rate berechnen müssen, mit der eine Menge Bytes übertragen wurde, können Sie die Per -Methode der ByteSize verwenden. Die Per Methode akzeptiert ein Argument - das Messintervall für die Bytes; Dies ist die Zeit, die für die Übertragung der Bytes benötigt wurde.
Die Per Methode gibt eine ByteRate -Klasse zurück, die eine Humanize Methode hat. Standardmäßig werden die Preise in Sekunden angegeben (z. B. MB/s). Bei Wunsch kann jedoch eine Zeiteinheit verabschiedet werden, um ein alternatives Intervall zu Humanize . Gültige Intervalle sind TimeUnit.Second , TimeUnit.Minute und TimeUnit.Hour . Beispiele für jede Intervall- und Beispiel -Byte -Rate -Verwendung finden Sie unten.
var size = ByteSize . FromMegabytes ( 10 ) ;
var measurementInterval = TimeSpan . FromSeconds ( 1 ) ;
var text = size . Per ( measurementInterval ) . Humanize ( ) ;
// 10 MB/s
text = size . Per ( measurementInterval ) . Humanize ( TimeUnit . Minute ) ;
// 600 MB/min
text = size . Per ( measurementInterval ) . Humanize ( TimeUnit . Hour ) ;
// 35.15625 GB/hourSie können ein Format für den Bytes -Teil der humanisierten Ausgabe angeben:
19854651984 . Bytes ( ) . Per ( 1 . Seconds ( ) ) . Humanize ( "#.##" ) ;
// 18.49 GB/s Humanizer enthält Methoden, um einen numerischen Übergang in Wörter zu ändern. Die Überschrift kann ein double sein, während das Ergebnis eine Zeichenfolge ist. Sie können auswählen, ob eine vollständige Darstellung der Überschrift (z.
360 . ToHeading ( ) ;
// N
720 . ToHeading ( ) ;
// NVerwenden Sie den folgenden Anruf, um eine Vollversion der Überschrift abzurufen:
180 . ToHeading ( HeadingStyle . Full ) ;
// south
360 . ToHeading ( HeadingStyle . Full ) ;
// northBitte beachten Sie, dass eine Textdarstellung eine maximale Abweichung von 11,25 ° hat.
Die vorliegenden Methoden haben eine Überladung, mit der Sie ein CultureInfo -Objekt bereitstellen können, um das lokalisierte Ergebnis zur Rückgabe zu bestimmen.
Um einen Pfeil abzurufen, der die Überschrift darstellt, verwenden Sie die folgende Methode:
90 . ToHeadingArrow ( ) ;
// →
225 . ToHeadingArrow ( ) ;
// ↙Die Pfeildarstellung der Überschrift hat eine maximale Abweichung von 22,5 °.
Um eine Überschrift basierend auf der kurzen Textdarstellung (z. B. E, S, W) abzurufen, kann die folgende Methode verwendet werden:
"S" . FromShortHeading ( ) ;
// 180
"SW" . FromShortHeading ( ) ;
// 225 Humanizer kann ganze Zahlen mit Tupleize in ihr 'Tupel' verwandeln. Zum Beispiel:
1 . Tupleize ( ) ;
// single
3 . Tupleize ( ) ;
// triple
100 . Tupleize ( ) ;
// centupleDie Nummern 1-10, 100 und 1000 werden in ein 'genanntes' Tupel (dh "Single", "Double" usw.) umgewandelt. Jede andere Nummer "N" wird in "N-Tuple" konvertiert.
Humanizer kann Zeiteinheiten in ihre Symbole übersetzen:
TimeUnit . Day . ToSymbol ( ) ;
// d
TimeUnit . Week . ToSymbol ( ) ;
// week
TimeUnit . Year . ToSymbol ( ) ;
// y Dies ist nur eine Grundlinie und Sie können dies verwenden, um Ihren täglichen Job zu vereinfachen. In ASP.NET MVC werden beispielsweise immer wieder Display für ViewModel -Eigenschaften eingebunden, damit HtmlHelper korrekte Beschriftungen für uns generieren kann. Aber genau wie Enums brauchen wir in den meisten Fällen nur einen Raum zwischen den Wörtern im Eigenschaftsnamen - warum also nicht "string".Humanize dafür?!
In dem Code finden Sie möglicherweise ein ASP.NET -MVC -Beispiel (obwohl das Projekt aus der Lösungsdatei ausgeschlossen ist, um das Nuget -Paket auch für .NET 3.5 verfügbar zu machen).
Dies wird unter Verwendung eines benutzerdefinierten DataAnnotationsModelMetadataProvider erreicht. Es ist klein genug, um hier zu wiederholen; Also hier gehen wir:
using System ;
using System . Collections . Generic ;
using System . ComponentModel ;
using System . ComponentModel . DataAnnotations ;
using System . Linq ;
using System . Web . Mvc ;
using Humanizer ;
public class HumanizerMetadataProvider : DataAnnotationsModelMetadataProvider
{
protected override ModelMetadata CreateMetadata (
IEnumerable < Attribute > attributes ,
Type containerType ,
Func < object > modelAccessor ,
Type modelType ,
string propertyName )
{
var propertyAttributes = attributes . ToList ( ) ;
var modelMetadata = base . CreateMetadata ( propertyAttributes , containerType , modelAccessor , modelType , propertyName ) ;
if ( IsTransformRequired ( modelMetadata , propertyAttributes ) )
modelMetadata . DisplayName = modelMetadata . PropertyName . Humanize ( ) ;
return modelMetadata ;
}
private static bool IsTransformRequired ( ModelMetadata modelMetadata , IList < Attribute > propertyAttributes )
{
if ( string . IsNullOrEmpty ( modelMetadata . PropertyName ) )
return false ;
if ( propertyAttributes . OfType < DisplayNameAttribute > ( ) . Any ( ) )
return false ;
if ( propertyAttributes . OfType < DisplayAttribute > ( ) . Any ( ) )
return false ;
return true ;
}
} Diese Klasse ruft die Basisklasse an, um die Metadaten zu extrahieren, und humanisiert bei Bedarf den Eigenschaftsnamen. Es wird überprüft, ob die Eigenschaft bereits über ein DisplayName oder eine Display enthält. In diesem Fall wird der Metadatenanbieter das Attribut nur ehren und die Eigenschaft in Ruhe lassen. Für andere Eigenschaften wird es den Immobiliennamen humanisieren. Das ist alles.
Jetzt müssen Sie diesen Metadatenanbieter mit ASP.NET MVC registrieren. Stellen Sie sicher, dass Sie System.Web.Mvc.ModelMetadataProviders und nicht System.Web.ModelBinding.ModelMetadataProviders :
ModelMetadataProviders . Current = new HumanizerMetadataProvider ( ) ;... und jetzt können Sie ersetzen:
public class RegisterModel
{
[ Display ( Name = "User name" ) ]
public string UserName { get ; set ; }
[ Display ( Name = "Email address" ) ]
public string EmailAddress { get ; set ; }
[ Display ( Name = "Confirm password" ) ]
public string ConfirmPassword { get ; set ; }
}mit:
public class RegisterModel
{
public string UserName { get ; set ; }
public string EmailAddress { get ; set ; }
public string ConfirmPassword { get ; set ; }
}... und der "Metadata Humanizer" wird sich um den Rest kümmern.
Wenn Sie das Titelgehäuse für Ihre Etiketten wünschen, können Sie die Methode mit Transform anketten, wenn Sie das Titelgehäuse für Ihre Etiketten wünschen:
modelMetadata . DisplayName = modelMetadata . PropertyName . Humanize ( ) . Transform ( To . TitleCase ) ; Humanizer ist eine tragbare Klassenbibliothek. Derzeit gibt es ein Problem, wenn Sie versuchen, PCLs in einer MVC -Ansicht zu verwenden, da die MVC -Ansichten nicht dasselbe Build -System wie das reguläre Projekt teilen. Sie müssen alle Referenzen in der web.config -Datei angeben, einschließlich derjenigen, die das Projektsystem normalerweise automatisch hinzufügt.
Wenn Sie auf Fehler stoßen, die sagen, dass Sie entweder auf System.Runtime oder System.Globalization einen Verweis hinzufügen müssen, gilt dies für Sie. Die Lösung besteht darin, die Vertragsreferenzen zu Ihrem hier aufgeführten web.config hinzuzufügen. Beachten Sie, dass dies für jede PCL gilt, die Sie in einer MVC -Ansicht verwenden, nicht nur für Humanizer.
Das Humanizer -Projekt wird von Azure DevOps kontinuierlich gebaut und getestet (weitere Details hier). Das gilt auch, um Anfragen zu ziehen. Kurz nachdem Sie eine PR eingereicht haben, können Sie die Erstellungs- und Teststatusbenachrichtigung in Ihrer PR überprüfen.
Der aktuelle Build -Status auf dem CI -Server ist
Im Folgenden finden Sie eine Liste verwandter Open -Source -Projekte:
Bei Verwendung von Resharper sind Anmerkungen für Humanizer im Paket Humanizer.Annotation erhältlich, das Sie über den Resharper -Erweiterungsmanager erhalten können. Diese Anmerkungen decken noch nicht die gesamte Bibliothek ab, aber Pull -Anfragen sind immer willkommen!.
PowerShell Humanizer ist ein PowerShell -Modul, das Humanizer umwickelt.
Humanizer.jvm ist eine Anpassung des Humanizer -Frameworks für .NET, das für die JVM vorgenommen wird und in Kotlin geschrieben ist. Humanizer.jvm erfüllt alle Ihre JVM -Bedürfnisse, um Saiten, Aufzüge, Datteln, Zeiten, Times, Zahlen und Mengen zu manipulieren und anzuzeigen.
Humanizer.Node ist ein TypeScript -Port des Humanizer -Frameworks.
Ikone erstellt von Tyrone Rieschiek
