Humanizer
v3.0.0-beta.54
HumanizadorHumanizer satisface todas sus necesidades de .NET para manipular y mostrar cuerdas, enumeraciones, fechas, tiempos, pasos de tiempo, números y cantidades.
Puede instalar humanizador como un paquete Nuget:
Solo inglés : Humanizer.Core
Todos los idiomas: Humanizer
Se admiten los siguientes marcos: Net4.8, Net6, Net7 y Net8
Nota: El Nuget también se dirige a NetStandard2. Esto es para habilitar el escenario donde se requiere NetStandard2. Por ejemplo, analizadores de Roslyn o tareas de MSBuild. No son compatibles con otros marcos (que no sean mencionados anteriormente) que pueden consumir NetStandard2 (Ejemplo NET4.6.1 a NET 4.7.2). Por ejemplo, Net4.6.1 a Net4.7.2 no son compatibles.
Además, los símbolos de humanizador se indexan con SourCelink y se incluyen en el paquete para que pueda atravesar el código de humanizador mientras depugga su código.
Usted elige qué paquetes se basan en qué paquetes Nuget instala. Por defecto, el paquete principal Humanizer 2.0 instala todos los idiomas compatibles exactamente como lo hace en 1.x. Si no está seguro, simplemente use el paquete principal Humanizer .
Estas son las opciones:
Humanizer . Esto atrae a Humanizer.Core y todos los paquetes de idiomas.Humanizer.Core . Solo los recursos del idioma inglés estarán disponiblesHumanizer.Core.fr . Puede incluir varios idiomas instalando muchos paquetes de idioma que desee.La explicación detallada de cómo funciona esto está en los comentarios aquí.
Las extensiones de cadenas Humanize le permiten convertir una cadena computarizada en una más legible amigable para el ser humano. La base de esto se estableció en el marco BDDFY donde los nombres de clase, los nombres de métodos y las propiedades se convierten en oraciones legibles por humanos.
"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" Tenga en cuenta que una cadena que contiene solo letras mayúsculas, y consiste solo en una palabra, siempre se trata como un acrónimo (independientemente de su longitud). Para garantizar que cualquier cadena arbitraria siempre se humanice, debe usar una transformación (ver método Transform a continuación):
// 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"También puede especificar la carcasa deseada:
"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"La API
LetterCasingy los métodos que lo aceptan son heredados de la era V0.2 y estarán en desuso en el futuro. En lugar de eso, puede usar el métodoTransformexplicado a continuación.
Al igual que puedes humanizar una computadora amigable con la cuerda amigable para los humanos, puedes deshumanizar una cuerda amigable para los humanos en una computadora amigable:
"Pascal case input string is turned into sentence" . Dehumanize ( ) => "PascalCaseInputStringIsTurnedIntoSentence" Existe un método Transform que reemplaza LetterCasing , ApplyCase y Humanize sobrecargas que aceptan LetterCasing . La firma del método de transformación es la siguiente:
string Transform ( this string input , params IStringTransformer [ ] transformers ) Y hay algunas implementaciones fuera de la caja de IStringTransformer para carcasa de letras:
"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 es una propiedad estática pública de To clase que devuelve una instancia de clase privada ToLowerCase que implementa IStringTransformer y sabe cómo convertir una cadena en minúsculas.
El beneficio de usar Transform y IStringTransformer SOBRE ApplyCase Y LetterCasing es que LetterCasing es una enumia y está limitado a usar lo que está en el marco, mientras que IStringTransformer es una interfaz que puede implementar en su base de código una vez y usarlo con el método Transform que permite una fácil extensión.
Puede truncar una string utilizando el método Truncate :
"Long text to truncate" . Truncate ( 10 ) => "Long text…" Por defecto, el carácter '…' se usa para truncar cadenas. La ventaja de usar el personaje '…' en lugar de "..." es que el primero solo toma un solo carácter y, por lo tanto, permite que se muestre más texto antes del truncamiento. Si lo desea, también puede proporcionar su propia cadena de truncamiento:
"Long text to truncate" . Truncate ( 10 , "---" ) => "Long te -- - " La estrategia de truncamiento predeterminada, Truncator.FixedLength , es truncar la cadena de entrada a una longitud específica, incluida la longitud de la cadena de truncamiento. Hay dos estrategias de truncator más disponibles: una para un número fijo de caracteres (alfa-numéricos) y otra para un número fijo de palabras. Para usar un truncador específico al truncar, los dos métodos Truncate que se muestran en los ejemplos anteriores tienen una sobrecarga que le permite especificar la instancia ITruncator para usar para el truncamiento. Aquí hay ejemplos sobre cómo usar los tres truncadores proporcionados:
"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---" Tenga en cuenta que también puede usar Crear su propio Truncator implementando la interfaz ITruncator .
También hay una opción para elegir si truncar la cadena desde el principio ( TruncateFrom.Left ) o el extremo ( TruncateFrom.Right ). El valor predeterminado es el derecho como se muestra en los ejemplos anteriores. Los ejemplos a continuación muestran cómo truncar desde el comienzo de la cadena:
"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" Llamar ToString directamente a los miembros de ENUM generalmente da como resultado una salida menos que ideal para los usuarios. La solución a esto generalmente es usar la anotación de datos DescriptionAttribute y luego leerla en tiempo de ejecución para obtener una salida más amigable. Esa es una gran solución; Pero la mayoría de las veces solo necesitamos poner algo de espacio entre las palabras de un miembro de Enum, que es lo que String.Humanize() funciona bien. Para un enum como:
public enum EnumUnderTest
{
[ Description ( "Custom description" ) ]
MemberWithDescriptionAttribute ,
MemberWithoutDescriptionAttribute ,
ALLCAPITALS
}Obtendrás:
// 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" No se limita a DescriptionAttribute de la descripción personalizada. Cualquier atributo aplicado en los miembros de ENUM con un recuento de propiedades string Description . Esto es para ayudar con las plataformas con DescriptionAttribute faltante y también para permitir subclases de la DescriptionAttribute .
Incluso puede configurar el nombre de la propiedad de Attibute para usar como descripción.
Configurator.EnumDescriptionPropertyLocator = p => p.Name == "Info"
Si necesita proporcionar descripciones localizadas, puede usar la anotación de datos DisplayAttribute en su lugar.
public enum EnumUnderTest
{
[ Display ( Description = "EnumUnderTest_Member" , ResourceType = typeof ( Project . Resources ) ) ]
Member
}Obtendrás:
EnumUnderTest . Member . Humanize ( ) => "content" // from Project.Resources found under "EnumUnderTest_Member" resource key¡Esperemos que esto ayude a evitar enumerar en las enumeraciones con atributos innecesarios!
¡Deshumaniza una cuerda en el enum de la que se humanizó originalmente! La API parece:
public static TTargetEnum DehumanizeTo < TTargetEnum > ( this string input )Y el uso es:
"Member without description attribute" . DehumanizeTo < EnumUnderTest > ( ) => EnumUnderTest . MemberWithoutDescriptionAttribute Y al igual que la API de Humanize, honra el atributo Description . No tiene que proporcionar la carcasa que proporcionó durante la humanización: lo resuelve.
También hay una contraparte no genérica para cuando el enum original no se conoce en el momento de la compilación:
public static Enum DehumanizeTo ( this string input , Type targetEnum , NoMatch onNoMatch = NoMatch . ThrowsException )que se puede usar como:
"Member without description attribute" . DehumanizeTo ( typeof ( EnumUnderTest ) ) => EnumUnderTest . MemberWithoutDescriptionAttribute Por defecto, ambos métodos arrojan una NoMatchFoundException cuando no pueden igualar la entrada proporcionada con el enum de destino. En el método no genérico, también puede pedirle al método que devuelva NULL estableciendo el segundo parámetro opcional en NoMatch.ReturnsNull .
Puede Humanize una instancia de DateTime o DateTimeOffset y recuperar una cadena que dice qué tan atrás o avanzado en el tiempo es:
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 admite fechas locales y UTC, así como fechas con Offset ( DateTimeOffset ). También puede proporcionar la fecha en que desea que se compare la fecha de entrada. Si es nulo, usará la fecha actual como base de comparación. Además, la cultura para usar se puede especificar explícitamente. Si no es así, se usa la cultura de interfaz de usuario actual del hilo actual. Aquí está la firma 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 )Muchas localizaciones están disponibles para este método. Aquí hay algunos ejemplos:
// 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 минут назад" Hay dos estrategias para DateTime.Humanize : la predeterminada como se ve anteriormente y una basada en precisión. Para usar la estrategia basada en precisión, necesita configurarla:
Configurator . DateTimeHumanizeStrategy = new PrecisionDateTimeHumanizeStrategy ( precision : .75 ) ;
Configurator . DateTimeOffsetHumanizeStrategy = new PrecisionDateTimeOffsetHumanizeStrategy ( precision : .75 ) ; // configure when humanizing DateTimeOffsetLa precisión predeterminada se establece en .75, pero también puede pasar su precisión deseada. Con precisión establecida a 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 No hay deshumanización para las fechas como Humanize es una transformación con pérdida y la fecha amigable para los humanos no es reversible
Puede llamar Humanize en un TimeSpan para obtener una representación amigable para el humano:
TimeSpan . FromMilliseconds ( 1 ) . Humanize ( ) => "1 millisecond"
TimeSpan . FromMilliseconds ( 2 ) . Humanize ( ) => "2 milliseconds"
TimeSpan . FromDays ( 1 ) . Humanize ( ) => "1 day"
TimeSpan . FromDays ( 16 ) . Humanize ( ) => "2 weeks" Existe un parámetro precision opcional para TimeSpan.Humanize que le permite especificar la precisión del valor devuelto. El valor predeterminado de precision es 1, lo que significa que solo la unidad de tiempo más grande se devuelve como usted vio en TimeSpan.FromDays(16).Humanize() Aquí hay algunos ejemplos de especificación de precisión:
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" Por defecto, cuando se usa el parámetro precision las unidades de tiempo vacío no se cuentan para la precisión del valor devuelto. Si no se desea este comportamiento para usted, puede usar el método de TimeSpan.Humanize countEmptyUnits . Las principales unidades de tiempo vacías nunca cuentan. Aquí hay un ejemplo que muestra la diferencia de contar unidades vacías:
TimeSpan . FromMilliseconds ( 3603001 ) . Humanize ( 3 ) => "1 hour, 3 seconds, 1 millisecond"
TimeSpan . FromMilliseconds ( 3603001 ) . Humanize ( 3 , countEmptyUnits : true ) => "1 hour, 3 seconds"Muchas localizaciones están disponibles para este método:
// 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 cultura para usar se puede especificar explícitamente. Si no es así, se usa la cultura de interfaz de usuario actual del hilo actual. Ejemplo:
TimeSpan . FromDays ( 1 ) . Humanize ( culture : "ru-RU" ) => "один день"Además, se puede especificar una unidad mínima de tiempo para evitar rodar hacia una unidad más pequeña. Por ejemplo:
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 HourAdemás, se puede especificar una unidad de tiempo máxima para evitar rodar a la siguiente unidad más grande. Por ejemplo:
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 El maxunit predeterminado es TimeUnit.Week porque da resultados exactos. Puede aumentar este valor a TimeUnit.Month o TimeUnit.Year Por lo tanto, los meses se alternan entre 30 y 31 días de duración y cada cuarto año dura 366 días.
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 Cuando hay varias unidades de tiempo, se combinan usando la cadena ", " :
TimeSpan . FromMilliseconds ( 1299630020 ) . Humanize ( 3 ) => "2 weeks, 1 day, 1 hour" Cuando TimeSpan es cero, el comportamiento predeterminado devolverá "0" más lo que sea la unidad de tiempo mínima. Sin embargo, si asigna true a toWords al llamar Humanize , entonces el método devuelve "Sin tiempo". Por ejemplo:
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" Usando el parámetro collectionSeparator , puede especificar su propia cadena separadora:
TimeSpan . FromMilliseconds ( 1299630020 ) . Humanize ( 3 , collectionSeparator : " - " ) => "2 weeks - 1 day - 1 hour" También es posible utilizar el formato de colección de la cultura actual para combinar las unidades de tiempo. Para hacerlo, especifique null como el parámetro 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 se prefieren las palabras a los números, se puede establecer un parámetro toWords: true para convertir los números en un tiempo de tiempo humanizado a palabras:
TimeSpan . FromMilliseconds ( 1299630020 ) . Humanize ( 3 , toWords : true ) => "two weeks, one day, one hour" Al llamar ToAge , un TimeSpan también puede expresarse como una edad. Para las culturas que no definen una expresión de edad, el resultado será el mismo que llamar Humanize (pero con una maxUnit predeterminada igual a TimeUnit.Year .
// in en-US culture
TimeSpan . FromDays ( 750 ) . ToAge ( ) => "2 years old"
// in fr culture
TimeSpan . FromDays ( 750 ) . ToAge ( ) => "2 ans" Puede llamar Humanize en cualquier IEnumerable para obtener una cadena bien formateada que represente los objetos en la colección. Por defecto, se solicitará ToString() en cada elemento que obtenga su representación, pero en su lugar se puede pasar una función de formato a Humanize . Además, se proporciona un separador predeterminado ("y" en inglés), pero un separador diferente puede pasar a Humanize .
Por ejemplo:
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"Los artículos se recortan y se omiten los artículos en blanco (nullorwhitespace). Esto da como resultado una puntuación de coma limpia. (Si hay una función de formato personalizada, esto se aplica solo a la salida del formato).
Puede proporcionar su propio formato de colección implementando ICollectionFormatter y registrándolo con Configurator.CollectionFormatters .
También hay algunos métodos de inflector:
Pluralize pluraliza la entrada proporcionada mientras toma en consideración las palabras irregulares e incontables:
"Man" . Pluralize ( ) => "Men "
" string" . Pluralize ( ) => "strings" Normalmente llamaría Pluralize en una palabra singular, pero si no está seguro sobre la singularidad de la palabra, puede llamar al método con el argumento opcional inputIsKnownToBeSingular :
"Men" . Pluralize ( inputIsKnownToBeSingular : false ) => "Men "
" Man" . Pluralize ( inputIsKnownToBeSingular : false ) => "Men"
"string" . Pluralize ( inputIsKnownToBeSingular : false ) => "strings" La sobrecarga de Pluralize con argumento plurality es obsoleta y se eliminó en la versión 2.0.
Singularize singulariza la entrada proporcionada mientras toma en consideración las palabras irregulares e incontables:
"Men" . Singularize ( ) => "Man "
" strings" . Singularize ( ) => "string" Normalmente llamaría Singularize en una palabra plural, pero si no está seguro sobre la pluralidad de la palabra, puede llamar al método con el argumento opcional inputIsKnownToBePlural :
"Men" . Singularize ( inputIsKnownToBePlural : false ) => "Man "
" Man" . Singularize ( inputIsKnownToBePlural : false ) => "Man"
"strings" . Singularize ( inputIsKnownToBePlural : false ) => "string" La sobrecarga de Singularize con argumento plurality es obsoleta y se eliminó en la versión 2.0.
A veces, es posible que deba agregar una regla del vocabulario de singularización/pluralización (los ejemplos a continuación ya están en el DefaultVocabulary utilizado por 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" ) ; Muchas veces desea llamar Singularize y Pluralize para prefijar una palabra con un número; por ejemplo, "2 solicitudes", "3 hombres". ToQuantity prefijos la palabra proporcionada con el número y, en consecuencia, pluraliza o singulariza la palabra:
"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 puede averiguar si la palabra de entrada es singular o plural y singularizará o pluralizará según sea necesario:
"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" ToQuantity puede aprobar un segundo argumento, ShowQuantityAs , para especificar cómo desea que se genere la cantidad proporcionada. El valor predeterminado es ShowQuantityAs.Numeric , que es lo que vimos anteriormente. Los otros dos valores son ShowQuantityAs.Words y ShowQuantityAs.None .
"case" . ToQuantity ( 5 , ShowQuantityAs . Words ) => "five cases "
" case" . ToQuantity ( 5 , ShowQuantityAs . None ) => "cases"También hay una sobrecarga que le permite formatear el número. Puede pasar en el formato y la cultura que se utilizará.
"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 convierte un número en una cadena ordinal utilizada para denotar la posición en una secuencia ordenada, como la primera, 2da, 3ª, 4ª:
1 . Ordinalize ( ) => "1st"
5 . Ordinalize ( ) => "5th" También puede llamar a Ordinalize en una cadena numérica y lograr el mismo resultado: "21".Ordinalize() => "21st"
Ordinalize también apoya el género gramatical para ambas formas. Puede pasar un argumento a Ordinalize GrammaticalGender.Neuter especificar GrammaticalGender.Feminine GrammaticalGender.Masculine género se debe obtener el número.
// 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º"Obviamente, esto solo se aplica a algunas culturas. Para otros que pasan el género o no pasa en absoluto, no hace ninguna diferencia en el resultado.
Además, Ordinalize respalda las variaciones que aplican algunas culturas dependiendo de la posición del número ordado en una oración. Use la wordForm argumento para obtener un resultado u otro. Los valores posibles son WordForm.Abbreviation y WordForm.Normal . Puede combinar el argumento wordForm con el género, pero pasar este argumento cuando no es aplicable no hará ninguna diferencia en el resultado.
// 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 convierte las palabras de entrada a la carcasa del título; equivalente a "some title".Humanize(LetterCasing.Title)
Pascalize convierte las palabras de entrada a uppercamelcase, también eliminando los subrayadores y los espacios:
"some_title for something" . Pascalize ( ) => "SomeTitleForSomething" Camelize se comporta de manera idéntica a Pascalize , excepto que el primer carácter es minúscula:
"some_title for something" . Camelize ( ) => "someTitleForSomething" Underscore separa las palabras de entrada con un bajo:
"SomeTitle" . Underscore ( ) => "some_title" Dasherize y Hyphenate REEMPLAZO SUBIRSECORES CON DAPOS EN LA CARDA:
"some_title" . Dasherize ( ) => "some-title"
"some_title" . Hyphenate ( ) => "some-title" Kebaberize separa las palabras de entrada con guiones y todas las palabras se convierten en minúsculas
"SomeText" . Kebaberize ( ) => "some-text" Humanizer proporciona una API con fluidez para lidiar con DateTime y TimeSpan de la siguiente manera:
Métodos 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 )No hay API fluidas para un mes o año, ya que un mes podría tener entre 28 y 31 días y un año podría ser de 365 o 366 días.
Puede usar estos métodos para, por ejemplo, reemplazar
DateTime . Now . AddDays ( 2 ) . AddHours ( 3 ) . AddMinutes ( - 5 )con
DateTime . Now + 2 . Days ( ) + 3 . Hours ( ) - 5 . Minutes ( ) También hay tres categorías de métodos fluidos para tratar 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 yeary algunos métodos de extensión:
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 ( ) Obviamente también podrías encadenar los métodos; por ejemplo On.November.The13th.In(2010).AtNoon + 5.Minutes()
Humanizer proporciona una API fluida que produce (generalmente grandes) números de manera más clara:
1.25 . Billions ( ) => 1250000000
3 . Hundreds ( ) . Thousands ( ) => 300000 Humanizer puede cambiar los números a palabras utilizando la extensión 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" También puede aprobar un segundo argumento, GrammaticalGender , a ToWords GrammaticalGender.Neuter especificar GrammaticalGender.Feminine qué género GrammaticalGender.Masculine ser el número.
// 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 ( ) => "ناقص واحد"Obviamente, esto solo se aplica a algunas culturas. Para otros que pasa el género no hace ninguna diferencia en el resultado.
Además, la cultura para usar se puede especificar explícitamente. Si no es así, se usa la cultura de interfaz de usuario actual del hilo actual. Aquí hay un ejemplo:
11 . ToWords ( new CultureInfo ( "en" ) ) => "eleven"
1 . ToWords ( GrammaticalGender . Masculine , new CultureInfo ( "ru" ) ) => "один"Otra sobrecarga del método le permite pasar un bool para eliminar el "y" que se puede agregar antes del último número:
3501 . ToWords ( false ) => "three thousand five hundred one"
102 . ToWords ( false ) => "one hundred two"Este método puede ser útil para escribir cheques, por ejemplo.
Además, ToWords admite variaciones que aplican algunas culturas dependiendo de la posición del número en una oración. Use la wordForm argumento para obtener un resultado u otro. Los valores posibles son WordForm.Abbreviation y WordForm.Normal . Este argumento se puede combinar con el resto de los argumentos presentados anteriormente. Pasar el argumento wordForm en cuándo no es aplicable no hará ninguna diferencia en el resultado.
// 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" Esto es un tipo de mezcla ToWords con Ordinalize . ¡Puede llamar ToOrdinalWords en un número para obtener una representación ordinal del número en palabras! Por ejemplo:
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 también es compatible con el género gramatical. Puede pasar un segundo argumento a ToOrdinalWords para especificar el género de la salida. Los valores posibles son GrammaticalGender.Masculine , GrammaticalGender.Feminine y 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 ) => "الثاني"Obviamente, esto solo se aplica a algunas culturas. Para otros que pasa el género no hace ninguna diferencia en el resultado.
Además, la cultura para usar se puede especificar explícitamente. Si no es así, se usa la cultura de interfaz de usuario actual del hilo actual. Aquí hay un ejemplo:
10 . ToOrdinalWords ( new CultureInfo ( "en-US" ) ) => "tenth"
1 . ToOrdinalWords ( GrammaticalGender . Masculine , new CulureInfo ( "pt-BR" ) ) => "primeiro" ToOrdinalWords también admite variaciones que aplican algunas culturas dependiendo de la posición del número ordinado en una oración. Use la wordForm argumento para obtener un resultado u otro. Los valores posibles son WordForm.Abbreviation y WordForm.Normal . Combine este argumento con el resto de los argumentos presentados anteriormente. Pasar el argumento wordForm en cuándo no es aplicable no hará ninguna diferencia en el resultado.
// 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"Esta es una especie de extensión de 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 también es compatible con el caso gramatical. Puede pasar un segundo argumento a ToOrdinalWords para especificar el caso de la salida. GrammaticalGender.Prepositional valores posibles GrammaticalCase.Accusative GrammaticalCase.Instrumental GrammaticalCase.Dative GrammaticalCase.Nominative GrammaticalCase.Genitive
Obviamente, esto solo se aplica a algunas culturas. Para otros, el caso de pasar no hace ninguna diferencia en el resultado.
Extiende el tiempo de tiempo para permitir que humanizarlo a una notación de reloj
// 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" El humanizador puede cambiar los números a números romanos utilizando la extensión ToRoman . Los números 1 a 10 se pueden expresar en números romanos de la siguiente manera:
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" También la operación inversa utilizando la extensión FromRoman .
"I" . FromRoman ( ) => 1
"II" . FromRoman ( ) => 2
"III" . FromRoman ( ) => 3
"IV" . FromRoman ( ) => 4
"V" . FromRoman ( ) => 5Tenga en cuenta que solo los enteros menores de 4000 pueden convertirse en números romanos.
El humanizador puede cambiar los números a números métricos utilizando la extensión ToMetric . Los números 1, 1230 y 0.1 se pueden expresar en números métricos de la siguiente manera:
1d . ToMetric ( ) => "1"
1230d . ToMetric ( ) => "1.23k"
0.1d . ToMetric ( ) => "100m" También la operación inversa utilizando la extensión FromMetric .
"1" . FromMetric ( ) => 1
"1.23k" . FromMetric ( ) => 1230
"100m" . FromMetric ( ) => 0.1 Humanizer incluye un puerto de la brillante Biblioteca Bytesize. Se realizan bastantes cambios y adiciones en ByteSize para hacer que la interacción con ByteSize sea más fácil y más consistente con la API de humanizador. Aquí hay algunos ejemplos de cómo puede convertir de números a tamaños de bytes y magnitudes de tamaño:
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-9Hay algunos métodos de extensión que le permiten convertir un número en una instancia de bytesize:
3 . Bits ( ) ;
5 . Bytes ( ) ;
( 10.5 ) . Kilobytes ( ) ;
( 2.5 ) . Megabytes ( ) ;
( 10.2 ) . Gigabytes ( ) ;
( 4.7 ) . Terabytes ( ) ;También puede sumar/restar los valores utilizando +/- Métodos de operadores y sumar/restar:
var total = ( 10 ) . Gigabytes ( ) + ( 512 ) . Megabytes ( ) - ( 2.5 ) . Gigabytes ( ) ;
total . Subtract ( ( 2500 ) . Kilobytes ( ) ) . Add ( ( 25 ) . Megabytes ( ) ) ; Un objeto ByteSize contiene dos propiedades que representan el símbolo y el valor de prefijo métrico más grande:
var maxFileSize = ( 10 ) . Kilobytes ( ) ;
maxFileSize . LargestWholeNumberSymbol ; // "KB"
maxFileSize . LargestWholeNumberValue ; // 10 Si desea una representación de cadena, puede llamar ToString o Humanize indistintamente en la instancia 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 También puede proporcionar opcionalmente un formato para la representación de cadena esperada. El formato puede contener el símbolo del valor para mostrar: b , B , KB , MB , GB , TB . El formateador utiliza el método de double.ToString incorporado con #.## como el formato predeterminado que redondea el número a dos decimales:
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 desea una representación de cadena con palabras completas, puede llamar ToFullWords en la instancia 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 No hay un método Dehumanize para convertir una representación de cadena en una instancia ByteSize ; Pero puede usar Parse e TryParse en ByteSize para hacerlo. Al igual que otros métodos TryParse , ByteSize.TryParse Devuelve el valor boolean que indica si el análisis fue exitoso o no. Si se analiza el valor, se emite al parámetro out suministrado:
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" ) ; Finalmente, si necesita calcular la velocidad a la que se ha transferido una cantidad de bytes, puede usar el método Per método de ByteSize . El método Per método acepta un argumento: el intervalo de medición para los bytes; Esta es la cantidad de tiempo que tardó en transferir los bytes.
El método Per método devuelve una clase ByteRate que tiene un método Humanize . Por defecto, las tasas se dan en segundos (por ejemplo, MB/S). Sin embargo, si lo desea, se puede pasar una unidad de tiempo a Humanize para un intervalo alternativo. TimeUnit.Minute intervalos válidos son TimeUnit.Second TimeUnit.Hour Ejemplos de cada intervalo y uso de la tasa de bytes de ejemplo están a continuación.
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/hourPuede especificar un formato para la parte bytes de la salida humanizada:
19854651984 . Bytes ( ) . Per ( 1 . Seconds ( ) ) . Humanize ( "#.##" ) ;
// 18.49 GB/s El humanizador incluye métodos para cambiar un rumbo numérico a las palabras. El encabezado puede ser un double mientras que el resultado será una cadena. Puede elegir si debe devolver una representación completa del encabezado (por ejemplo, norte, este, sur o oeste), una representación corta (por ejemplo, N, E, S, W) o un carácter de flecha Unicode (por ejemplo, ↑, →, ↓, ←).
360 . ToHeading ( ) ;
// N
720 . ToHeading ( ) ;
// NPara recuperar una versión completa del encabezado, use la siguiente llamada:
180 . ToHeading ( HeadingStyle . Full ) ;
// south
360 . ToHeading ( HeadingStyle . Full ) ;
// northTenga en cuenta que una representación textual tiene una desviación máxima de 11.25 °.
Los métodos sobre todo tienen una sobrecarga con la que puede proporcionar un objeto CultureInfo para determinar el resultado localizado para devolver.
Para recuperar una flecha que representa el encabezado, use el siguiente método:
90 . ToHeadingArrow ( ) ;
// →
225 . ToHeadingArrow ( ) ;
// ↙La representación de la flecha del encabezado tiene una desviación máxima de 22.5 °.
Para recuperar un encabezado basado en la representación de texto corto (por ejemplo, E, S, W), se puede utilizar el siguiente método:
"S" . FromShortHeading ( ) ;
// 180
"SW" . FromShortHeading ( ) ;
// 225 El humanizador puede cambiar los números enteros en su 'tuple' usando Tupleize . Por ejemplo:
1 . Tupleize ( ) ;
// single
3 . Tupleize ( ) ;
// triple
100 . Tupleize ( ) ;
// centupleLos números 1-10, 100 y 1000 se convertirán en una tupla 'llamada' (es decir, "single", "doble", etc.). Cualquier otro número "n" se convertirá en "n-tuple".
El humanizador puede traducir unidades de tiempo a sus símbolos:
TimeUnit . Day . ToSymbol ( ) ;
// d
TimeUnit . Week . ToSymbol ( ) ;
// week
TimeUnit . Year . ToSymbol ( ) ;
// y Esto es solo una línea de base y puede usar esto para simplificar su trabajo diario. Por ejemplo, en ASP.NET MVC seguimos el atributo Display en las propiedades de ViewModel para que HtmlHelper pueda generar etiquetas correctas para nosotros; Pero, al igual que enums, en la gran mayoría de los casos, solo necesitamos un espacio entre las palabras en el nombre de la propiedad, entonces, ¿por qué no usar "string".Humanize para eso?
Puede encontrar una muestra ASP.NET MVC en el código que lo hace (aunque el proyecto está excluido del archivo de solución para que el paquete Nuget esté disponible para .NET 3.5 también).
Esto se logra utilizando un DataAnnotationsModelMetadataProvider personalizado que llamé humanizeMetAdataprovider. Es lo suficientemente pequeño como para repetir aquí; Así que aquí vamos:
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 ;
}
} Esta clase llama a la clase base para extraer los metadatos y luego, si es necesario, humaniza el nombre de la propiedad. Está comprobando si la propiedad ya tiene un DisplayName o atributo Display en cuyo caso el proveedor de metadatos solo honrará el atributo y dejará solo la propiedad. Para otras propiedades, humanizará el nombre de la propiedad. Eso es todo.
Ahora debe registrar este proveedor de metadatos en ASP.NET MVC. Asegúrese de usar System.Web.Mvc.ModelMetadataProviders , y no System.Web.ModelBinding.ModelMetadataProviders :
ModelMetadataProviders . Current = new HumanizerMetadataProvider ( ) ;... y ahora puedes reemplazar:
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 ; }
}con:
public class RegisterModel
{
public string UserName { get ; set ; }
public string EmailAddress { get ; set ; }
public string ConfirmPassword { get ; set ; }
}... y el "humanizador de metadatos" se encargará del resto.
No es necesario mencionar que si desea carcasa de título para sus etiquetas, puede encadenar el método con Transform :
modelMetadata . DisplayName = modelMetadata . PropertyName . Humanize ( ) . Transform ( To . TitleCase ) ; Humanizer es una biblioteca de clase portátil. Actualmente hay un problema si intenta usar PCL en una vista MVC ya que las vistas de MVC no comparten el mismo sistema de compilación que el proyecto regular. Debe especificar todas las referencias en el archivo web.config , incluidos las que el sistema del proyecto normalmente agrega automáticamente.
Si encuentra errores que dicen que debe agregar una referencia a System.Runtime o System.Globalization , esto se aplica a usted. La solución es agregar las referencias del contrato a su web.config como se enumera aquí. Tenga en cuenta que esto se aplica a cualquier PCL que use en una vista MVC, no solo humanizador.
El proyecto Humanizer es construido y probado continuamente por Azure DevOps (más detalles aquí). Eso también se aplica a las solicitudes de extracción. Poco después de enviar un PR, puede verificar la notificación de estado de compilación y prueba en su PR.
El estado de compilación actual en el servidor CI es
A continuación se muestra una lista de proyectos de código abierto relacionados:
Si usa Resharper, las anotaciones para humanizador están disponibles en el paquete Humanizer.annotations, que puede obtener a través del administrador de extensión de Resharper. Estas anotaciones aún no cubren toda la biblioteca, ¡pero las solicitudes de extracción siempre son bienvenidas!
PowerShell Humanizer es un módulo PowerShell que envuelve humanizador.
Humanizer.jvm es una adaptación del marco humanizador para .NET que está hecho para el JVM y está escrito en Kotlin. Humanizer.jvm satisface todas sus necesidades de JVM para manipular y mostrar cuerdas, enums, fechas, tiempos, pasos de tiempo, números y cantidades.
Humanizer.node es un puerto mecanografiado del marco de humanizador.
Ícono creado por Tyrone Rieschiek
