Humanizer
v3.0.0-beta.54
HumaniseurHumanizer répond à tous vos besoins .NET pour manipuler et afficher des chaînes, des énumérations, des dates, des temps, des délais, des chiffres et des quantités.
Vous pouvez installer Humanizer en tant que package NuGet:
Anglais uniquement : Humanizer.Core
Toutes les langues: Humanizer
Les cadres suivants sont pris en charge: Net4.8, Net6, Net7 et Net8
Remarque: le NuGet cible également netstandard2. Il s'agit d'activer le scénario où netstandard2 est requis. Par exemple, les analyseurs Roslyn ou les tâches MSBuild. D'autres cadres (autres que répertoriés ci-dessus) qui peuvent consommer netstandard2 (exemple net4.6.1 à net 4.7.2) ne sont pas pris en charge. Par exemple, Net4.6.1 à Net4.7.2 ne sont pas pris en charge.
Les symboles de l'humaniseur sont également indexés par source avec SourceLink et sont inclus dans le package afin que vous puissiez passer par le code humaniseur tout en débogues de votre code.
Vous choisissez les packages en fonction de ce que vous installez. Par défaut, le package Humanizer 2.0 principal installe toutes les langues prises en charge exactement comme dans 1.x. Si vous n'êtes pas sûr, utilisez simplement le package Humanizer principal.
Voici les options:
Humanizer principal. Cela tire Humanizer.Core et tous les packages de langues.Humanizer.Core . Seules les ressources de langue anglaise seront disponiblesHumanizer.Core.fr . Vous pouvez inclure plusieurs langues en installant dans la mesure où de nombreux packages de langues souhaités.L'explication détaillée de la façon dont cela fonctionne est dans les commentaires ici.
Humanize les extensions de chaîne vous permettent de transformer une chaîne par ailleurs informatisée en une chaîne plus lisible pour l'homme. Le fondement de ceci a été fixé dans le cadre BDDFY où les noms de classe, les noms de méthodes et les propriétés sont transformés en phrases lisibles par l'homme.
"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" Notez qu'une chaîne qui ne contient que des lettres en majuscules et ne se compose qu'un seul mot, est toujours traitée comme un acronyme (quelle que soit sa longueur). Pour garantir que toute chaîne arbitraire sera toujours humanisée, vous devez utiliser une transformation (voir la méthode Transform ci-dessous):
// 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"Vous pouvez également spécifier le boîtier de lettre souhaité:
"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"L'API
LetterCasinget les méthodes qui l'acceptent sont l'héritage de l'ère V0.2 et seront obsolètes à l'avenir. Au lieu de cela, vous pouvez utiliser la méthodeTransformexpliquée ci-dessous.
Tout comme vous pouvez humaniser un informatique convivial dans la chaîne amicale, vous pouvez déshumaniser une chaîne amicale humaine dans une chaîne informatique:
"Pascal case input string is turned into sentence" . Dehumanize ( ) => "PascalCaseInputStringIsTurnedIntoSentence" Il existe une méthode Transform qui remplace les surcharges LetterCasing , ApplyCase et Humanize qui acceptent LetterCasing . La signature de la méthode de transformation est la suivante:
string Transform ( this string input , params IStringTransformer [ ] transformers ) Et il y a certaines implémentations hors boîte d' IStringTransformer pour le boîtier des lettres:
"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 est une propriété statique publique To classe qui renvoie une instance de la classe ToLowerCase privée qui implémente IStringTransformer et sait comment transformer une chaîne en minuscules.
L'avantage de l'utilisation Transform et IStringTransformer via ApplyCase et LetterCasing est que LetterCasing est une énumération et vous êtes limité à utiliser ce qui est dans le cadre tandis que IStringTransformer est une interface que vous pouvez implémenter dans votre base de code une fois et l'utiliser avec la méthode Transform permettant une extension facile.
Vous pouvez tronquer une string en utilisant la méthode Truncate :
"Long text to truncate" . Truncate ( 10 ) => "Long text…" Par défaut, le caractère '…' est utilisé pour tronquer les chaînes. L'avantage de l'utilisation du caractère '…' au lieu de "..." est que le premier ne prend qu'un seul caractère et permet donc de montrer plus de texte avant la troncature. Si vous le souhaitez, vous pouvez également fournir votre propre chaîne de troncature:
"Long text to truncate" . Truncate ( 10 , "---" ) => "Long te -- - " La stratégie de troncature par défaut, Truncator.FixedLength , consiste à tronquer la chaîne d'entrée sur une longueur spécifique, y compris la longueur de chaîne de troncature. Il y a deux autres stratégies de troncons disponibles: une pour un nombre fixe de caractères (alpha-numeriques) et un pour un nombre fixe de mots. Pour utiliser un troncateur spécifique lors du tronçon, les deux méthodes Truncate illustrées dans les exemples précédents ont toutes une surcharge qui vous permet de spécifier l'instance ITruncator à utiliser pour la troncature. Voici des exemples sur la façon d'utiliser les trois troncateurs fournis:
"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---" Notez que vous pouvez également utiliser Créer votre propre troncateur en implémentant l'interface ITruncator .
Il existe également une option pour choisir de tronquer la chaîne depuis le début ( TruncateFrom.Left ) ou la fin ( TruncateFrom.Right ). La valeur par défaut est le droit comme indiqué dans les exemples ci-dessus. Les exemples ci-dessous montrent comment tronquer depuis le début de la chaîne:
"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" Appeler ToString directement sur les membres de l'Enum entraîne généralement une sortie moins que idéale pour les utilisateurs. La solution à cela consiste généralement à utiliser DescriptionAttribute , puis à lire cela à l'exécution pour obtenir une sortie plus conviviale. C'est une excellente solution; Mais le plus souvent, nous avons seulement besoin de mettre un peu d'espace entre les mots d'un membre de l'énume - c'est ce que String.Humanize() fait bien. Pour une énumération comme:
public enum EnumUnderTest
{
[ Description ( "Custom description" ) ]
MemberWithDescriptionAttribute ,
MemberWithoutDescriptionAttribute ,
ALLCAPITALS
}Vous obtiendrez:
// 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" Vous n'êtes pas limité à DescriptionAttribute pour une description personnalisée. Tout attribut appliqué sur les membres de l'énum avec une propriété string Description compte. Il s'agit d'aider avec des plates-formes avec DescriptionAttribute manquantes et également pour permettre des sous-classes de la DescriptionAttribute .
Vous pouvez même configurer le nom de la propriété d'atcourir à utiliser comme description.
Configurator.EnumDescriptionPropertyLocator = p => p.Name == "Info"
Si vous avez besoin de fournir des descriptions localisées, vous pouvez utiliser l'annotation de données d' DisplayAttribute à la place.
public enum EnumUnderTest
{
[ Display ( Description = "EnumUnderTest_Member" , ResourceType = typeof ( Project . Resources ) ) ]
Member
}Vous obtiendrez:
EnumUnderTest . Member . Humanize ( ) => "content" // from Project.Resources found under "EnumUnderTest_Member" resource keyEspérons que cela aidera à éviter les énumérements de détritus avec des attributs inutiles!
Déshumanise une chaîne dans l'énumération dont il était à l'origine humanisé! L'API ressemble:
public static TTargetEnum DehumanizeTo < TTargetEnum > ( this string input )Et l'utilisation est:
"Member without description attribute" . DehumanizeTo < EnumUnderTest > ( ) => EnumUnderTest . MemberWithoutDescriptionAttribute Et tout comme l'API humanize, il honore l'attribut Description . Vous n'avez pas à fournir le boîtier que vous avez fourni pendant l'humanisation: il le comprend.
Il existe également un homologue non générique pour le moment où l'énumération d'origine n'est pas connue au moment de la compilation:
public static Enum DehumanizeTo ( this string input , Type targetEnum , NoMatch onNoMatch = NoMatch . ThrowsException )qui peut être utilisé comme:
"Member without description attribute" . DehumanizeTo ( typeof ( EnumUnderTest ) ) => EnumUnderTest . MemberWithoutDescriptionAttribute Par défaut, les deux méthodes lancent une NoMatchFoundException lorsqu'elles ne peuvent pas correspondre à l'entrée fournie par rapport à l'énumération cible. Dans la méthode non générique, vous pouvez également demander à la méthode de retourner NULL en définissant le deuxième paramètre facultatif sur NoMatch.ReturnsNull .
Vous pouvez Humanize une instance de DateTime ou DateTimeOffset et de récupérer une chaîne indiquant à quel point il est loin ou en avant dans le temps:
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 prend en charge les dates locales et UTC ainsi que les dates avec Offset ( DateTimeOffset ). Vous pouvez également fournir la date à laquelle vous souhaitez que la date d'entrée soit comparée. Si NULL, il utilisera la date actuelle comme base de comparaison. De plus, la culture à utiliser peut être spécifiée explicitement. Si ce n'est pas le cas, la culture d'interface utilisateur actuelle de Thread actuel est utilisée. Voici la signature de l'API:
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 )De nombreuses localisations sont disponibles pour cette méthode. Voici quelques exemples:
// 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 минут назад" Il existe deux stratégies pour DateTime.Humanize : la par défaut comme on le voit ci-dessus et une fonction basée sur la précision. Pour utiliser la stratégie basée sur la précision, vous devez la configurer:
Configurator . DateTimeHumanizeStrategy = new PrecisionDateTimeHumanizeStrategy ( precision : .75 ) ;
Configurator . DateTimeOffsetHumanizeStrategy = new PrecisionDateTimeOffsetHumanizeStrategy ( precision : .75 ) ; // configure when humanizing DateTimeOffsetLa précision par défaut est définie sur 0,75 mais vous pouvez également passer la précision souhaitée. Avec précision réglé à 0,75:
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 Aucune déshumanisation pour les dates, car Humanize n'est une transformation avec perte et la date amicale humaine n'est pas réversible
Vous pouvez appeler Humanize sur un TimeSpan pour obtenir une représentation amicale humaine pour cela:
TimeSpan . FromMilliseconds ( 1 ) . Humanize ( ) => "1 millisecond"
TimeSpan . FromMilliseconds ( 2 ) . Humanize ( ) => "2 milliseconds"
TimeSpan . FromDays ( 1 ) . Humanize ( ) => "1 day"
TimeSpan . FromDays ( 16 ) . Humanize ( ) => "2 weeks" Il existe un paramètre precision facultatif pour TimeSpan.Humanize qui vous permet de spécifier la précision de la valeur renvoyée. La valeur par défaut de precision est 1, ce qui signifie que seule la plus grande unité de temps est retournée comme vous l'avez vu dans TimeSpan.FromDays(16).Humanize() . Voici quelques exemples de précision de précision:
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" Par défaut, lors de l'utilisation des paramètres precision les unités de temps vides ne sont pas comptées pour la précision de la valeur renvoyée. Si ce comportement n'est pas souhaité pour vous, vous pouvez utiliser la méthode TimeSpan.Humanize surchargée avec le paramètre countEmptyUnits . Les unités de temps vides ne comptent jamais. Voici un exemple montrant la différence de comptage des unités vides:
TimeSpan . FromMilliseconds ( 3603001 ) . Humanize ( 3 ) => "1 hour, 3 seconds, 1 millisecond"
TimeSpan . FromMilliseconds ( 3603001 ) . Humanize ( 3 , countEmptyUnits : true ) => "1 hour, 3 seconds"De nombreuses localisations sont disponibles pour cette méthode:
// 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"La culture à utiliser peut être spécifiée explicitement. Si ce n'est pas le cas, la culture d'interface utilisateur actuelle de Thread actuel est utilisée. Exemple:
TimeSpan . FromDays ( 1 ) . Humanize ( culture : "ru-RU" ) => "один день"De plus, une unité de temps minimale peut être spécifiée pour éviter de descendre à une petite unité. Par exemple:
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 HourDe plus, une unité maximale de temps peut être spécifiée pour éviter de se réunir à la plus grande unité la plus grande. Par exemple:
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 Le maxunit par défaut est TimeUnit.Week car il donne des résultats exacts. Vous pouvez augmenter cette valeur à TimeUnit.Month ou TimeUnit.Year Ce qui vous donnera une approximation basée sur 365.2425 jours par an et 30.436875 jours par mois. Par conséquent, les mois alternent entre 30 et 31 jours de longueur et chaque quatrième année dure 366 jours.
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 Lorsqu'il y a plusieurs unités de temps, ils sont combinés à l'aide de la chaîne ", " :
TimeSpan . FromMilliseconds ( 1299630020 ) . Humanize ( 3 ) => "2 weeks, 1 day, 1 hour" Lorsque TimeSpan est nul, le comportement par défaut renvoie "0" plus quelle que soit l'unité de temps minimum. Cependant, si vous attribuez true aux toWords lors de l'appel de Humanize , la méthode renvoie "pas de temps". Par exemple:
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" À l'aide du paramètre collectionSeparator , vous pouvez spécifier votre propre chaîne de séparateur:
TimeSpan . FromMilliseconds ( 1299630020 ) . Humanize ( 3 , collectionSeparator : " - " ) => "2 weeks - 1 day - 1 hour" Il est également possible d'utiliser le formateur de collection de la culture actuelle pour combiner les unités de temps. Pour ce faire, spécifiez null comme paramètre collectionSeparator :
// 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" Si les mots sont préférés aux nombres, un paramètre toWords: true peut être défini pour convertir les nombres dans un temps de temps humanisé en mots:
TimeSpan . FromMilliseconds ( 1299630020 ) . Humanize ( 3 , toWords : true ) => "two weeks, one day, one hour" En appelant ToAge , un TimeSpan peut également être exprimé en tant qu'âge. Pour les cultures qui ne définissent pas une expression de l'âge, le résultat sera le même que d'appeler Humanize (mais avec un maxUnit par défaut égal à TimeUnit.Year ) .
// in en-US culture
TimeSpan . FromDays ( 750 ) . ToAge ( ) => "2 years old"
// in fr culture
TimeSpan . FromDays ( 750 ) . ToAge ( ) => "2 ans" Vous pouvez appeler Humanize sur n'importe quel IEnumerable pour obtenir une chaîne bien formatée représentant les objets de la collection. Par défaut, ToString() sera appelé sur chaque élément pour obtenir sa représentation, mais une fonction de formatage peut être transmise à Humanize à la place. De plus, un séparateur par défaut est fourni ("et" en anglais), mais un séparateur différent peut être transmis dans Humanize .
Par exemple:
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"Les articles sont coupés et vides (nullorwhitespace) Les articles sont ignorés. Il en résulte une ponctuation de virgule propre. (S'il existe une fonction de format personnalisée, cela ne s'applique qu'à la sortie du formateur.)
Vous pouvez fournir votre propre formateur de collection en implémentant ICollectionFormatter et en l'enregistrant avec Configurator.CollectionFormatters .
Il existe également quelques méthodes d'inflecteur:
Pluralize les pluralise de l'entrée fournie tout en prenant en considération les mots irréguliers et innombrables:
"Man" . Pluralize ( ) => "Men "
" string" . Pluralize ( ) => "strings" Normalement, vous appelleriez Pluralize sur un mot singulier, mais si vous n'êtes pas sûr de la singularité du mot, vous pouvez appeler la méthode avec l'argument inputIsKnownToBeSingular :
"Men" . Pluralize ( inputIsKnownToBeSingular : false ) => "Men "
" Man" . Pluralize ( inputIsKnownToBeSingular : false ) => "Men"
"string" . Pluralize ( inputIsKnownToBeSingular : false ) => "strings" La surcharge de Pluralize with plurality est obsolète et a été supprimée dans la version 2.0.
Singularize de singularise l'entrée fournie tout en prenant en considération les mots irréguliers et innombrables:
"Men" . Singularize ( ) => "Man "
" strings" . Singularize ( ) => "string" Normalement, vous appelleriez Singularize sur un mot pluriel, mais si vous n'êtes pas sûr de la pluralité du mot, vous pouvez appeler la méthode avec l'argument facultatif inputIsKnownToBePlural :
"Men" . Singularize ( inputIsKnownToBePlural : false ) => "Man "
" Man" . Singularize ( inputIsKnownToBePlural : false ) => "Man"
"strings" . Singularize ( inputIsKnownToBePlural : false ) => "string" La surcharge de Singularize avec un argument plurality est obsolète et a été supprimée dans la version 2.0.
Parfois, vous devrez peut-être ajouter une règle du vocabulaire de la singularisation / pluralisation (les exemples ci-dessous sont déjà dans le DefaultVocabulary utilisé par Inflector ):
// 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" ) ; Plusieurs fois, vous voulez appeler Singularize et Pluralize pour préfixer un mot avec un numéro; par exemple "2 demandes", "3 hommes". ToQuantity préfixe le mot fourni avec le nombre et, en conséquence, pluralise ou singularise le mot:
"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 peut déterminer si le mot d'entrée est singulier ou pluriel et sera singularisé ou pluralisera si nécessaire:
"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" Vous pouvez également transmettre un deuxième argument, ShowQuantityAs , à ToQuantity pour spécifier comment vous souhaitez que la quantité fournie soit sortie. La valeur par défaut est ShowQuantityAs.Numeric qui est ce que nous avons vu ci-dessus. Les deux autres valeurs sont ShowQuantityAs.Words et ShowQuantityAs.None .
"case" . ToQuantity ( 5 , ShowQuantityAs . Words ) => "five cases "
" case" . ToQuantity ( 5 , ShowQuantityAs . None ) => "cases"Il existe également une surcharge qui vous permet de formater le numéro. Vous pouvez passer dans le format et la culture à utiliser.
"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 transforme un nombre en une chaîne ordinale utilisée pour désigner la position dans une séquence ordonnée telle que 1er, 2e, 3e, 4e:
1 . Ordinalize ( ) => "1st"
5 . Ordinalize ( ) => "5th" Vous pouvez également appeler Ordinalize sur une chaîne numérique et obtenir le même résultat: "21".Ordinalize() => "21st"
Ordinalize soutient également le sexe grammatical pour les deux formes. Vous pouvez transmettre un argument à Ordinalize GrammaticalGender.Feminine spécifier GrammaticalGender.Masculine genre le nombre GrammaticalGender.Neuter être étendu.
// 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º"De toute évidence, cela ne s'applique qu'à certaines cultures. Pour d'autres, passer du genre ou ne pas passer du tout ne fait aucune différence dans le résultat.
De plus, Ordinalize prend en charge les variations que certaines cultures s'appliquent en fonction de la position du nombre ordinalé dans une phrase. Utilisez l'argument wordForm pour obtenir un résultat ou un autre. Les valeurs possibles sont WordForm.Abbreviation et WordForm.Normal . Vous pouvez combiner un argument wordForm avec le sexe, mais passer cet argument dans le cas où il n'est pas applicable ne fera aucune différence dans le résultat.
// 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 convertit les mots d'entrée en boîtier de titre; équivalent à "some title".Humanize(LetterCasing.Title)
Pascalize convertit les mots d'entrée en Uppercamelcase, en supprimant également les soulignements et les espaces:
"some_title for something" . Pascalize ( ) => "SomeTitleForSomething" Camelize se comporte de manière identique à Pascalize , sauf que le premier caractère est en minuscules:
"some_title for something" . Camelize ( ) => "someTitleForSomething" Underscore sépare les mots d'entrée avec un soulignement:
"SomeTitle" . Underscore ( ) => "some_title" Dasherize et Hyphenate Remplacez les soulignements par des tirets dans la chaîne:
"some_title" . Dasherize ( ) => "some-title"
"some_title" . Hyphenate ( ) => "some-title" Kebaberize sépare les mots d'entrée avec des traits de trait et tous les mots sont convertis en minuscules
"SomeText" . Kebaberize ( ) => "some-text" Humanizer fournit une API couramment pour gérer DateTime et TimeSpan comme suit:
Méthodes 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 )Il n'y a pas d'API fluide pour le mois ou l'année car un mois pourrait avoir entre 28 et 31 jours et un an pourrait durer 365 ou 366 jours.
Vous pouvez utiliser ces méthodes pour, par exemple, remplacer
DateTime . Now . AddDays ( 2 ) . AddHours ( 3 ) . AddMinutes ( - 5 )avec
DateTime . Now + 2 . Days ( ) + 3 . Hours ( ) - 5 . Minutes ( ) Il existe également trois catégories de méthodes courantes pour gérer DateTime :
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 yearet quelques méthodes d'extension:
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 ( ) De toute évidence, vous pouvez également enchaîner les méthodes; par exemple On.November.The13th.In(2010).AtNoon + 5.Minutes()
Humanizer fournit une API courante qui produit (généralement de gros) nombres de manière plus claire:
1.25 . Billions ( ) => 1250000000
3 . Hundreds ( ) . Thousands ( ) => 300000 Humanizer peut changer de nombre en mots à l'aide de l'extension ToWords :
1 . ToWords ( ) => "one"
10 . ToWords ( ) => "ten"
11 . ToWords ( ) => "eleven"
122 . ToWords ( ) => "one hundred and twenty-two"
3501 . ToWords ( ) => "three thousand five hundred and one" Vous pouvez également passer un deuxième argument, GrammaticalGender , à ToWords GrammaticalGender.Neuter spécifier GrammaticalGender.Feminine GrammaticalGender.Masculine genre le nombre doit être étendu.
// 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 ( ) => "ناقص واحد"De toute évidence, cela ne s'applique qu'à certaines cultures. Pour d'autres, passer le genre ne fait aucune différence dans le résultat.
De plus, la culture à utiliser peut être spécifiée explicitement. Si ce n'est pas le cas, la culture d'interface utilisateur actuelle de Thread actuel est utilisée. Voici un exemple:
11 . ToWords ( new CultureInfo ( "en" ) ) => "eleven"
1 . ToWords ( GrammaticalGender . Masculine , new CultureInfo ( "ru" ) ) => "один"Une autre surcharge de la méthode vous permet de passer un bool pour supprimer le "et" qui peut être ajouté avant le dernier numéro:
3501 . ToWords ( false ) => "three thousand five hundred one"
102 . ToWords ( false ) => "one hundred two"Cette méthode peut être utile pour rédiger des chèques par exemple.
De plus, ToWords soutiennent les variations que certaines cultures s'appliquent en fonction de la position du nombre dans une phrase. Utilisez l'argument wordForm pour obtenir un résultat ou un autre. Les valeurs possibles sont WordForm.Abbreviation et WordForm.Normal . Cet argument peut être combiné avec le reste des arguments présentés ci-dessus. Passer un argument wordForm dans le moment où il n'est pas applicable ne fera aucune différence dans le résultat.
// 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" C'est une sorte de mélange ToWords avec Ordinalize . Vous pouvez appeler ToOrdinalWords sur un numéro pour obtenir une représentation ordinale du numéro en mots! Par exemple:
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 prend également en charge le sexe grammatical. Vous pouvez transmettre un deuxième argument à ToOrdinalWords pour spécifier le sexe de la sortie. Les valeurs possibles sont GrammaticalGender.Masculine , GrammaticalGender.Feminine et GrammaticalGender.Neuter :
// 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 ) => "الثاني"De toute évidence, cela ne s'applique qu'à certaines cultures. Pour d'autres, passer le genre ne fait aucune différence dans le résultat.
De plus, la culture à utiliser peut être spécifiée explicitement. Si ce n'est pas le cas, la culture d'interface utilisateur actuelle de Thread actuel est utilisée. Voici un exemple:
10 . ToOrdinalWords ( new CultureInfo ( "en-US" ) ) => "tenth"
1 . ToOrdinalWords ( GrammaticalGender . Masculine , new CulureInfo ( "pt-BR" ) ) => "primeiro" ToOrdinalWords prend également en charge les variations que certaines cultures s'appliquent en fonction de la position du nombre ordinalé dans une phrase. Utilisez l'argument wordForm pour obtenir un résultat ou un autre. Les valeurs possibles sont WordForm.Abbreviation et WordForm.Normal . Combinez cet argument avec le reste des arguments présentés ci-dessus. Passer un argument wordForm dans le moment où il n'est pas applicable ne fera aucune différence dans le résultat.
// 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"C'est une sorte d'extension de l'ordination
// 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 prend également en charge le cas grammatical. Vous pouvez transmettre un deuxième argument à ToOrdinalWords pour spécifier le cas de la sortie. GrammaticalGender.Prepositional GrammaticalCase.Instrumental GrammaticalCase.Dative GrammaticalCase.Accusative GrammaticalCase.Nominative GrammaticalCase.Genitive
De toute évidence, cela ne s'applique qu'à certaines cultures. Pour d'autres, passer un cas ne fait aucune différence dans le résultat.
S'étend à temps pour permettre à l'humaniser à une notation d'horloge
// 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 peut changer de nombre en chiffres romains en utilisant l'extension ToRoman . Les numéros 1 à 10 peuvent être exprimés en chiffres romains comme suit:
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" Aussi l'opération inverse en utilisant l'extension FromRoman .
"I" . FromRoman ( ) => 1
"II" . FromRoman ( ) => 2
"III" . FromRoman ( ) => 3
"IV" . FromRoman ( ) => 4
"V" . FromRoman ( ) => 5Notez que seuls les entiers inférieurs à 4000 peuvent être convertis en chiffres romains.
Humanizer peut changer les nombres en chiffres métriques en utilisant l'extension ToMetric . Les nombres 1, 1230 et 0,1 peuvent être exprimés en chiffres métriques comme suit:
1d . ToMetric ( ) => "1"
1230d . ToMetric ( ) => "1.23k"
0.1d . ToMetric ( ) => "100m" Également l'opération inverse à l'aide de l'extension FromMetric .
"1" . FromMetric ( ) => 1
"1.23k" . FromMetric ( ) => 1230
"100m" . FromMetric ( ) => 0.1 Humanizer comprend un port de la bibliothèque Brilliant Bytetesize. Un certain nombre de changements et d'ajouts sont apportés à ByteSize pour rendre l'interaction avec ByteSize plus facile et plus cohérente avec l'API de l'humanizer. Voici quelques exemples de la façon de passer des nombres en tailles d'octets et entre les amplitudes de taille:
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-9Il existe quelques méthodes d'extension qui vous permettent de transformer un nombre en une instance byteTize:
3 . Bits ( ) ;
5 . Bytes ( ) ;
( 10.5 ) . Kilobytes ( ) ;
( 2.5 ) . Megabytes ( ) ;
( 10.2 ) . Gigabytes ( ) ;
( 4.7 ) . Terabytes ( ) ;Vous pouvez également ajouter / soustraire les valeurs à l'aide des opérateurs +/- et ajouter / soustraire les méthodes:
var total = ( 10 ) . Gigabytes ( ) + ( 512 ) . Megabytes ( ) - ( 2.5 ) . Gigabytes ( ) ;
total . Subtract ( ( 2500 ) . Kilobytes ( ) ) . Add ( ( 25 ) . Megabytes ( ) ) ; Un objet ByteSize contient deux propriétés qui représentent le plus grand symbole et la valeur du préfixe métrique:
var maxFileSize = ( 10 ) . Kilobytes ( ) ;
maxFileSize . LargestWholeNumberSymbol ; // "KB"
maxFileSize . LargestWholeNumberValue ; // 10 Si vous voulez une représentation de chaîne, vous pouvez appeler ToString ou Humanize interchangeable sur l'instance ByteSize :
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 Vous pouvez également fournir éventuellement un format pour la représentation de chaîne attendue. Le formateur peut contenir le symbole de la valeur à afficher: b , B , KB , MB , GB , TB . Le formateur utilise la méthode intégrée en double.ToString avec #.## comme format par défaut qui arrond le nombre à deux décimales:
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 Si vous voulez une représentation de chaîne avec des mots complets, vous pouvez appeler ToFullWords sur l'instance ByteSize :
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 Il n'y a pas de méthode Dehumanize pour transformer une représentation de chaîne en une instance ByteSize ; Mais vous pouvez utiliser Parse et TryParse sur ByteSize pour ce faire. Comme les autres méthodes TryParse , ByteSize.TryParse renvoie la valeur boolean indiquant si l'analyse a réussi ou non. Si la valeur est analysée, elle est sortie au paramètre out fourni:
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" ) ; Enfin, si vous avez besoin de calculer la vitesse à laquelle une quantité d'octets a été transférée, vous pouvez utiliser la méthode Per ByteSize . La méthode Per accepte un argument - l'intervalle de mesure pour les octets; C'est le temps qu'il a fallu pour transférer les octets.
La méthode Per renvoie une classe ByteRate qui a une méthode Humanize . Par défaut, les taux sont donnés en secondes (par exemple, MB / s). Cependant, si vous le souhaitez, un temps de temps peut être transmis à Humanize pour un intervalle alternatif. Les intervalles valides sont TimeUnit.Second , TimeUnit.Minute et TimeUnit.Hour . Des exemples de chaque intervalle et de l'utilisation du taux d'octets de l'exemple sont ci-dessous.
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/hourVous pouvez spécifier un format pour la partie des octets de la sortie humanisée:
19854651984 . Bytes ( ) . Per ( 1 . Seconds ( ) ) . Humanize ( "#.##" ) ;
// 18.49 GB/s Humanizer comprend des méthodes pour changer une rubrique numérique vers des mots. L'en-tête peut être un double tandis que le résultat sera une chaîne. Vous pouvez choisir de retourner une représentation complète de l'en-tête (par exemple nord, est, sud ou ouest), une courte représentation (par exemple N, E, S, W) ou un caractère flèche Unicode (par exemple ↑, →, ↓, ←).
360 . ToHeading ( ) ;
// N
720 . ToHeading ( ) ;
// NAfin de récupérer une version complète de l'en-tête, utilisez l'appel suivant:
180 . ToHeading ( HeadingStyle . Full ) ;
// south
360 . ToHeading ( HeadingStyle . Full ) ;
// northVeuillez noter qu'une représentation textuelle a une déviation maximale de 11,25 °.
Les méthodes ont surtout une surcharge avec laquelle vous pouvez fournir un objet CultureInfo afin de déterminer le résultat localisé à retourner.
Pour récupérer une flèche représentant le titre Utilisez la méthode suivante:
90 . ToHeadingArrow ( ) ;
// →
225 . ToHeadingArrow ( ) ;
// ↙La représentation de la flèche de la rubrique a une déviation maximale de 22,5 °.
Afin de récupérer un titre en fonction de la représentation du texte court (par exemple n, e, s, w), la méthode suivante peut être utilisée:
"S" . FromShortHeading ( ) ;
// 180
"SW" . FromShortHeading ( ) ;
// 225 Humanizer peut transformer des nombres entiers en leur «tuple» à l'aide de Tupleize . Par exemple:
1 . Tupleize ( ) ;
// single
3 . Tupleize ( ) ;
// triple
100 . Tupleize ( ) ;
// centupleLes numéros 1-10, 100 et 1000 seront convertis en un tuple 'nommé' (c'est-à-dire "single", "double" etc.). Tout autre numéro "n" sera converti en "n-tuple".
Humanizer peut traduire des unités de temps à leurs symboles:
TimeUnit . Day . ToSymbol ( ) ;
// d
TimeUnit . Week . ToSymbol ( ) ;
// week
TimeUnit . Year . ToSymbol ( ) ;
// y Ce n'est qu'une base de référence et vous pouvez l'utiliser pour simplifier votre travail quotidien. Par exemple, dans ASP.NET MVC, nous continuons à effondrer l'attribut Display sur les propriétés ViewModel afin que HtmlHelper puisse générer des étiquettes correctes pour nous; Mais, tout comme Enum, dans la grande majorité des cas, nous avons juste besoin d'un espace entre les mots dans le nom de la propriété - alors pourquoi ne pas utiliser "string".Humanize pour cela ?!
Vous pouvez trouver un échantillon ASP.NET MVC dans le code qui le fait (bien que le projet soit exclu du fichier de solution pour rendre le package NuGet disponible également pour .net 3.5).
Ceci est réalisé à l'aide d'une DataAnnotationsModelMetadataProvider personnaliséesModelMetAdataprovider que j'ai appelé HumanizerMetAdataprovider. Il est assez petit pour répéter ici; Alors voilà:
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 ;
}
} Cette classe appelle la classe de base pour extraire les métadonnées, puis, si nécessaire, humanise le nom de la propriété. Il vérifie si la propriété a déjà un DisplayName ou un attribut Display , auquel cas le fournisseur de métadonnées ne fera qu'honorer l'attribut et laissera la propriété seule. Pour d'autres propriétés, il humanisera le nom de la propriété. C'est tout.
Vous devez maintenant enregistrer ce fournisseur de métadonnées avec ASP.NET MVC. Assurez-vous d'utiliser System.Web.Mvc.ModelMetadataProviders , et non System.Web.ModelBinding.ModelMetadataProviders :
ModelMetadataProviders . Current = new HumanizerMetadataProvider ( ) ;... et maintenant vous pouvez remplacer:
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 ; }
}avec:
public class RegisterModel
{
public string UserName { get ; set ; }
public string EmailAddress { get ; set ; }
public string ConfirmPassword { get ; set ; }
}... et les "métadonnées humanizer" s'occuperont du reste.
Pas besoin de mentionner que si vous voulez un boîtier de titre pour vos étiquettes, vous pouvez enchaîner la méthode avec Transform :
modelMetadata . DisplayName = modelMetadata . PropertyName . Humanize ( ) . Transform ( To . TitleCase ) ; Humanizer est une bibliothèque de classe portable. Il y a actuellement un problème si vous essayez d'utiliser des PCL dans une vue MVC car les vues MVC ne partagent pas le même système de construction que le projet ordinaire. Vous devez spécifier toutes les références dans le fichier web.config , y compris celles que le système de projet ajoute normalement automatiquement.
Si vous rencontrez des erreurs en disant que vous devez ajouter une référence à System.Runtime ou System.Globalization , cela s'applique à vous. La solution consiste à ajouter les références du contrat à votre web.config comme indiqué ici. Notez que cela s'applique à tout PCL que vous utilisez dans une vue MVC, pas seulement à l'humaniseur.
Le projet Humanizer est construit et testé en continu par Azure DevOps (plus de détails ici). Cela s'applique également aux demandes de traction. Peu de temps après avoir soumis un PR, vous pouvez vérifier la notification de build et de test sur votre PR.
L'état de construction actuel sur le serveur CI est
Vous trouverez ci-dessous une liste des projets open source connexes:
Si vous utilisez Resharper, les annotations pour l'humanizer sont disponibles dans le package Humanizer.annotations, que vous pouvez obtenir via le Resharper Extension Manager. Ces annotations ne couvrent pas encore toute la bibliothèque, mais les demandes de traction sont toujours les bienvenues!.
PowerShell Humanizer est un module PowerShell qui enveloppe l'humaniseur.
Humanizer.jvm est une adaptation du framework Humanizer pour .NET qui est conçu pour le JVM et est écrit en Kotlin. Humanizer.jvm répond à tous vos besoins JVM pour manipuler et afficher des chaînes, des énumérements, des dates, des temps, des décorations, des chiffres et des quantités.
Humanizer.Node est un port de type dactylographié du cadre Humanizer.
Icône créée par Tyrone Rieschiek
