A simple "human scale" number to string converter

Introduction

I needed to show file sizes in a "human friendly format" recently, so I thought I'd knock up a simple method to do it. So the file sizes such as 10123456789 bytes would display as 10.1Gb and so forth. Simple, but a pain, since it breaks your concentration to "knock up" a method. I'm sure there are other versions out there, but...some of them are far too complicated for their own good!

The code

Easy to read, I think: it uses an array of ISO suffixes (in ISO they are prefixes, because they come before the quantity type: "G" is the prefix, "b" is the bytes in "12.3 Gb")

/// <summary>
/// Suffix size values (ISO only goes up to "Yotta", but a 64bit int
/// can't even get there - the last two are for completeness.)
/// </summary>
///
private static string[] suffixes = new string[] { "", "k", "M", "G", "T", "P", "E", "Z", "Y" };
/// <summary>
/// Converts a long value to a human scale count
///        Number  Human Scale
///             1  1
///            10  10
///           101  101
///          1012  1.01k
///         10123  10.1k
///        101234  101k
///       1012345  1.01M
///      10123456  10.1M
///     101234567  101M
///    1012345678  1.01G
///             ....
/// </summary>
/// <param name="value">Value to scale</param>
/// <param name="suffix">If supplied, appended to the output string</param>
/// <param name="spacer">If supplied, it separates the numbers and the ISO size indicator</param>
/// <param name="positiveIndicator">If supplied, it prefixes the number</param>
/// <returns></returns>
public static string HumanScale(long value, string suffix = "", string spacer = "", string positiveIndicator = "")
    {
    string result = Math.Abs(value).ToString();
    int digits = result.Length;
    if (digits >= 4)
        {
        digits--;       // Groups = (Length - 1) / sizeOfGroup;
                        // digitsBeforeDecimal = ((Length - 1) % 3) + 1
                        // This avoids testing and "move down" of groups count
                        // when we don't want a decimal at all: 123M for example.
        int groups = digits / 3;
        int digitsBeforeDecimal = digits % 3;
        StringBuilder sb = new StringBuilder();
        foreach (char c in result.Substring(0, 3))
            {
            if (digitsBeforeDecimal == -1) sb.Append(System.Globalization.CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator);
            digitsBeforeDecimal--;
            sb.Append(c);
            }
        result = string.Format("{0}{1}{2}{3}", sb, spacer, suffixes[groups], suffix);
        }
    return string.Format("{0}{1}", value < 0 ? System.Globalization.CultureInfo.CurrentCulture.NumberFormat.NegativeSign : positiveIndicator, result);
    }

Using it is also simple:

long l = 1;
for (int i = 0; i <= 24; i++)
    {
    Console.WriteLine("{0,2} {1,24}  {2}", i, l, HumanScale(l));
    l = (l * 10) + (i % 10);
    }

Generates:

 0                        1  1
 1                       10  10
 2                      101  101
 3                     1012  1.01k
 4                    10123  10.1k
 5                   101234  101k
 6                  1012345  1.01M
 7                 10123456  10.1M
 8                101234567  101M
 9               1012345678  1.01G
10              10123456789  10.1G
11             101234567890  101G
12            1012345678901  1.01T
13           10123456789012  10.1T
14          101234567890123  101T
15         1012345678901234  1.01P
16        10123456789012345  10.1P
17       101234567890123456  101P
18      1012345678901234567  1.01E
19     -8323287284697205938  -8.32E
20      9000847521575698709  9.00E
21     -2225245152790770990  -2.22E
22     -3805707454198158283  -3.80E
23     -1163586394562479596  -1.16E
24      6810880128084755659  6.81E

Note that the long value overflows long before Yottabytes are reached!

History

2014-05-25 Original version

2014-05-25 XML comments un-mucked up. Editor removed closing tags, and so forth - so they would have been invalid in Visual Studio when copy / pasted. I do dislike this editor, sometimes...