Humanizer
v3.0.0-beta.54
휴먼 라이저Humanizer는 문자열, 열거, 날짜, 시간, 타임 스팬, 숫자 및 수량 조작 및 표시에 대한 모든 .NET 요구를 충족합니다.
Nuget 패키지로 Humanizer를 설치할 수 있습니다.
영어 전용 : Humanizer.Core
모든 언어 : Humanizer
다음 프레임 워크가 지원됩니다 : Net4.8, Net6, Net7 및 Net8
참고 : Nuget은 또한 Netstandard2를 대상으로합니다. 이는 Netstandard2가 필요한 시나리오를 활성화하기위한 것입니다. 예를 들어 Roslyn 분석기 또는 MSBuild 작업. Netstandard2 (예를 들어 Net4.6.1에서 Net 4.7.2까지)를 소비 할 수있는 다른 프레임 워크 (위에 나열된 이외)는 지원되지 않습니다. 예를 들어 Net4.6.1에서 Net4.7.2까지는 지원되지 않습니다.
또한 Humanizer Symbol은 SourcelInk와 함께 인덱싱 된 소스이며 패키지에 포함되므로 코드를 디버깅하는 동안 Humanizer 코드를 진행할 수 있습니다.
설치 한 Nuget 패키지를 기반으로 어떤 패키지를 선택하십시오. 기본적으로 Main Humanizer 2.0 패키지는 1.x에서와 마찬가지로 지원되는 모든 언어를 설치합니다. 확실하지 않으면 메인 Humanizer 패키지 만 사용하십시오.
다음은 다음과 같습니다.
Humanizer 패키지를 사용하십시오. 이것은 Humanizer.Core 와 모든 언어 패키지를 가져옵니다.Humanizer.Core 패키지를 사용하십시오. 영어 자료 만 사용할 수 있습니다Humanizer.Core.fr 사용하십시오. 원하는 많은 언어 패키지를 설치하여 여러 언어를 포함시킬 수 있습니다.이 작동 방식에 대한 자세한 설명은 여기에 의견에 있습니다.
Humanize 문자열 확장은 다른 전산화 된 문자열을보다 읽기 쉬운 인간 친화적 인 문자열로 바꿀 수 있습니다. 이것의 기초는 클래스 이름, 메소드 이름 및 속성이 사람이 읽을 수있는 문장으로 바뀌는 BDDFY 프레임 워크에 설정되었습니다.
"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" 상류 문자 만 포함하고 한 단어 만 구성된 문자열은 항상 약어로 취급됩니다 (길이에 관계없이). 임의의 모든 문자열이 항상 인간화되도록 보장하려면 변환을 사용해야합니다 (아래 Transform 방법 참조).
// 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"원하는 문자 케이스를 지정할 수도 있습니다.
"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"API를 수용하는
LetterCasingAPI와 방법은 V0.2 시대의 유산이며 향후 더 이상 사용되지 않습니다. 그 대신 아래 설명 된Transform방법을 사용할 수 있습니다.
컴퓨터 친화적 인 인간 친화적 인 끈으로 인간화 할 수있는 것처럼 인간 친화적 인 끈을 컴퓨터 친화적 인 문자열로 비인간화할 수 있습니다.
"Pascal case input string is turned into sentence" . Dehumanize ( ) => "PascalCaseInputStringIsTurnedIntoSentence" LetterCasing 대체하고 ApplyCase 하고 Humanize 과부하 LetterCasing 대체하는 Transform 방법이 있습니다. 변환 방법 서명은 다음과 같습니다.
string Transform ( this string input , params IStringTransformer [ ] transformers ) 그리고 문자 케이싱을위한 IStringTransformer 의 상자 구현 중 일부가 있습니다.
"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 To 에 공개 정적 속성으로, IStringTransformer 구현하고 문자열을 소문자로 바꾸는 방법을 알고있는 개인 ToLowerCase 클래스의 인스턴스를 반환합니다.
Transform 및 IStringTransformer Over ApplyCase 및 LetterCasing 을 사용하는 이점은 LetterCasing 이 열거적이며 Framework의 내용을 사용하는 것으로 제한되며 IStringTransformer 코드베이스에서 한 번 구현할 수있는 인터페이스이며 Transform 방법을 사용하여 쉽게 확장 할 수있는 인터페이스입니다.
Truncate 메소드를 사용하여 string 을 자울 수 있습니다.
"Long text to truncate" . Truncate ( 10 ) => "Long text…" 기본적으로 '…' 문자는 현을 자르는 데 사용됩니다. '…' 대신 "..." 문자를 사용하는 장점은 전자가 단일 문자 만 사용하므로 잘린 텍스트를 잘라 내기 전에 더 많은 텍스트를 표시 할 수 있다는 것입니다. 원한다면 자신의 자리를 제공 할 수도 있습니다.
"Long text to truncate" . Truncate ( 10 , "---" ) => "Long te -- - " 기본 자르기 전략 인 Truncator.FixedLength 는 입력 문자열을 자르기 스트링 길이를 포함하여 특정 길이로 자릅니다. 두 가지 더 트렁커 전략이 있습니다. 하나는 고정 된 수의 (알파 수치) 문자와 고정 된 수의 단어에 대한 문자입니다. 절단 할 때 특정 절단기를 사용하려면 이전 예제에 표시된 두 개의 Truncate 메소드에는 모두 절단에 사용할 ITruncator 인스턴스를 지정할 수있는 과부하가 있습니다. 다음은 제공된 세 가지 자리기를 사용하는 방법에 대한 예입니다.
"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---" ITruncator 인터페이스를 구현하여 자신만의 트렁크를 만들 수 있습니다.
처음부터 문자열을 자울 것인지 ( TruncateFrom.Left ) 또는 끝 ( TruncateFrom.Right )에서 잘라낼 지 여부를 선택할 수있는 옵션도 있습니다. 기본값은 위의 예와 같이 권리입니다. 아래 예제는 문자열의 시작 부분에서 자르는 방법을 보여줍니다.
"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" 열거 회원에게 직접 ToString 호출하면 일반적으로 사용자에게 이상적인 출력이 적습니다. 이에 대한 해결책은 일반적으로 DescriptionAttribute Data Annotation을 사용한 다음 런타임에이를 읽어보다 친숙한 출력을 얻는 것입니다. 그것은 훌륭한 해결책입니다. 그러나 종종 우리는 열거 멤버의 단어 사이에 공간을두면되면 String.Humanize() 잘하는 것입니다. 열거적 인 경우 :
public enum EnumUnderTest
{
[ Description ( "Custom description" ) ]
MemberWithDescriptionAttribute ,
MemberWithoutDescriptionAttribute ,
ALLCAPITALS
}당신은 얻을 것입니다 :
// 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" 사용자 정의 설명을 위해 DescriptionAttribute 에 국한되지 않습니다. 열거 멤버에 적용되는 모든 속성은 string Description 속성 계산입니다. 이것은 DescriptionAttribute 누락 된 플랫폼을 돕고 DescriptionAttribute 의 하위 클래스를 허용하는 것입니다.
설명으로 사용하기 위해 ATTBICT의 속성 이름을 구성 할 수도 있습니다.
Configurator.EnumDescriptionPropertyLocator = p => p.Name == "Info"
현지화 된 설명을 제공 해야하는 경우 대신 DisplayAttribute Data Annotation을 사용할 수 있습니다.
public enum EnumUnderTest
{
[ Display ( Description = "EnumUnderTest_Member" , ResourceType = typeof ( Project . Resources ) ) ]
Member
}당신은 얻을 것입니다 :
EnumUnderTest . Member . Humanize ( ) => "content" // from Project.Resources found under "EnumUnderTest_Member" resource key바라건대 이것은 불필요한 속성을 가진 쓰레기 열거를 피하는 데 도움이되기를 바랍니다!
원래 인간화 된 열거로 문자열을 비인간 화합니다! API는 다음과 같습니다.
public static TTargetEnum DehumanizeTo < TTargetEnum > ( this string input )그리고 사용법은 다음과 같습니다.
"Member without description attribute" . DehumanizeTo < EnumUnderTest > ( ) => EnumUnderTest . MemberWithoutDescriptionAttribute 그리고 Humanize API와 마찬가지로 Description 속성을 존중합니다. 인간화 중에 제공 한 케이스를 제공 할 필요는 없습니다.
컴파일 타임에 원래 열거가 알려지지 않은 경우에 대한 비 게 릭 대응 물이 있습니다.
public static Enum DehumanizeTo ( this string input , Type targetEnum , NoMatch onNoMatch = NoMatch . ThrowsException )다음과 같이 사용할 수 있습니다.
"Member without description attribute" . DehumanizeTo ( typeof ( EnumUnderTest ) ) => EnumUnderTest . MemberWithoutDescriptionAttribute 기본적으로 두 가지 방법 모두 제공된 입력과 대상 열거와 일치 할 수 없을 때 NoMatchFoundException 을합니다. 비 게 니체 메소드에서는 두 번째 옵션 매개 변수를 NoMatch.ReturnsNull 로 설정하여 NULL을 반환하도록 요청할 수도 있습니다.
DateTime 또는 DateTimeOffset 의 인스턴스를 Humanize 하고 다음과 같은 시간에 얼마나 멀리 또는 앞으로 나가는지를 다시 얻을 수 있습니다.
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는 오프셋 ( DateTimeOffset )이있는 날짜뿐만 아니라 로컬 및 UTC 날짜를 모두 지원합니다. 입력 날짜를 비교하려는 날짜를 제공 할 수도 있습니다. NULL 인 경우 현재 날짜를 비교 기반으로 사용합니다. 또한 사용할 문화는 명시 적으로 지정할 수 있습니다. 그렇지 않은 경우 현재 스레드의 현재 UI 문화가 사용됩니다. 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 )이 방법을 위해 많은 지역화를 사용할 수 있습니다. 다음은 몇 가지 예입니다.
// 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 минут назад" DateTime.Humanize 에는 두 가지 전략이 있습니다. 정밀도 기반 전략을 사용하려면 구성해야합니다.
Configurator . DateTimeHumanizeStrategy = new PrecisionDateTimeHumanizeStrategy ( precision : .75 ) ;
Configurator . DateTimeOffsetHumanizeStrategy = new PrecisionDateTimeOffsetHumanizeStrategy ( precision : .75 ) ; // configure when humanizing DateTimeOffset기본 정밀도는 .75로 설정되어 있지만 원하는 정밀도도 전달할 수 있습니다. 정밀도가 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 Humanize 로 인해 날짜에 대한 비인간 화는 손실 된 변형이며 인간의 친근한 날짜는 가역적이지 않습니다.
인간의 인간 친화적 인 표현을 얻기 위해 TimeSpan 에 Humanize 부를 수 있습니다.
TimeSpan . FromMilliseconds ( 1 ) . Humanize ( ) => "1 millisecond"
TimeSpan . FromMilliseconds ( 2 ) . Humanize ( ) => "2 milliseconds"
TimeSpan . FromDays ( 1 ) . Humanize ( ) => "1 day"
TimeSpan . FromDays ( 16 ) . Humanize ( ) => "2 weeks" TimeSpan.Humanize 에 대한 선택적 precision 매개 변수가있어 리턴 값의 정밀도를 지정할 수 있습니다. precision 의 기본값은 1이므로 TimeSpan.FromDays(16).Humanize() 에서 본 것처럼 가장 큰 시간 단위 만 반환됩니다. 정밀도 지정의 몇 가지 예는 다음과 같습니다.
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" 기본적으로 precision 매개 변수를 사용할 때 빈 시간 단위는 반환 된 값의 정밀도를 향해 계산되지 않습니다. 이 동작이 원하지 않는 경우, countEmptyUnits 매개 변수와 함께 오버로드 된 TimeSpan.Humanize 메소드를 사용할 수 있습니다. 빈 시간 유닛을 선도하는 것은 결코 계산되지 않습니다. 다음은 빈 단위 계산의 차이를 보여주는 예입니다.
TimeSpan . FromMilliseconds ( 3603001 ) . Humanize ( 3 ) => "1 hour, 3 seconds, 1 millisecond"
TimeSpan . FromMilliseconds ( 3603001 ) . Humanize ( 3 , countEmptyUnits : true ) => "1 hour, 3 seconds"이 방법에 대해 많은 지역화를 사용할 수 있습니다.
// 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"사용할 문화는 명시 적으로 지정할 수 있습니다. 그렇지 않은 경우 현재 스레드의 현재 UI 문화가 사용됩니다. 예:
TimeSpan . FromDays ( 1 ) . Humanize ( culture : "ru-RU" ) => "один день"또한 더 작은 장치로 롤링하지 않도록 최소 시간 단위를 지정할 수 있습니다. 예를 들어:
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 Hour또한, 다음 가장 큰 단위로 롤업하는 것을 피하기 위해 최대 시간 단위를 지정할 수 있습니다. 예를 들어:
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 기본 최대 튜닝은 정확한 결과를 제공하기 때문에 TimeUnit.Week 입니다. 이 값을 TimeUnit.Month 또는 TimeUnit.Year 로 늘릴 수 있으며, 이는 1 년에 365.2425 일, 한 달에 30.436875 일을 기준으로 근사치를 줄 수 있습니다. 따라서 달의 길이는 30 일에서 31 일 사이이며 4 년마다 366 일입니다.
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 여러 시간 단위가 있으면 ", " 문자열을 사용하여 결합됩니다.
TimeSpan . FromMilliseconds ( 1299630020 ) . Humanize ( 3 ) => "2 weeks, 1 day, 1 hour" TimeSpan 0 인 경우 기본 동작은 "0"과 최소 시간 단위가 무엇이든 반환됩니다. 그러나 Humanize 호출 할 때 toWords 에 true 할당하면 메소드가 "시간 없음"을 반환합니다. 예를 들어:
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" collectionSeparator 매개 변수를 사용하면 자신의 분리기 문자열을 지정할 수 있습니다.
TimeSpan . FromMilliseconds ( 1299630020 ) . Humanize ( 3 , collectionSeparator : " - " ) => "2 weeks - 1 day - 1 hour" 현재 문화의 컬렉션 Formatter를 사용하여 시간 단위를 결합 할 수도 있습니다. 그렇게하려면 null 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" 단어가 숫자보다 선호되는 경우, toWords: true 매개 변수를 설정하여 인간화 된 타임 스파의 숫자를 단어로 변환 할 수 있습니다.
TimeSpan . FromMilliseconds ( 1299630020 ) . Humanize ( 3 , toWords : true ) => "two weeks, one day, one hour" ToAge 전화하면 TimeSpan 도 나이로 표현 될 수 있습니다. 연령 표현을 정의하지 않는 배양의 경우 결과는 Humanize 호출하는 것과 동일합니다 (그러나 기본 maxUnit 는 TimeUnit.Year 와 같습니다) .
// in en-US culture
TimeSpan . FromDays ( 750 ) . ToAge ( ) => "2 years old"
// in fr culture
TimeSpan . FromDays ( 750 ) . ToAge ( ) => "2 ans" 컬렉션의 개체를 나타내는 멋지게 형식화 된 문자열을 얻으려면 IEnumerable 에서 Humanize 호출 할 수 있습니다. 기본적으로 ToString() 각 항목에서 표현을 얻기 위해 호출되지만 서식 함수는 대신 Humanize 로 전달 될 수 있습니다. 또한, 기본 구분기가 제공되지만 ( "및"영어로) 다른 분리기가 Humanize 로 전달 될 수 있습니다.
예를 들어:
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"항목이 다듬어지고 공백 (NullorWhitespace) 항목이 건너 뜁니다. 이것은 깨끗한 쉼표 구두점을 초래합니다. (맞춤형 포맷터 함수가있는 경우, 이것은 Formatter의 출력에만 적용됩니다.)
ICollectionFormatter 구현하고 Configurator.CollectionFormatters 에 등록하여 자신의 컬렉션 Formatter를 제공 할 수 있습니다.
몇 가지 원인 방법도 있습니다.
Pluralize 입력을 복수화하면서 불규칙하고 사소 할 수없는 단어를 고려하면서 제공됩니다.
"Man" . Pluralize ( ) => "Men "
" string" . Pluralize ( ) => "strings" 일반적으로 단수 단어로 Pluralize 부를 것입니다. 그러나 단어의 특이점에 대해 확신이 없다면 옵션 inputIsKnownToBeSingular 인수로 메소드를 호출 할 수 있습니다.
"Men" . Pluralize ( inputIsKnownToBeSingular : false ) => "Men "
" Man" . Pluralize ( inputIsKnownToBeSingular : false ) => "Men"
"string" . Pluralize ( inputIsKnownToBeSingular : false ) => "strings" plurality 의 인수로 Pluralize 의 과부하는 더 이상 사용되지 않으며 버전 2.0에서 제거되었습니다.
불규칙하고 사소 할 수없는 단어를 고려하면서 제공된 입력을 Singularize 수화합니다.
"Men" . Singularize ( ) => "Man "
" strings" . Singularize ( ) => "string" 일반적으로 복수형으로 Singularize 부를 것입니다. 그러나 단어의 복수에 대해 확신이 없다면 옵션 inputIsKnownToBePlural 사용하여 메소드를 호출 할 수 있습니다.
"Men" . Singularize ( inputIsKnownToBePlural : false ) => "Man "
" Man" . Singularize ( inputIsKnownToBePlural : false ) => "Man"
"strings" . Singularize ( inputIsKnownToBePlural : false ) => "string" plurality 인수로 Singularize 의 과부하는 더 이상 사용되지 않으며 버전 2.0에서 제거되었습니다.
때로는 단수화/다원화 어휘의 규칙을 추가해야 할 수도 있습니다 (아래 예제는 이미 Inflector 사용하는 DefaultVocabulary 에 있습니다).
// Adds a word to the vocabulary which cannot easily be pluralized/singularized by RegEx.
// Will match both "salesperson" and "person".
Vocabularies . Default . AddIrregular ( "person" , "people" ) ;
// To only match "person" and not "salesperson" you would pass false for the 'matchEnding' parameter.
Vocabularies . Default . AddIrregular ( "person" , "people" , matchEnding : false ) ;
// Adds an uncountable word to the vocabulary. Will be ignored when plurality is changed:
Vocabularies . Default . AddUncountable ( "fish" ) ;
// Adds a rule to the vocabulary that does not follow trivial rules for pluralization:
Vocabularies . Default . AddPlural ( "bus" , "buses" ) ;
// Adds a rule to the vocabulary that does not follow trivial rules for singularization
// (will match both "vertices" -> "vertex" and "indices" -> "index"):
Vocabularies . Default . AddSingular ( "(vert|ind)ices$" , "$1ex" ) ; 여러 번 Singularize 및 Pluralize 호출하여 숫자로 단어를 접두사로 부릅니다. 예 : "2 요청", "3 남자". ToQuantity 제공된 단어를 숫자와 함께 접두사하고 그에 따라 단어를 복수화하거나 단수화합니다.
"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 입력 단어가 단수인지 복수인지를 파악할 수 있으며 필요에 따라 단수화 또는 복수화됩니다.
"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" 또한 제공된 수량을 출력하려는 방법을 지정하기 위해 두 번째 인수 인 ShowQuantityAs ToQuantity 통과 할 수 있습니다. 기본값은 ShowQuantityAs.Numeric 입니다. 다른 두 값은 ShowQuantityAs.Words 및 ShowQuantityAs.None 입니다.
"case" . ToQuantity ( 5 , ShowQuantityAs . Words ) => "five cases "
" case" . ToQuantity ( 5 , ShowQuantityAs . None ) => "cases"숫자를 포맷 할 수있는 과부하도 있습니다. 당신은 사용할 형식과 문화를 전달할 수 있습니다.
"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 숫자를 1 차, 2 차, 3, 4와 같은 순서 시퀀스에서 위치를 나타내는 데 사용되는 서수 문자열로 바꿉니다.
1 . Ordinalize ( ) => "1st"
5 . Ordinalize ( ) => "5th" "21".Ordinalize() 문자열에서 Ordinalize 호출하고 동일한 결과를 얻을 "21st" 있습니다.
Ordinalize 또한 두 형태의 문법적 성별을 지원합니다. 숫자가 출력 해야하는 성별을 지정하기 위해 인수를 Ordinalize 할 수 있습니다. 가능한 값은 GrammaticalGender.Masculine , GrammaticalGender.Feminine 및 GrammaticalGender.Neuter :
// for Brazilian Portuguese locale
1 . Ordinalize ( GrammaticalGender . Masculine ) => "1º"
1 . Ordinalize ( GrammaticalGender . Feminine ) => "1ª"
1 . Ordinalize ( GrammaticalGender . Neuter ) => "1º"
"2" . Ordinalize ( GrammaticalGender . Masculine ) => "2º"
"2" . Ordinalize ( GrammaticalGender . Feminine ) => "2ª"
"2" . Ordinalize ( GrammaticalGender . Neuter ) => "2º"분명히 이것은 일부 문화에만 적용됩니다. 성별을 통과하거나 전혀 지나지 않는 다른 사람들에게는 결과에 아무런 차이가 없습니다.
또한, Ordinalize 문장에서 서수화 된 숫자의 위치에 따라 일부 배양이 적용되는 변형을 지원합니다. 인수 wordForm 사용하여 하나의 결과를 얻습니다. 가능한 값은 WordForm.Abbreviation 및 WordForm.Normal 입니다. wordForm 인수를 성별과 결합 할 수 있지만 적용 할 수없는 경우이 인수를 전달하면 결과에 차이가 없습니다.
// 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 입력 단어를 제목 케이싱으로 변환합니다. "some title".Humanize(LetterCasing.Title)
Pascalize 입력 단어를 어퍼 카멜 케이스로 변환하여 밑줄과 공간을 제거합니다.
"some_title for something" . Pascalize ( ) => "SomeTitleForSomething" Camelize 첫 번째 문자가 소문자라는 점을 제외하고는 Pascalize 와 동일하게 동작합니다.
"some_title for something" . Camelize ( ) => "someTitleForSomething" Underscore 입력 단어를 밑줄로 분리합니다.
"SomeTitle" . Underscore ( ) => "some_title" Dasherize 및 Hyphenate 교체 밑줄은 문자열의 대시로 밑줄을 맡습니다.
"some_title" . Dasherize ( ) => "some-title"
"some_title" . Hyphenate ( ) => "some-title" Kebaberize 입력 단어를 하이픈으로 분리하고 모든 단어는 소문자로 변환됩니다.
"SomeText" . Kebaberize ( ) => "some-text" Humanizer는 다음과 같이 DateTime 및 TimeSpan 처리 할 수있는 유창한 API를 제공합니다.
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 )한 달은 28 일에서 31 일 사이에서 1 년 사이에 365 또는 366 일이 될 수 있으므로 월 또는 연도에는 유창한 API가 없습니다.
예를 들어이 방법을 사용하여 교체 할 수 있습니다
DateTime . Now . AddDays ( 2 ) . AddHours ( 3 ) . AddMinutes ( - 5 )~와 함께
DateTime . Now + 2 . Days ( ) + 3 . Hours ( ) - 5 . Minutes ( ) 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 year그리고 일부 확장 방법 :
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 ( ) 분명히 당신은 방법을 사슬로 만들 수 있습니다. 예 : On.November.The13th.In(2010).AtNoon + 5.Minutes()
Humanizer는 명확한 방식으로 (일반적으로 큰) 숫자를 생성하는 유창한 API를 제공합니다.
1.25 . Billions ( ) => 1250000000
3 . Hundreds ( ) . Thousands ( ) => 300000 Humanizer는 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" 두 번째 인수 인 GrammaticalGender ToWords 에 전달하여 출력 해야하는 성별을 지정할 수 있습니다. 가능한 값은 GrammaticalGender.Masculine , GrammaticalGender.Feminine 및 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 ( ) => "ناقص واحد"분명히 이것은 일부 문화에만 적용됩니다. 성별을 통과하는 다른 사람들에게는 결과에 아무런 차이가 없습니다.
또한 사용할 문화는 명시 적으로 지정할 수 있습니다. 그렇지 않은 경우 현재 스레드의 현재 UI 문화가 사용됩니다. 예는 다음과 같습니다.
11 . ToWords ( new CultureInfo ( "en" ) ) => "eleven"
1 . ToWords ( GrammaticalGender . Masculine , new CultureInfo ( "ru" ) ) => "один"이 메소드의 또 다른 과부하는 부울을 전달하여 마지막 숫자 앞에 추가 할 수있는 "및"를 제거 할 수 있습니다.
3501 . ToWords ( false ) => "three thousand five hundred one"
102 . ToWords ( false ) => "one hundred two"이 방법은 예를 들어 점검을 작성하는 데 유용 할 수 있습니다.
또한 ToWords 문장에서 숫자의 위치에 따라 일부 배양이 적용되는 변형을 지원합니다. 인수 wordForm 사용하여 하나의 결과를 얻습니다. 가능한 값은 WordForm.Abbreviation 및 WordForm.Normal 입니다. 이 주장은 위에 제시된 나머지 논쟁과 결합 될 수 있습니다. 적용 할 수없는 경우 wordForm 인수를 전달하면 결과에 아무런 차이가 없습니다.
// 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" 이것은 일종의 믹싱 ToWords 과 Ordinalize . 숫자로 ToOrdinalWords 호출하여 숫자를 단어로 서식 할 수 있습니다! 예를 들어:
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 또한 문법적 성별을 지원합니다. 출력의 성별을 지정하기 위해 두 번째 인수를 ToOrdinalWords 에 전달할 수 있습니다. 가능한 값은 GrammaticalGender.Masculine , GrammaticalGender.Feminine 및 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 ) => "الثاني"분명히 이것은 일부 문화에만 적용됩니다. 성별을 통과하는 다른 사람들에게는 결과에 아무런 차이가 없습니다.
또한 사용할 문화는 명시 적으로 지정할 수 있습니다. 그렇지 않은 경우 현재 스레드의 현재 UI 문화가 사용됩니다. 예는 다음과 같습니다.
10 . ToOrdinalWords ( new CultureInfo ( "en-US" ) ) => "tenth"
1 . ToOrdinalWords ( GrammaticalGender . Masculine , new CulureInfo ( "pt-BR" ) ) => "primeiro" ToOrdinalWords 또한 문장에서 서수화 된 숫자의 위치에 따라 일부 배양이 적용되는 변형을 지원합니다. 인수 wordForm 사용하여 하나의 결과를 얻습니다. 가능한 값은 WordForm.Abbreviation 및 WordForm.Normal 입니다. 이 주장을 위에 제시된 나머지 논쟁과 결합하십시오. 적용 할 수없는 경우 wordForm 인수를 전달하면 결과에 아무런 차이가 없습니다.
// 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"이것은 일종의 서수 연장입니다
// 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 또한 문법 사례를 지원합니다. 출력 사례를 지정하기 위해 두 번째 인수를 ToOrdinalWords 에 전달할 수 있습니다. 가능한 값은 GrammaticalCase.Nominative GrammaticalCase.Dative GrammaticalCase.Instrumental nominative, GrammaticalCase.Genitive GrammaticalGender.Prepositional GrammaticalCase.Accusative
분명히 이것은 일부 문화에만 적용됩니다. 사례를 통과하는 다른 사람들에게는 결과에 아무런 차이가 없습니다.
시계 표기법으로 인간화를 허용하도록 TimeOnly를 연장합니다.
// for English US locale
new TimeOnly ( 3 , 0 ) . ToClockNotation ( ) => "three o'clock"
new TimeOnly ( 12 , 0 ) . ToClockNotation ( ) => "noon"
new TimeOnly ( 14 , 30 ) . ToClockNotation ( ) => "half past two"
// for Brazilian Portuguese locale
new TimeOnly ( 3 , 0 ) . ToClockNotation ( ) => "três em ponto"
new TimeOnly ( 12 , 0 ) . ToClockNotation ( ) => "meio-dia"
new TimeOnly ( 14 , 30 ) . ToClockNotation ( ) => "duas e meia" Humanizer는 ToRoman 확장을 사용하여 숫자를 로마 숫자로 변경할 수 있습니다. 숫자 1 ~ 10은 다음과 같이 로마 숫자로 표현 될 수 있습니다.
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" 또한 FromRoman Extension을 사용한 역 작동.
"I" . FromRoman ( ) => 1
"II" . FromRoman ( ) => 2
"III" . FromRoman ( ) => 3
"IV" . FromRoman ( ) => 4
"V" . FromRoman ( ) => 54000보다 작은 정수 만 로마 숫자로 변환 할 수 있습니다.
Humanizer는 ToMetric Extension을 사용하여 숫자를 메트릭 숫자로 변경할 수 있습니다. 숫자 1, 1230 및 0.1은 다음과 같이 메트릭 숫자로 표현 될 수 있습니다.
1d . ToMetric ( ) => "1"
1230d . ToMetric ( ) => "1.23k"
0.1d . ToMetric ( ) => "100m" 또한 FromMetric Extension을 사용한 역 작동.
"1" . FromMetric ( ) => 1
"1.23k" . FromMetric ( ) => 1230
"100m" . FromMetric ( ) => 0.1 Humanizer에는 Brilliant Bytesize 라이브러리의 항구가 포함되어 있습니다. ByteSize 와의 상당한 변경 사항과 추가 사항은 ByteSize 와의 상호 작용을 Humanizer API와 더 쉽고 일치하게 만듭니다. 다음은 숫자에서 바이트 크기로, 크기 크기 사이에서 변환하는 방법에 대한 몇 가지 예입니다.
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-9숫자를 바이트 크기 인스턴스로 전환 할 수있는 몇 가지 확장 방법이 있습니다.
3 . Bits ( ) ;
5 . Bytes ( ) ;
( 10.5 ) . Kilobytes ( ) ;
( 2.5 ) . Megabytes ( ) ;
( 10.2 ) . Gigabytes ( ) ;
( 4.7 ) . Terabytes ( ) ;+/- 연산자를 사용하여 값을 추가/빼기 및 추가 방법을 추가/빼면 다음을 추가 할 수 있습니다.
var total = ( 10 ) . Gigabytes ( ) + ( 512 ) . Megabytes ( ) - ( 2.5 ) . Gigabytes ( ) ;
total . Subtract ( ( 2500 ) . Kilobytes ( ) ) . Add ( ( 25 ) . Megabytes ( ) ) ; ByteSize 객체에는 가장 큰 메트릭 접두사 기호와 값을 나타내는 두 가지 속성이 포함되어 있습니다.
var maxFileSize = ( 10 ) . Kilobytes ( ) ;
maxFileSize . LargestWholeNumberSymbol ; // "KB"
maxFileSize . LargestWholeNumberValue ; // 10 문자열 표현을 원한다면 ByteSize 인스턴스에서 ToString 호출하거나 상호 교환 적으로 Humanize 할 수 있습니다.
7 . Bits ( ) . ToString ( ) ; // 7 b
8 . Bits ( ) . ToString ( ) ; // 1 B
( .5 ) . Kilobytes ( ) . Humanize ( ) ; // 512 B
( 1000 ) . Kilobytes ( ) . ToString ( ) ; // 1000 KB
( 1024 ) . Kilobytes ( ) . Humanize ( ) ; // 1 MB
( .5 ) . Gigabytes ( ) . Humanize ( ) ; // 512 MB
( 1024 ) . Gigabytes ( ) . ToString ( ) ; // 1 TB 또한 예상 문자열 표현에 대한 형식을 선택적으로 제공 할 수도 있습니다. 포피터는 표시 할 값의 상징을 포함 할 수 있습니다 : b , B , KB , MB , GB , TB . Formatter는 #.## 과 함께 내장 된 double.ToString 메소드를 기본 형식으로 사용하여 숫자를 두 십수 자리로 반올림합니다.
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 전체 단어가있는 문자열 표현을 원한다면 ByteSize 인스턴스에서 ToFullWords 호출 할 수 있습니다.
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 문자열 표현을 ByteSize 인스턴스로 다시 전환하는 Dehumanize 방법이 없습니다. 그러나 ByteSize 에 Parse 및 TryParse 사용하여이를 수행 할 수 있습니다. 다른 TryParse 메소드와 마찬가지로, ByteSize.TryParse 파싱이 성공했는지 여부를 나타내는 boolean 값을 반환합니다. 값이 구문 분석되면 제공되는 out 매개 변수로 출력됩니다.
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" ) ; 마지막으로, 바이트 수량이 전송 된 속도를 계산 해야하는 경우, ByteSize 의 Per 을 사용할 수 있습니다. 메소드 Per 하나의 인수 - 바이트의 측정 간격을 허용합니다. 이것은 바이트를 전달하는 데 걸리는 시간입니다.
메소드 Per 은 Humanize 메소드를 갖는 ByteRate 클래스를 반환합니다. 기본적으로 요금은 초 (예 : MB/S)에 주어집니다. 그러나, 원하는 경우, 시간 단위는 대체 간격으로 Humanize 로 전달 될 수있다. 유효한 간격은 TimeUnit.Second , TimeUnit.Minute 및 TimeUnit.Hour 입니다. 각 간격 및 예 바이트 속도 사용의 예는 다음과 같습니다.
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/hour인간화 된 출력의 바이트 부분에 대한 형식을 지정할 수 있습니다.
19854651984 . Bytes ( ) . Per ( 1 . Seconds ( ) ) . Humanize ( "#.##" ) ;
// 18.49 GB/s Humanizer에는 숫자 제목을 단어로 변경하는 방법이 포함되어 있습니다. 제목은 double 일 수 있지만 결과는 문자열이됩니다. 제목 (예 : North, East, South 또는 West), 짧은 표현 (예 : N, E, S, W) 또는 유니 코드 화살표 문자 (예 : ↑, →, ↓, ←)의 전체 표현을 반환할지 여부를 선택할 수 있습니다.
360 . ToHeading ( ) ;
// N
720 . ToHeading ( ) ;
// N제목의 정식 버전을 검색하려면 다음 호출을 사용하십시오.
180 . ToHeading ( HeadingStyle . Full ) ;
// south
360 . ToHeading ( HeadingStyle . Full ) ;
// north텍스트 표현의 최대 편차는 11.25 °입니다.
무엇보다도 방법에는 현지화 된 결과를 결정하기 위해 CultureInfo 객체를 제공 할 수있는 과부하가 있습니다.
제목을 나타내는 화살표를 검색하려면 다음 방법을 사용하십시오.
90 . ToHeadingArrow ( ) ;
// →
225 . ToHeadingArrow ( ) ;
// ↙제목의 화살표 표현의 최대 편차는 22.5 °입니다.
짧은 텍스트 표현 (예 : n, e, s, w)을 기반으로 제목을 검색하기 위해 다음 방법을 사용할 수 있습니다.
"S" . FromShortHeading ( ) ;
// 180
"SW" . FromShortHeading ( ) ;
// 225 Humanizer는 Tupleize 사용하여 전체 숫자를 '튜플'으로 변경할 수 있습니다. 예를 들어:
1 . Tupleize ( ) ;
// single
3 . Tupleize ( ) ;
// triple
100 . Tupleize ( ) ;
// centuple숫자 1-10, 100 및 1000은 '명명 된'튜플 (예 : 단일 ","더블 "등)으로 변환됩니다. 다른 숫자 "n"은 "n- 튜플"으로 변환됩니다.
Humanizer는 시간 단위를 기호로 번역 할 수 있습니다.
TimeUnit . Day . ToSymbol ( ) ;
// d
TimeUnit . Week . ToSymbol ( ) ;
// week
TimeUnit . Year . ToSymbol ( ) ;
// y 이것은 단지 기준 일 뿐이며 이것을 사용하여 일상적인 직업을 단순화 할 수 있습니다. 예를 들어, ASP.NET MVC에서는 viewModel 속성에서 chucking Display 속성을 유지하므로 HtmlHelper 올바른 레이블을 생성 할 수 있습니다. 그러나 열거와 마찬가지로 대부분의 경우 대부분의 경우 속성 이름의 단어 사이에 공간이 필요합니다. 따라서 "string".Humanize 사용하지 않는 이유는 무엇입니까?!
코드에서 ASP.NET MVC 샘플을 찾을 수 있습니다 (프로젝트는 솔루션 파일에서 제외되어 NUGET 패키지를 .NET 3.5에서도 사용할 수 있도록합니다).
이것은 사용자 정의 DataAnnotationsModelMetadataProvider 사용하여 달성됩니다. 여기에서 반복하기에 충분히 작습니다. 그래서 우리는 간다 :
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 ;
}
} 이 클래스는 기본 클래스를 호출하여 메타 데이터를 추출한 다음 필요한 경우 속성 이름을 인간화합니다. 속성에 이미 DisplayName 또는 Display 속성이 있는지 확인하고 있습니다.이 경우 메타 데이터 제공 업체는 속성을 존중하고 속성을 내버려 둘 것입니다. 다른 속성의 경우 속성 이름을 인간화합니다. 그게 다야.
이제이 메타 데이터 제공 업체를 ASP.NET MVC에 등록해야합니다. System.Web.Mvc.ModelMetadataProviders 사용하고 System.Web.ModelBinding.ModelMetadataProviders 사용하십시오.
ModelMetadataProviders . Current = new HumanizerMetadataProvider ( ) ;... 이제 교체 할 수 있습니다.
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 ; }
}와 함께:
public class RegisterModel
{
public string UserName { get ; set ; }
public string EmailAddress { get ; set ; }
public string ConfirmPassword { get ; set ; }
}... 그리고 "메타 데이터 휴먼 라이저"는 나머지를 돌볼 것입니다.
라벨에 대한 제목 케이싱을 원한다면 Transform 으로 메소드를 체인 할 수 있다고 언급 할 필요가 없습니다.
modelMetadata . DisplayName = modelMetadata . PropertyName . Humanize ( ) . Transform ( To . TitleCase ) ; Humanizer는 휴대용 클래스 라이브러리입니다. MVC 뷰가 일반 프로젝트와 동일한 빌드 시스템을 공유하지 않기 때문에 MVC보기에서 PCL을 사용하려고하는 경우 현재 문제가 있습니다. 프로젝트 시스템이 일반적으로 자동으로 추가되는 것을 포함하여 web.config 파일의 모든 참조를 지정해야합니다.
System.Runtime 또는 System.Globalization 에 대한 참조를 추가해야한다는 오류가 발생하면 이는 귀하에게 적용됩니다. 해결책은 여기에 나열된대로 계약 참조를 web.config 에 추가하는 것입니다. 이것은 Humanizer뿐만 아니라 MVC보기에서 사용하는 모든 PCL에 적용됩니다.
Humanizer Project는 Azure DevOps (자세한 내용)에 의해 지속적으로 구축 및 테스트되었습니다. 요청을 당기는데도 적용됩니다. PR을 제출 한 직후 PR에서 빌드 및 테스트 상태 알림을 확인할 수 있습니다.
CI 서버의 현재 빌드 상태는 다음과 같습니다
아래는 관련 오픈 소스 프로젝트 목록입니다.
Resharper를 사용하는 경우 Humanizer.annotations 패키지에서는 Humanizer 용 주석이 있습니다. Resharper Extension Manager를 통해 얻을 수 있습니다. 이러한 주석은 아직 전체 라이브러리를 다루지 않지만 풀 요청은 항상 환영합니다!.
PowerShell Humanizer는 Humanizer를 감싸는 PowerShell 모듈입니다.
Humanizer.jvm은 JVM 용으로 제작되었으며 Kotlin에서 작성된 .NET에 대한 Humanizer Framework의 적응입니다. Humanizer.jvm은 문자열, 열거, 날짜, 시간, 타임 스팬, 숫자 및 수량 조작 및 표시에 대한 모든 JVM 요구를 충족시킵니다.
Humanizer.Node는 Humanizer 프레임 워크의 타입 스크립트 포트입니다.
Tyrone Rieschiek가 만든 아이콘
