Humanizer
v3.0.0-beta.54
HumanizadorO humanizador atende a todas as suas necessidades .NET para manipular e exibir cordas, enumistas, datas, tempos, tempo, números e quantidades.
Você pode instalar o Humanizer como um pacote NUGET:
Somente inglês : Humanizer.Core
Todas as línguas: Humanizer
As seguintes estruturas são suportadas: net4.8, net6, net7 e net8
NOTA: O NUGET também tem como alvo o NetStandard2. Isso é para ativar o cenário em que o NetStandard2 é necessário. Por exemplo, analisadores de Roslyn ou tarefas msbuild. Outras estruturas (exceto listadas acima) que podem consumir NetStandard2 (Exemplo Net4.6.1 a Net 4.7.2) não são suportadas. Por exemplo, net4.6.1 a net4.7.2 não são suportados.
Os símbolos do humanizador também são indexados com o Sourcelink e estão incluídos no pacote para que você possa passar pelo código do Humanizer enquanto depura seu código.
Você escolhe quais pacotes com base no (s) pacote NUGET (s) você instala. Por padrão, o principal pacote Humanizer 2.0 instala todos os idiomas suportados exatamente como no 1.x. Se você não tiver certeza, basta usar o pacote principal Humanizer .
Aqui estão as opções:
Humanizer . Isso puxa o Humanizer.Core e todos os pacotes de idiomas.Humanizer.Core . Somente os recursos do idioma inglês estarão disponíveisHumanizer.Core.fr . Você pode incluir vários idiomas instalando o número de pacotes de idiomas que desejar.A explicação detalhada de como isso funciona é nos comentários aqui.
Extensões de string Humanize permitem que você transforme uma string computadorizada em uma outra mais legível para o ser humano. A base disso foi estabelecida na estrutura BDDFY, onde nomes de classe, nomes de métodos e propriedades são transformados em frases legíveis humanas.
"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" Observe que uma sequência que contém apenas letras maiúsculas e consiste apenas de uma palavra, é sempre tratada como um acrônimo (independentemente de seu comprimento). Para garantir que qualquer string arbitrária seja sempre humanizada, você deve usar uma transformação (consulte o método Transform abaixo):
// 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"Você também pode especificar o invólucro de carta desejado:
"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"A API
LetterCasinge os métodos que a aceitam são o legado da era v0.2 e serão preteridos no futuro. Em vez disso, você pode usar o métodoTransformexplicado abaixo.
Assim como você pode humanizar um computador amigável em cordas amigáveis ao humano, você pode desumanizar uma corda amigável humana em um computador amigável:
"Pascal case input string is turned into sentence" . Dehumanize ( ) => "PascalCaseInputStringIsTurnedIntoSentence" Existe um método Transform que substitui as sobrecargas LetterCasing , ApplyCase e Humanize que aceitam LetterCasing . A assinatura do método de transformação é a seguinte:
string Transform ( this string input , params IStringTransformer [ ] transformers ) E há algumas implementações prontas para a caixa do IStringTransformer para a carcaça:
"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 é uma propriedade estática pública para To aula que retorna uma instância da classe privada ToLowerCase que implementa IStringTransformer e sabe como transformar uma string em minúsculas.
O benefício de usar Transform e IStringTransformer sobre ApplyCase e LetterCasing é que LetterCasing é uma enumeração e você está limitado a usar o que está na estrutura, enquanto IStringTransformer é uma interface que você pode implementar na sua base de código uma vez e usá -lo com o método Transform permitindo uma extensão fácil.
Você pode truncar uma string usando o método Truncate :
"Long text to truncate" . Truncate ( 10 ) => "Long text…" Por padrão, o personagem '…' é usado para truncar strings. A vantagem de usar o personagem '…' em vez de "..." é que o primeiro pega apenas um único caractere e, portanto, permite que mais texto seja mostrado antes do truncamento. Se quiser, você também pode fornecer sua própria string de truncamento:
"Long text to truncate" . Truncate ( 10 , "---" ) => "Long te -- - " A estratégia de truncamento padrão, Truncator.FixedLength , é truncar a sequência de entrada para um comprimento específico, incluindo o comprimento da string de truncamento. Existem mais duas estratégias de truncador disponíveis: uma para um número fixo de caracteres (alfa-numéricos) e outro para um número fixo de palavras. Para usar um truncador específico ao truncando, os dois métodos Truncate mostrados nos exemplos anteriores têm uma sobrecarga que permite especificar a instância ITruncator a ser usada para o truncamento. Aqui estão exemplos de como usar os três truncadores fornecidos:
"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---" Observe que você também pode usar Criar seu próprio truncador implementando a interface ITruncator .
Há também uma opção para escolher se deve truncar a string a partir do início ( TruncateFrom.Left ) ou o final ( TruncateFrom.Right ). O padrão é o certo, conforme mostrado nos exemplos acima. Os exemplos abaixo mostram como truncar desde o início da string:
"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" Chamar ToString diretamente nos membros da enum geralmente resulta em saída inferior ao ideal para os usuários. A solução para isso geralmente é usar a anotação de dados DescriptionAttribute e, em seguida, leia isso no tempo de execução para obter uma saída mais amigável. Essa é uma ótima solução; Mas, na maioria das vezes, precisamos apenas colocar algum espaço entre as palavras de um membro da enum - que é o que String.Humanize() faz bem. Para um enume
public enum EnumUnderTest
{
[ Description ( "Custom description" ) ]
MemberWithDescriptionAttribute ,
MemberWithoutDescriptionAttribute ,
ALLCAPITALS
}Você vai conseguir:
// 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" Você não está limitado ao DescriptionAttribute da descrição personalizada. Qualquer atributo aplicado nos membros da enum com uma contagem de propriedades string Description . Isso é para ajudar com plataformas com a falta DescriptionAttribute e também para permitir subclasses do DescriptionAttribute .
Você pode até configurar o nome da propriedade do Atttbtion para usar como descrição.
Configurator.EnumDescriptionPropertyLocator = p => p.Name == "Info"
Se você precisar fornecer descrições localizadas, poderá usar DisplayAttribute Data Anotation.
public enum EnumUnderTest
{
[ Display ( Description = "EnumUnderTest_Member" , ResourceType = typeof ( Project . Resources ) ) ]
Member
}Você vai conseguir:
EnumUnderTest . Member . Humanize ( ) => "content" // from Project.Resources found under "EnumUnderTest_Member" resource keyEspero que isso ajude a evitar enumes de lixo com atributos desnecessários!
Desumaniza uma corda na enumeração de onde foi originalmente humanizada! A API parece:
public static TTargetEnum DehumanizeTo < TTargetEnum > ( this string input )E o uso é:
"Member without description attribute" . DehumanizeTo < EnumUnderTest > ( ) => EnumUnderTest . MemberWithoutDescriptionAttribute E, assim como a API Humanize, ele homenageia o atributo Description . Você não precisa fornecer o invólucro que você forneceu durante a humanização: ele a descobre.
Há também uma contraparte não genérica para quando a enumeração original não é conhecida no momento da compilação:
public static Enum DehumanizeTo ( this string input , Type targetEnum , NoMatch onNoMatch = NoMatch . ThrowsException )que pode ser usado como:
"Member without description attribute" . DehumanizeTo ( typeof ( EnumUnderTest ) ) => EnumUnderTest . MemberWithoutDescriptionAttribute Por padrão, ambos os métodos lançam um NoMatchFoundException quando não conseguem corresponder à entrada fornecida com a enumeração de destino. No método não genérico, você também pode solicitar ao método que retorne nulo, definindo o segundo parâmetro opcional como NoMatch.ReturnsNull .
Você pode Humanize uma instância do DateTime ou DateTimeOffset e recuperar uma string, dizendo a que distância é o tempo ou a frente no tempo:
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" O Humanizer suporta datas locais e UTC, bem como datas com deslocamento ( DateTimeOffset ). Você também pode fornecer a data em que deseja que a data de entrada seja comparada. Se nulo, ele usará a data atual como base de comparação. Além disso, a cultura a ser usada pode ser especificada explicitamente. Caso contrário, a cultura atual da interface do encadeamento atual é usada. Aqui está a assinatura da 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 )Muitas localizações estão disponíveis para este método. Aqui estão alguns exemplos:
// 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 минут назад" Existem duas estratégias para DateTime.Humanize : o padrão, como visto acima e uma de precisão. Para usar a estratégia baseada em precisão, você precisa configurá -la:
Configurator . DateTimeHumanizeStrategy = new PrecisionDateTimeHumanizeStrategy ( precision : .75 ) ;
Configurator . DateTimeOffsetHumanizeStrategy = new PrecisionDateTimeOffsetHumanizeStrategy ( precision : .75 ) ; // configure when humanizing DateTimeOffsetA precisão padrão é definida como 0,75, mas você também pode passar a precisão desejada. Com precisão definida como 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 Nenhuma desumanização para datas, pois Humanize é uma transformação com perdas e a data amigável humana não é reversível
Você pode ligar para Humanize em um TimeSpan para obter uma representação amigável humana:
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 um parâmetro precision opcional para TimeSpan.Humanize que permite especificar a precisão do valor retornado. O valor padrão da precision é 1, o que significa que apenas a maior unidade de tempo é retornada como você viu no TimeSpan.FromDays(16).Humanize() Aqui estão alguns exemplos de especificação de precisão:
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 padrão, ao usar o parâmetro precision , as unidades de tempo vazias não são contadas para a precisão do valor retornado. Se esse comportamento não for desejado para você, você poderá usar o método de TimeSpan.Humanize sobrecarregado com o parâmetro countEmptyUnits . As unidades de tempo vazias líderes nunca contam. Aqui está um exemplo que mostra a diferença de contar unidades vazias:
TimeSpan . FromMilliseconds ( 3603001 ) . Humanize ( 3 ) => "1 hour, 3 seconds, 1 millisecond"
TimeSpan . FromMilliseconds ( 3603001 ) . Humanize ( 3 , countEmptyUnits : true ) => "1 hour, 3 seconds"Muitas localizações estão disponíveis 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"A cultura a ser usada pode ser especificada explicitamente. Caso contrário, a cultura atual da interface do encadeamento atual é usada. Exemplo:
TimeSpan . FromDays ( 1 ) . Humanize ( culture : "ru-RU" ) => "один день"Além disso, uma unidade mínima de tempo pode ser especificada para evitar rolar para uma unidade menor. Por exemplo:
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 HourAlém disso, uma unidade máxima de tempo pode ser especificada para evitar rolar para a próxima maior unidade. Por exemplo:
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 O MaxUnit padrão é TimeUnit.Week porque fornece resultados exatos. Você pode aumentar esse valor para TimeUnit.Month ou TimeUnit.Year , que fornecerá uma aproximação com base em 365.2425 dias por ano e 30.436875 dias por mês. Portanto, os meses estão alternando entre 30 e 31 dias de duração e a cada quarto ano tem 366 dias de duração.
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 Quando existem várias unidades de tempo, elas são combinadas usando a string ", " :
TimeSpan . FromMilliseconds ( 1299630020 ) . Humanize ( 3 ) => "2 weeks, 1 day, 1 hour" Quando TimeSpan é zero, o comportamento padrão retornará "0", além de qualquer que seja a unidade de tempo mínimo. No entanto, se você atribuir true a toWords ao chamar Humanize , o método retornará "sem tempo". Por exemplo:
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 o parâmetro collectionSeparator , você pode especificar sua própria string separadora:
TimeSpan . FromMilliseconds ( 1299630020 ) . Humanize ( 3 , collectionSeparator : " - " ) => "2 weeks - 1 day - 1 hour" Também é possível usar o formatador de coleção da cultura atual para combinar as unidades de tempo. Para fazer isso, especifique null como o 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" Se as palavras forem preferidas aos números, um parâmetro toWords: true pode ser definido para converter os números em um timepan humanizado em palavras:
TimeSpan . FromMilliseconds ( 1299630020 ) . Humanize ( 3 , toWords : true ) => "two weeks, one day, one hour" Ao chamar ToAge , um TimeSpan também pode ser expresso como idade. Para culturas que não definem uma expressão de idade, o resultado será o mesmo que chamar Humanize (mas com uma maxUnit padrão igual a TimeUnit.Year ) .
// in en-US culture
TimeSpan . FromDays ( 750 ) . ToAge ( ) => "2 years old"
// in fr culture
TimeSpan . FromDays ( 750 ) . ToAge ( ) => "2 ans" Você pode ligar para Humanize em qualquer IEnumerable para obter uma string bem formatada, representando os objetos da coleção. Por padrão, ToString() será chamado em cada item para obter sua representação, mas uma função de formatação pode ser passada para Humanize . Além disso, um separador padrão é fornecido ("e" em inglês), mas um separador diferente pode ser transmitido para Humanize .
Por exemplo:
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"Os itens são aparados e os itens em branco (NullorWhitespace) são ignorados. Isso resulta em pontuação limpa de vírgula. (Se houver uma função de formatador personalizada, isso se aplica apenas à saída do formatador.)
Você pode fornecer seu próprio formatador de coleção implementando ICollectionFormatter e registrando -o com Configurator.CollectionFormatters .
Existem também alguns métodos de inflector:
Pluralize pluraliza a entrada fornecida enquanto leva em consideração palavras irregulares e incontáveis:
"Man" . Pluralize ( ) => "Men "
" string" . Pluralize ( ) => "strings" Normalmente, você chamaria Pluralize de uma palavra singular, mas se você não tiver certeza sobre a singularidade da palavra, você pode chamar o método com o argumento opcional inputIsKnownToBeSingular :
"Men" . Pluralize ( inputIsKnownToBeSingular : false ) => "Men "
" Man" . Pluralize ( inputIsKnownToBeSingular : false ) => "Men"
"string" . Pluralize ( inputIsKnownToBeSingular : false ) => "strings" A sobrecarga de Pluralize com o argumento plurality é obsoleta e foi removida na versão 2.0.
Singularize singulariza a entrada fornecida enquanto leva em consideração palavras irregulares e incontáveis:
"Men" . Singularize ( ) => "Man "
" strings" . Singularize ( ) => "string" Normalmente, você chamaria Singularize em uma palavra plural, mas se não tiver certeza sobre a pluralidade da palavra, você pode chamar o método com o argumento opcional inputIsKnownToBePlural :
"Men" . Singularize ( inputIsKnownToBePlural : false ) => "Man "
" Man" . Singularize ( inputIsKnownToBePlural : false ) => "Man"
"strings" . Singularize ( inputIsKnownToBePlural : false ) => "string" A sobrecarga do Singularize com o argumento plurality é obsoleta e foi removida na versão 2.0.
Às vezes, pode ser necessário adicionar uma regra do vocabulário de singularização/pluralização (os exemplos abaixo já estão no DefaultVocabulary usado pelo 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" ) ; Muitas vezes você deseja chamar Singularize e Pluralize para prefixar uma palavra com um número; por exemplo, "2 solicitações", "3 homens". ToQuantity prefixa a palavra fornecida com o número e, portanto, pluraliza ou singulariza a palavra:
"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 pode descobrir se a palavra de entrada é singular ou plural e singularizará ou pluralizará conforme necessário:
"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" Você também pode passar por um segundo argumento, ShowQuantityAs , para ToQuantity para especificar como deseja que a quantidade fornecida seja emitida. O valor padrão é ShowQuantityAs.Numeric , que é o que vimos acima. Os outros dois valores são ShowQuantityAs.Words e ShowQuantityAs.None .
"case" . ToQuantity ( 5 , ShowQuantityAs . Words ) => "five cases "
" case" . ToQuantity ( 5 , ShowQuantityAs . None ) => "cases"Há também uma sobrecarga que permite formatar o número. Você pode passar no formato e na cultura a ser usada.
"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 transforma um número em uma sequência ordinal usada para denotar a posição em uma sequência ordenada como 1ª, 2ª, 3ª, 4ª: 4ª:
1 . Ordinalize ( ) => "1st"
5 . Ordinalize ( ) => "5th" Você também pode chamar Ordinalize em uma string numérica e obter o mesmo resultado: "21".Ordinalize() => "21st"
Ordinalize também suporta gênero gramatical para ambas as formas. Você pode passar um argumento para Ordinalize para especificar em qual gênero o número deve ser produzido. Os valores possíveis são GrammaticalGender.Masculine , GrammaticalGender.Feminine e GrammaticalGender.Neuter :
// for Brazilian Portuguese locale
1 . Ordinalize ( GrammaticalGender . Masculine ) => "1º"
1 . Ordinalize ( GrammaticalGender . Feminine ) => "1ª"
1 . Ordinalize ( GrammaticalGender . Neuter ) => "1º"
"2" . Ordinalize ( GrammaticalGender . Masculine ) => "2º"
"2" . Ordinalize ( GrammaticalGender . Feminine ) => "2ª"
"2" . Ordinalize ( GrammaticalGender . Neuter ) => "2º"Obviamente, isso se aplica apenas a algumas culturas. Para outros, passar o gênero ou não passar não faz diferença no resultado.
Além disso, Ordinalize suporta variações que algumas culturas se aplicam, dependendo da posição do número ordinalizado em uma frase. Use o argumento wordForm para obter um resultado ou outro. Os valores possíveis são WordForm.Abbreviation e WordForm.Normal . Você pode combinar o argumento wordForm com o gênero, mas passar esse argumento quando não for aplicável não fará nenhuma diferença no 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 converte as palavras de entrada no revestimento do título; equivalente a "some title".Humanize(LetterCasing.Title)
Pascalize converte as palavras de entrada em uppercamelcase, também removendo sublinhados e espaços:
"some_title for something" . Pascalize ( ) => "SomeTitleForSomething" Camelize se comporta de forma idêntica a Pascalize , exceto que o primeiro caractere é minúsculo:
"some_title for something" . Camelize ( ) => "someTitleForSomething" Underscore separa as palavras de entrada com sublinhado:
"SomeTitle" . Underscore ( ) => "some_title" Dasherize e Hyphenate Substituem sublinhados por traços na string:
"some_title" . Dasherize ( ) => "some-title"
"some_title" . Hyphenate ( ) => "some-title" Kebaberize separa as palavras de entrada com hífens e todas as palavras são convertidas em minúsculas
"SomeText" . Kebaberize ( ) => "some-text" O Humanizer fornece uma API fluente para lidar com DateTime e TimeSpan da seguinte maneira:
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 )Não há APIs fluentes por mês ou ano, pois um mês pode ter entre 28 a 31 dias e um ano pode ser de 365 ou 366 dias.
Você pode usar esses métodos para, por exemplo, substituir
DateTime . Now . AddDays ( 2 ) . AddHours ( 3 ) . AddMinutes ( - 5 )com
DateTime . Now + 2 . Days ( ) + 3 . Hours ( ) - 5 . Minutes ( ) Existem também três categorias de métodos fluentes para lidar com 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 yeare alguns métodos de extensão:
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, você também pode encadear os métodos; por exemplo, On.November.The13th.In(2010).AtNoon + 5.Minutes()
O humanizador fornece uma API fluente que produz (geralmente grandes) números de maneira mais clara:
1.25 . Billions ( ) => 1250000000
3 . Hundreds ( ) . Thousands ( ) => 300000 O humanizador pode alterar números para palavras usando a extensão 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" Você também pode passar por um segundo argumento, GrammaticalGender , para ToWords para especificar em GrammaticalGender.Feminine gênero o número deve ser emitido. Os valores possíveis são GrammaticalGender.Masculine GrammaticalGender.Neuter
// 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, isso se aplica apenas a algumas culturas. Para outros, passar o gênero não faz diferença no resultado.
Além disso, a cultura a ser usada pode ser especificada explicitamente. Caso contrário, a cultura atual da interface do encadeamento atual é usada. Aqui está um exemplo:
11 . ToWords ( new CultureInfo ( "en" ) ) => "eleven"
1 . ToWords ( GrammaticalGender . Masculine , new CultureInfo ( "ru" ) ) => "один"Outra sobrecarga do método permite que você passe um bool para remover o "e" que pode ser adicionado antes do último número:
3501 . ToWords ( false ) => "three thousand five hundred one"
102 . ToWords ( false ) => "one hundred two"Este método pode ser útil para escrever cheques, por exemplo.
Além disso, ToWords suporta variações que algumas culturas se aplicam, dependendo da posição do número em uma frase. Use o argumento wordForm para obter um resultado ou outro. Os valores possíveis são WordForm.Abbreviation e WordForm.Normal . Esse argumento pode ser combinado com o restante dos argumentos apresentados acima. A transmissão wordForm argumentou quando não for aplicável, não fará nenhuma diferença no 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" Isso é uma espécie de ToWords com Ordinalize . Você pode ligar para ToOrdinalWords em um número para obter uma representação ordinal do número em palavras! Por exemplo:
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 também suporta gênero gramatical. Você pode passar um segundo argumento para ToOrdinalWords para especificar o gênero da saída. Os valores possíveis são GrammaticalGender.Masculine , GrammaticalGender.Feminine e 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, isso se aplica apenas a algumas culturas. Para outros, passar o gênero não faz diferença no resultado.
Além disso, a cultura a ser usada pode ser especificada explicitamente. Caso contrário, a cultura atual da interface do encadeamento atual é usada. Aqui está um exemplo:
10 . ToOrdinalWords ( new CultureInfo ( "en-US" ) ) => "tenth"
1 . ToOrdinalWords ( GrammaticalGender . Masculine , new CulureInfo ( "pt-BR" ) ) => "primeiro" ToOrdinalWords também suporta variações que algumas culturas se aplicam, dependendo da posição do número ordinalizado em uma frase. Use o argumento wordForm para obter um resultado ou outro. Os valores possíveis são WordForm.Abbreviation e WordForm.Normal . Combine esse argumento com o restante dos argumentos apresentados acima. A transmissão wordForm argumentou quando não for aplicável, não fará nenhuma diferença no 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 é uma espécie de extensão de ordenalizar
// 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 também suporta caso gramatical. Você pode passar um segundo argumento para ToOrdinalWords para especificar o caso da saída. GrammaticalGender.Prepositional GrammaticalCase.Instrumental GrammaticalCase.Dative GrammaticalCase.Accusative GrammaticalCase.Nominative GrammaticalCase.Genitive
Obviamente, isso se aplica apenas a algumas culturas. Para outras pessoas que passam, o caso não faz nenhuma diferença no resultado.
Estende -se tempo para permitir humanizá -lo a uma notação de relógio
// 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" O humanizador pode alterar números para algarismos romanos usando a extensão ToRoman . Os números 1 a 10 podem ser expressos em algarismos romanos da seguinte forma:
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" Também a operação reversa usando a extensão FromRoman .
"I" . FromRoman ( ) => 1
"II" . FromRoman ( ) => 2
"III" . FromRoman ( ) => 3
"IV" . FromRoman ( ) => 4
"V" . FromRoman ( ) => 5Observe que apenas números inteiros menores que 4000 podem ser convertidos em algarismos romanos.
O humanizador pode alterar números para números métricos usando a extensão ToMetric . Os números 1, 1230 e 0.1 podem ser expressos em números métricos da seguinte forma:
1d . ToMetric ( ) => "1"
1230d . ToMetric ( ) => "1.23k"
0.1d . ToMetric ( ) => "100m" Também a operação reversa usando a extensão FromMetric .
"1" . FromMetric ( ) => 1
"1.23k" . FromMetric ( ) => 1230
"100m" . FromMetric ( ) => 0.1 O humanizador inclui uma porta da brilhante biblioteca de bytesize. Algumas mudanças e adições são feitas no ByteSize para tornar a interação com ByteSize mais fácil e mais consistente com a API do humanizador. Aqui estão alguns exemplos de como você pode converter de números para tamanhos de bytes e entre magnitudes de tamanho:
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-9Existem alguns métodos de extensão que permitem transformar um número em uma instância de bytesize:
3 . Bits ( ) ;
5 . Bytes ( ) ;
( 10.5 ) . Kilobytes ( ) ;
( 2.5 ) . Megabytes ( ) ;
( 10.2 ) . Gigabytes ( ) ;
( 4.7 ) . Terabytes ( ) ;Você também pode adicionar/subtrair os valores usando os operadores +/- e adicionar/subtrair métodos:
var total = ( 10 ) . Gigabytes ( ) + ( 512 ) . Megabytes ( ) - ( 2.5 ) . Gigabytes ( ) ;
total . Subtract ( ( 2500 ) . Kilobytes ( ) ) . Add ( ( 25 ) . Megabytes ( ) ) ; Um objeto ByteSize contém duas propriedades que representam o maior símbolo e valor de prefixo métrico:
var maxFileSize = ( 10 ) . Kilobytes ( ) ;
maxFileSize . LargestWholeNumberSymbol ; // "KB"
maxFileSize . LargestWholeNumberValue ; // 10 Se você deseja uma representação de string, você pode ligar para ToString ou Humanize de forma intercambiável na instância 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 Opcionalmente, você também pode fornecer um formato para a representação de string esperada. O formatador pode conter o símbolo do valor a ser exibido: b , B , KB , MB , GB , TB . O formatador usa o método embutido em double.ToString com #.## como o formato padrão que arredonda o número para dois locais decimais:
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 Se você deseja uma representação de string com palavras completas, você pode chamar ToFullWords na instância 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 Não há um método Dehumanize para transformar uma representação de string de volta em uma instância ByteSize ; Mas você pode usar Parse e TryParse no ByteSize para fazer isso. Como outros métodos TryParse , ByteSize.TryParse Retorna o valor boolean indicando se a análise foi ou não bem -sucedida. Se o valor for analisado, ele será emitido para o parâmetro out fornecido:
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, se você precisar calcular a taxa na qual uma quantidade de bytes foi transferida, poderá usar o método Per ByteSize . O método Per aceita um argumento - o intervalo de medição para os bytes; Essa é a quantidade de tempo que levou para transferir os bytes.
O método Per retorna uma classe ByteRate que possui um método Humanize . Por padrão, as taxas são fornecidas em segundos (por exemplo, MB/S). No entanto, se desejar, uma unidade de tempo pode ser passada para Humanize para um intervalo alternativo. Intervalos válidos são TimeUnit.Second , TimeUnit.Minute e TimeUnit.Hour . Exemplos de cada intervalo e exemplo de uso da taxa de bytes estão abaixo.
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/hourVocê pode especificar um formato para a parte bytes da saída humanizada:
19854651984 . Bytes ( ) . Per ( 1 . Seconds ( ) ) . Humanize ( "#.##" ) ;
// 18.49 GB/s O humanizador inclui métodos para alterar um caminho numérico para as palavras. O cabeçalho pode ser double , enquanto o resultado será uma string. Você pode escolher se deve retornar uma representação completa do cabeçalho (por exemplo, norte, leste, sul ou oeste), uma breve representação (por exemplo, e, e, s, w) ou um caractere de seta Unicode (por exemplo, ↑, →, ↓, ←).
360 . ToHeading ( ) ;
// N
720 . ToHeading ( ) ;
// NPara recuperar uma versão completa do cabeçalho, use a seguinte chamada:
180 . ToHeading ( HeadingStyle . Full ) ;
// south
360 . ToHeading ( HeadingStyle . Full ) ;
// northObserve que uma representação textual tem um desvio máximo de 11,25 °.
Os métodos acima de tudo têm uma sobrecarga com a qual você pode fornecer um objeto CultureInfo para determinar o resultado localizado para retornar.
Para recuperar uma seta que representa o título, use o seguinte método:
90 . ToHeadingArrow ( ) ;
// →
225 . ToHeadingArrow ( ) ;
// ↙A representação de seta do cabeçalho tem um desvio máximo de 22,5 °.
Para recuperar um título com base na representação de texto curto (por exemplo, e, e, s, w), o seguinte método pode ser usado:
"S" . FromShortHeading ( ) ;
// 180
"SW" . FromShortHeading ( ) ;
// 225 O humanizador pode transformar números inteiros em sua 'tupla' usando Tupleize . Por exemplo:
1 . Tupleize ( ) ;
// single
3 . Tupleize ( ) ;
// triple
100 . Tupleize ( ) ;
// centupleOs números 1-10, 100 e 1000 serão convertidos em uma tupla 'nomeada' (ou seja, "single", "duplo" etc.). Qualquer outro número "n" será convertido para "n-tuple".
O humanizador pode traduzir unidades de tempo para seus símbolos:
TimeUnit . Day . ToSymbol ( ) ;
// d
TimeUnit . Week . ToSymbol ( ) ;
// week
TimeUnit . Year . ToSymbol ( ) ;
// y Isso é apenas uma linha de base e você pode usar isso para simplificar seu trabalho diário. Por exemplo, no ASP.NET MVC, continuamos atingindo o atributo Display nas propriedades do ViewModel, para que HtmlHelper possa gerar rótulos corretos para nós; Mas, assim como enums, na grande maioria dos casos, precisamos apenas de um espaço entre as palavras em nome da propriedade - então por que não usar "string".Humanize para isso?!
Você pode encontrar uma amostra ASP.NET MVC no código que faz isso (embora o projeto seja excluído do arquivo de solução para disponibilizar o pacote NUGET para .NET 3.5).
Isso é alcançado usando um DataAnnotationsModelMetadataProvider CUSTAL que eu chamei de HumanizerMetadataProvider. É pequeno o suficiente para repetir aqui; Então, aqui vamos nós:
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 classe chama a classe base para extrair os metadados e, se necessário, humaniza o nome da propriedade. Ele está verificando se a propriedade já tiver um atributo DisplayName ou Display nele, caso em que o provedor de metadados apenas honrará o atributo e deixará a propriedade em paz. Para outras propriedades, ele humanizará o nome da propriedade. Isso é tudo.
Agora você precisa registrar esse provedor de metadados no ASP.NET MVC. Certifique -se de usar System.Web.Mvc.ModelMetadataProviders , e não System.Web.ModelBinding.ModelMetadataProviders :
ModelMetadataProviders . Current = new HumanizerMetadataProvider ( ) ;... e agora você pode substituir:
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 ; }
}com:
public class RegisterModel
{
public string UserName { get ; set ; }
public string EmailAddress { get ; set ; }
public string ConfirmPassword { get ; set ; }
}... e o "humanizador de metadados" cuidará do resto.
Não há necessidade de mencionar que, se você deseja revestimento de título para seus rótulos, pode encadear o método com Transform :
modelMetadata . DisplayName = modelMetadata . PropertyName . Humanize ( ) . Transform ( To . TitleCase ) ; O humanizador é uma biblioteca de classes portátil. Atualmente, existe um problema se você tentar usar os PCLs em uma visualização do MVC, pois as visualizações do MVC não compartilham o mesmo sistema de construção que o projeto regular. Você deve especificar todas as referências no arquivo web.config , incluindo as que o sistema de projeto normalmente adiciona automaticamente.
Se você encontrar erros dizendo que deve adicionar uma referência a System.Runtime ou System.Globalization , isso se aplica a você. A solução é adicionar as referências do contrato à sua web.config conforme listado aqui. Observe que isso se aplica a qualquer PCL que você use em uma visualização do MVC, não apenas do humanizador.
O Projeto Humanizer é construído e testado continuamente pelo Azure DevOps (mais detalhes aqui). Isso se aplica a solicitações também. Logo após enviar um PR, você pode verificar a notificação de status de compilação e teste em seu PR.
O status de construção atual no servidor de CI é
Abaixo está uma lista de projetos de código aberto relacionados:
Se estiver usando o Resharper, as anotações do Humanizer estão disponíveis no pacote Humanizer.Annotações, que você pode obter através do RESHARPER Extension Manager. Essas anotações ainda não cobrem a biblioteca inteira, mas os pedidos de tração são sempre bem -vindos!.
O Humanizador do PowerShell é um módulo PowerShell que envolve o humanizador.
Humanizer.jvm é uma adaptação da estrutura do humanizador para .NET, que é feita para a JVM e é escrita em Kotlin. Humanizer.jvm atende a todas as suas necessidades de JVM para manipular e exibir cordas, enumistas, datas, horários, tempo, números e quantidades.
Humanizer.Node é uma porta datilografada da estrutura do humanizador.
Ícone criado por Tyrone Rieschiek
