Humanizer meets all your.Net needs for operations and displays of the following types, including strings, enumerations, dates, times, time spans, numbers, and quantities.It uses MIT for authorized distribution.

1. Humanized string

Humanized string extensions allow you to convert strings that were originally processed by your computer into human-friendly strings that are more readable.It is based on a BDDfy framework in which class names, method names, and properties are converted into easy-to-read sentences.

"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"

Note that strings containing only uppercase letters and only one word are always considered initials regardless of their length.To ensure that any string will always be human, you must use conversion (see the Transform method below):

// 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"

You can also specify the letter case you want:

"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"

The LetterCasing API and the way it was accepted are legacies of the V0.2 era and will not be recommended in the future.Instead, you can use the Transform method described below.

2. Inhuman Strings

Just as you can humanize a computer-friendly string into a human-friendly string, you can also humanize a human-friendly string into a computer-friendly string:

"Pascal case input string is turned into sentence".Dehumanize() => "PascalCaseInputStringIsTurnedIntoSentence"

3. Convert String

There is a Transform method that replaces LetterCasing, ApplyCase, and Humanize overloads.The transformation method signature is as follows:

string Transform(this string input, params IStringTransformer[] transformers)

For letter case, there are also existing implementations of 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 is a public static property of the To class that returns an instance of the private ToLowerCase class that implements IStringTransformer and knows how to convert strings to lowercase.

The advantage of using Transform and IStringTransformer over ApplyCase and LetterCasing is that LetterCasing is an enumeration, and you can only use content from the framework, while IStringTransformer is an interface that can be implemented in the code base at once and used with the Transform method, making it easy to extend.

4. Truncate string

You can truncate strings using the Truncate method:

"Long text to truncate".Truncate(10) => "Long text..."

By default, the'...'character is used to truncate strings.The advantage of using the'...'character instead of'...' is that it only uses one character, so it allows more text to be displayed before truncation.You can also provide your own truncated string if you want:

"Long text to truncate".Truncate(10, "---") => "Long te---"

The default truncation policy, Truncator.FixedLength, is to truncate the input string to a specific length, including the length of the truncated string.There are two other truncator strategies: one for a fixed number of (alphanumeric) characters and another for a fixed number of words.To use a specific truncator when truncating, both Truncate methods shown in the previous example have overloads that allow you to specify an ITruncator instance for truncation.The following are examples of how to use the three truncators provided:

"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---"

Note that you can also create your own truncators by implementing the ITruncator interface.

There is also an option to truncate the string from the beginning (TruncateFrom.Left) or the end (TruncateFrom.Right).As shown in the example above, the default is set to the right.The following example shows how to truncate from the beginning of a 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"

5. Formatted string

You can format the string using the FormatWith() method:

"To be formatted -> {0}/{1}.".FormatWith(1, "A") => "To be formatted -> 1/A."

This is an extension based on String.Format, so the exact rules apply to it.If format is null, ArgumentNullException is raised.A String.FormatException exception is thrown if the number of parameters passed is small.

You can also specify a culture to explicitly use as the first parameter of the FormatWith() method:

"{0:N2}".FormatWith(new CultureInfo("ru-RU"), 6666.66) => "6 666,66"

If no culture is specified, the current culture of the current thread is used.

6. Human Enumeration

Calling ToString directly on an enumeration member often results in undesirable output for the user.The solution is usually to use the DescriptionAttribute data comment and read it at runtime for more friendly output.That's a good solution.But in general, we only need to place some spaces between the words of the enumerated members - that's the advantage of String.Humanize().For enumerations like this:

public enum EnumUnderTest
{
    [Description("Custom description")]
    MemberWithDescriptionAttribute,
    MemberWithoutDescriptionAttribute,
    ALLCAPITALS
}

You will get:

// 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"

You are not limited to DescriptionAttribute as a custom description.Any attributes applied to enumerated members with a string Description attribute will be counted.This is to help platforms that lack a DescriptionAttribute and allow subclasses of DescriptionAttributes to be used.

You can even configure the name of the attibute attribute to be used as a description.

Configurator.EnumDescriptionPropertyLocator = p => p.Name == "Info"

If you need to provide a localized description, you can use the DisplayAttribute data comment instead.

public enum EnumUnderTest
{
    [Display(Description = "EnumUnderTest_Member", ResourceType = typeof(Project.Resources))]
    Member
}

You will get:

EnumUnderTest.Member.Humanize() => "content" // from Project.Resources found under "EnumUnderTest_Member" resource key

Hopefully this will help avoid confusing definitions of enumerations with unnecessary attributes!

7. Make enumerations non-human

Humanize the string so that it is a human enumeration!The API is as follows:

public static TTargetEnum DehumanizeTo<TTargetEnum>(this string input)

Usage is:

"Member without description attribute".DehumanizeTo<EnumUnderTest>() => EnumUnderTest.MemberWithoutDescriptionAttribute

Like the Humanize API, it uses the Description property.You don't need to provide the shells provided in the humanization process: it can be made clear.

When the original Enum is not known at compile time, there is also a non-generic counterpart:

public static Enum DehumanizeTo(this string input, Type targetEnum, NoMatch onNoMatch = NoMatch.ThrowsException)

It can be used like this:

"Member without description attribute".DehumanizeTo(typeof(EnumUnderTest)) => EnumUnderTest.MemberWithoutDescriptionAttribute

By default, neither method throws a NoMatchFoundException when matching the supplied input to the target enumeration.In non-generic methods, you can also ask the method to return null by setting the second optional parameter to NoMatch.ReturnsNull.

8. Human DateTime

You can humanize an instance of DateTime or DateTimeOffset and return a string that tells you when to go backward or forward in time:

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 supports local and UTC dates as well as dates with offsets (DateTimeOffset).You can also provide a date to compare with the input date.If null, it will use the current date as the basis for comparison.In addition, you can explicitly specify the culture you want to use.If not, use the current UI culture of the current thread.This is an API signature:

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)

There are many localized versions of this method.Here are some examples:

// 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 has two strategies: the default strategy described above and the precision-based strategy.To use a precision-based strategy, you need to configure it:

Configurator.DateTimeHumanizeStrategy = new PrecisionDateTimeHumanizeStrategy(precision: .75);
Configurator.DateTimeOffsetHumanizeStrategy = new PrecisionDateTimeOffsetHumanizeStrategy(precision: .75); // configure when humanizing DateTimeOffset

The default precision is set to.75, but you can also pass in the required precision.Set the precision to 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

Dates are not inhuman because humanization is a detrimental conversion and human-friendly dates are irreversible.

9. Time span of humanization

You can call Humanize on TimeSpan for a human-friendly representation:

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 has an optional precision parameter that allows you to specify the precision of the returned value.The default precision value is 1, which means that only the largest unit of time is returned, as you can see in TimeSpan.FromDays(16).Humanize().Here are some examples of specified precision:

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"

By default, when precision parameters are used, empty time units do not count in the accuracy of the returned value.If you do not need this behavior, you can use the overloaded TimeSpan.Humanize method with the countEmptyUnits parameter.Leading empty time units never count.This is an example of displaying the difference between null unit counts:

TimeSpan.FromMilliseconds(3603001).Humanize(3) => "1 hour, 3 seconds, 1 millisecond"
TimeSpan.FromMilliseconds(3603001).Humanize(3, countEmptyUnits:true) => "1 hour, 3 seconds"

There are many localized versions of this approach:

// 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"

You can explicitly specify the culture to be used.If not, use the current UI culture of the current thread.Example:

TimeSpan.FromDays(1).Humanize(culture: "ru-RU") => "один день"

In addition, you can specify the shortest unit of time to avoid scrolling to smaller units.For example:

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

In addition, you can specify a maximum time unit to avoid accumulating to the next maximum unit.For example:

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

The default maxUnit is TimeUnit.Week because it provides accurate results.You can increase this value to TimeUnit.Month or TimeUnit.Year, which will give you an approximation based on 365.2425 days a year and 30.436875 days a month.Therefore, the interval between months is 30 and 31 days, 366 days every four years.

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

If there are multiple time units, use the','string to combine them:

TimeSpan.FromMilliseconds(1299630020).Humanize(3) => "2 weeks, 1 day, 1 hour"

When TimeSpan is zero, the default behavior returns "0" plus the minimum unit of time.However, if true is assigned to toWords when Humanize is called, the method returns "no time".For example:

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"

Using the collectionSeparator parameter, you can specify your own delimiter string:

TimeSpan.FromMilliseconds(1299630020).Humanize(3, collectionSeparator: " - ") => "2 weeks - 1 day - 1 hour"

You can also use the current culture's set formatter to group time units.To do this, specify null as the collectionSeparator parameter:

// 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"

If words take precedence over numbers, you can set the toWords:true parameter to convert numbers in a human-friendly TimeSpan into words:

TimeSpan.FromMilliseconds (1299630020). Humanize (3, toWords:true) => "Two weeks, one day, one hour"

10. Human Collection

You can call Humanize on any IEnumerable to get a properly formatted string that represents objects in the collection.By default, ToString() is called on each project to get its representation, but the formatting function can be passed to Humanize.In addition, a default delimiter (and in English) is provided, but other delimiters can be passed to Humanize.

For example:

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"

Trim the item and skip the NullOrWhitespace item.This results in clean comma punctuation.(If you have a custom formatter function, this function only applies to the output of the formatter.)

You can provide your own collection formatter by implementing ICollectionFormatter and registering it with Configurator.CollectionFormatters.

11. Inflector methods

There are also inflector methods:

complex

Pluralize the input provided, taking into account irregular and non-countable words:

"Man".Pluralize() => "Men"
"string".Pluralize() => "strings"

Typically, you will call Pluralize on a single word, but if you are unsure of the singularity of the word, you can call it with the optional inputIsKnownToBeSingular parameter:

"Men".Pluralize(inputIsKnownToBeSingular: false) => "Men"
"Man".Pluralize(inputIsKnownToBeSingular: false) => "Men"
"string".Pluralize(inputIsKnownToBeSingular: false) => "strings"

Pluralize overloads with complex parameters are obsolete and have been removed in version 2.0.

Singularization

Singularity singularizes the input provided, taking into account irregular and uncountable words:

"Men".Singularize() => "Man"
"strings".Singularize() => "string"

Normally, you will call singularization on a plural word, but if you are not sure about the plural form of the word, you can call the method with the optional inputIsKnownToBePlural parameter:

"Men".Singularize(inputIsKnownToBePlural: false) => "Man"
"Man".Singularize(inputIsKnownToBePlural: false) => "Man"
"strings".Singularize(inputIsKnownToBePlural: false) => "string"

Singularize overloads with complex parameters are obsolete and removed in version 2.0.

12. Add Words

Sometimes you may need to add a rule from the singular/plural vocabulary (the following example is already in the default vocabulary used by 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");

To quantity

Many times, you want to call singularization and pluralization to add numbers to words.For example,'2 requests','3 men'.ToQuantity prefixes the supplied word with numbers and pluralizes or singularizes the word accordingly:

"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 can determine if the input word is singular or plural and, if necessary, singular or plural:

"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"

You can also pass the second parameter ShowQuantityAs to ToQuantity to specify how you want to output the quantity provided.The default value is ShowQuantityAs.Numeric, which is what we see above.The other two values are ShowQuantityAs.Words and ShowQuantityAs.None.

"case".ToQuantity(5, ShowQuantityAs.Words) => "five cases"
"case".ToQuantity(5, ShowQuantityAs.None) => "cases"

There is also an overload that allows you to format numbers.You can pass on the format and culture you want to use.

"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"

Ordinalization

Ordinalization converts a number to an ordinal string that represents the position in an ordered sequence such as 1st, 2nd, 3rd, 4th:

1.Ordinalize() => "1st"
5.Ordinalize() => "5th"

You can also call Ordinalize on a number string and get the same result:'21'. Ordinalize()=>'21'

Ordinalization also supports two forms of grammatical gender.You can pass a parameter to Ordinalize to specify which gender the number should be output in.Possible values are GrammaticalGender.Masculine, GrammmicalGender.Feminine, and 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º"

Obviously, this only applies to certain cultures.The results are no different for other people who pass by gender or fail at all.

Titleization

Titleize converts the input word to Title case; equivalent to "some titles".Humanize (LetterCasing.Title)

Pascalize

Pascalize converts the entered word to UpperCamelCase, removing underscores and spaces:

"some_title for something".Pascalize() => "SomeTitleForSomething"

Camelize

Camelize behaves the same as Pascalize, but the first character is lowercase:

"some_title for something".Camelize() => "someTitleForSomething"

Underline

Underscore underlines the words you enter:

"SomeTitle".Underscore() => "some_title"

Dasherize & Hyphenate

Dasherize and Hyphenate replace the underscores with underscores:

"some_title".Dasherize() => "some-title"
"some_title".Hyphenate() => "some-title"

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");

Finally, if you need to calculate the rate at which a certain number of bytes are transferred, you can use the Per method of ByteSize.The Per method accepts a parameter-byte measurement interval; this is the time it takes to transfer the bytes.

The Per method returns the ByteRate class with the Humanize method.By default, the rate is in seconds (for example, MB / s).However, you can pass TimeUnit to Humanize at another interval if you want.Valid intervals are TimeUnit.Second, TimeUnit.Minute, and TimeUnit.Hour.Below are examples of each interval and the byte rate.

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

You can specify the format for the byte portion of the human output: