Чи надає .NET простий спосіб перетворення байтів у KB, MB, GB тощо?


112

Цікаво, чи .NET забезпечує чистий спосіб зробити це:

int64 x = 1000000;
string y = null;
if (x / 1024 == 0) {
    y = x + " bytes";
}
else if (x / (1024 * 1024) == 0) {
    y = string.Format("{0:n1} KB", x / 1024f);
}

тощо ...

Відповіді:


192

Ось досить стислий спосіб зробити це:

static readonly string[] SizeSuffixes = 
                   { "bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB" };
static string SizeSuffix(Int64 value, int decimalPlaces = 1)
{
    if (decimalPlaces < 0) { throw new ArgumentOutOfRangeException("decimalPlaces"); }
    if (value < 0) { return "-" + SizeSuffix(-value); } 
    if (value == 0) { return string.Format("{0:n" + decimalPlaces + "} bytes", 0); }

    // mag is 0 for bytes, 1 for KB, 2, for MB, etc.
    int mag = (int)Math.Log(value, 1024);

    // 1L << (mag * 10) == 2 ^ (10 * mag) 
    // [i.e. the number of bytes in the unit corresponding to mag]
    decimal adjustedSize = (decimal)value / (1L << (mag * 10));

    // make adjustment when the value is large enough that
    // it would round up to 1000 or more
    if (Math.Round(adjustedSize, decimalPlaces) >= 1000)
    {
        mag += 1;
        adjustedSize /= 1024;
    }

    return string.Format("{0:n" + decimalPlaces + "} {1}", 
        adjustedSize, 
        SizeSuffixes[mag]);
}

Ось оригінальна реалізація, яку я запропонував, яка може бути дещо повільнішою, але трохи простішою:

static readonly string[] SizeSuffixes = 
                  { "bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB" };

static string SizeSuffix(Int64 value, int decimalPlaces = 1)
{
    if (value < 0) { return "-" + SizeSuffix(-value); } 

    int i = 0;
    decimal dValue = (decimal)value;
    while (Math.Round(dValue, decimalPlaces) >= 1000)
    {
        dValue /= 1024;
        i++;
    }

    return string.Format("{0:n" + decimalPlaces + "} {1}", dValue, SizeSuffixes[i]);
}

Console.WriteLine(SizeSuffix(100005000L));

Варто пам’ятати, що у позначенні СІ «кіло» зазвичай використовує малий к, тоді як усі великі одиниці використовують велику літеру. Windows використовує KB, MB, GB, тому я використав KB вище, але замість цього ви можете розглянути kB.


Лист, який задає запитання, шукає лише 1 десятковий знак точності. Чи можете ви навести приклад вводу, який дає неправильний вихід?
JLRishe

2
В обох прикладах зараз використовується поділ з плаваючою комою, тому має бути набагато менше занепокоєнь щодо помилок округлення.
JLRishe

Дякую, саме те, що я шукав. (2-я реалізація.)
snapplex

1
Дуже акуратне виконання. Зауважте, що якщо ви передасте значення 0 цій функції, воно викине IndexOutOfRangeException. Я вирішив додати if (value == 0) { return "0"; }чек всередині функції.
bounav

Чи можете ви надати випадок, коли розмір файлу <0? Для мене це виглядає дивно ...
Руслан Ф.

84

Оформити замовлення ByteSize бібліотеку. ЦеSystem.TimeSpan байти!

Він обробляє перетворення та форматування для вас.

var maxFileSize = ByteSize.FromKiloBytes(10);
maxFileSize.Bytes;
maxFileSize.MegaBytes;
maxFileSize.GigaBytes;

Він також робить подання рядків і їх аналіз.

// ToString
ByteSize.FromKiloBytes(1024).ToString(); // 1 MB
ByteSize.FromGigabytes(.5).ToString();   // 512 MB
ByteSize.FromGigabytes(1024).ToString(); // 1 TB

// Parsing
ByteSize.Parse("5b");
ByteSize.Parse("1.55B");

6
Простий у використанні та розумінні, і він працює з. Net 4.0 і вище.
Джокер

34
Це має бути включено до складу .NET фреймворку
helios456

Єдина проблема, яку я бачу, полягає в тому, що методи перетворення працюють лише від небайтових до байтових, але не навпаки.
SuperJMN

@SuperJMN, що ти не маєш на увазі Як шматочки? Існує метод .FromBits, який ви можете використовувати.
Омар

1
Якщо ваші вихідні дані - це щось інше, ніж "байти", і вам потрібно мати можливість перетворити на що завгодно ... це бібліотека, якою ви повинні користуватися.
Джеймс Блейк

37

Оскільки всі інші публікують свої методи, я зрозумів, що опублікую метод розширення, який я зазвичай використовую для цього:

EDIT: додано int / long варіанти ... та виправлено помилку copypasta ...

public static class Ext
{
    private const long OneKb = 1024;
    private const long OneMb = OneKb * 1024;
    private const long OneGb = OneMb * 1024;
    private const long OneTb = OneGb * 1024;

    public static string ToPrettySize(this int value, int decimalPlaces = 0)
    {
        return ((long)value).ToPrettySize(decimalPlaces);
    }

    public static string ToPrettySize(this long value, int decimalPlaces = 0)
    {
        var asTb = Math.Round((double)value / OneTb, decimalPlaces);
        var asGb = Math.Round((double)value / OneGb, decimalPlaces);
        var asMb = Math.Round((double)value / OneMb, decimalPlaces);
        var asKb = Math.Round((double)value / OneKb, decimalPlaces);
        string chosenValue = asTb > 1 ? string.Format("{0}Tb",asTb)
            : asGb > 1 ? string.Format("{0}Gb",asGb)
            : asMb > 1 ? string.Format("{0}Mb",asMb)
            : asKb > 1 ? string.Format("{0}Kb",asKb)
            : string.Format("{0}B", Math.Round((double)value, decimalPlaces));
        return chosenValue;
    }
}

Майте на увазі, хоча цей нижній регістр b зазвичай може означати біти, а не байти. :-) en.wikipedia.org/wiki/Data-rate_units#Kilobit_per_second
SharpC

32

Я б вирішив це за допомогою Extension methods, Math.Powфункції та Enums:

public static class MyExtension
{
    public enum SizeUnits
    {
        Byte, KB, MB, GB, TB, PB, EB, ZB, YB
    }

    public static string ToSize(this Int64 value, SizeUnits unit)
    {
        return (value / (double)Math.Pow(1024, (Int64)unit)).ToString("0.00");
    }
}

і використовувати його так:

string h = x.ToSize(MyExtension.SizeUnits.KB);

3
Елегантне рішення!
йосико

1
Я використав вашу ідею, щоб створити таку, яка автоматично визначає одиницю. +1
Луї Сомерс

2
Це дуже елегантне рішення, яке набагато чистіше і враховує прийняте рішення. Однак, строго кажучи, виходячи із значень enum, він повинен базуватися на потужності 1000, тобто не на 1024 ( en.wikipedia.org/wiki/Terabyte ) код ... загальнодоступна статична рядок ToSize (це довге значення, одиниця одиниці) => $ "{value / Math.Pow (1000, (long) одиниця)): F2} {unit.ToString ()}";
stoj

6

У короткій версії найбільш голосової відповіді є проблеми зі значеннями туберкульозу.

Я відповідним чином підкоригував обробку також значень tb і все ще без циклу, а також додав невелику перевірку помилок на наявність негативних значень. Ось моє рішення:

static readonly string[] SizeSuffixes = { "bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB" };
static string SizeSuffix(long value, int decimalPlaces = 0)
{
    if (value < 0)
    {
        throw new ArgumentException("Bytes should not be negative", "value");
    }
    var mag = (int)Math.Max(0, Math.Log(value, 1024));
    var adjustedSize = Math.Round(value / Math.Pow(1024, mag), decimalPlaces);
    return String.Format("{0} {1}", adjustedSize, SizeSuffixes[mag]);
}

1
Викладене питання з великими значеннями більше не повинно бути присутнім у прийнятій відповіді.
JLRishe

5

Ні. Переважно тому, що це досить ніша потреба, і існує занадто багато можливих варіацій. (Це "KB", "Kb" чи "Ko"? Мегабайт 1024 * 1024 байт або 1024 * 1000 байт? - так, деякі місця використовують це!)


1
+1 - згідно Вікіпедії , kb => 1000 байт, а KiB => 1024 байти.
Пітер Маджед

5

Ось варіант, який легше розширити, ніж ваш, але ні, в самій бібліотеці немає жодного.

private static List<string> suffixes = new List<string> { " B", " KB", " MB", " GB", " TB", " PB" };
public static string Foo(int number)
{
    for (int i = 0; i < suffixes.Count; i++)
    {
        int temp = number / (int)Math.Pow(1024, i + 1);
        if (temp == 0)
            return (number / (int)Math.Pow(1024, i)) + suffixes[i];
    }
    return number.ToString();
}

4
    private string GetFileSize(double byteCount)
    {
        string size = "0 Bytes";
        if (byteCount >= 1073741824.0)
            size = String.Format("{0:##.##}", byteCount / 1073741824.0) + " GB";
        else if (byteCount >= 1048576.0)
            size = String.Format("{0:##.##}", byteCount / 1048576.0) + " MB";
        else if (byteCount >= 1024.0)
            size = String.Format("{0:##.##}", byteCount / 1024.0) + " KB";
        else if (byteCount > 0 && byteCount < 1024.0)
            size = byteCount.ToString() + " Bytes";

        return size;
    }

    private void btnBrowse_Click(object sender, EventArgs e)
    {
        if (openFile1.ShowDialog() == DialogResult.OK)
        {
            FileInfo thisFile = new FileInfo(openFile1.FileName);

            string info = "";

            info += "File: " + Path.GetFileName(openFile1.FileName);
            info += Environment.NewLine;
            info += "File Size: " + GetFileSize((int)thisFile.Length);

            label1.Text = info;
        }
    }

Це один спосіб зробити це також (число 1073741824.0 - від 1024 * 1024 * 1024, так само GB)


3

@ Відповідь Серві була приємною і лаконічною. Я думаю, це може бути ще простіше?

private static string[] suffixes = new [] { " B", " KB", " MB", " GB", " TB", " PB" };

public static string ToSize(double number, int precision = 2)
{
    // unit's number of bytes
    const double unit = 1024;
    // suffix counter
    int i = 0;
    // as long as we're bigger than a unit, keep going
    while(number > unit)
    {
        number /= unit;
        i++;
    }
    // apply precision and current suffix
    return Math.Round(number, precision) + suffixes[i];
}

3

На основі елегантного рішення NeverHopeless:

private static readonly KeyValuePair<long, string>[] Thresholds = 
{
    // new KeyValuePair<long, string>(0, " Bytes"), // Don't devide by Zero!
    new KeyValuePair<long, string>(1, " Byte"),
    new KeyValuePair<long, string>(2, " Bytes"),
    new KeyValuePair<long, string>(1024, " KB"),
    new KeyValuePair<long, string>(1048576, " MB"), // Note: 1024 ^ 2 = 1026 (xor operator)
    new KeyValuePair<long, string>(1073741824, " GB"),
    new KeyValuePair<long, string>(1099511627776, " TB"),
    new KeyValuePair<long, string>(1125899906842620, " PB"),
    new KeyValuePair<long, string>(1152921504606850000, " EB"),

    // These don't fit into a int64
    // new KeyValuePair<long, string>(1180591620717410000000, " ZB"), 
    // new KeyValuePair<long, string>(1208925819614630000000000, " YB") 
};

/// <summary>
/// Returns x Bytes, kB, Mb, etc... 
/// </summary>
public static string ToByteSize(this long value)
{
    if (value == 0) return "0 Bytes"; // zero is plural
    for (int t = Thresholds.Length - 1; t > 0; t--)
        if (value >= Thresholds[t].Key) return ((double)value / Thresholds[t].Key).ToString("0.00") + Thresholds[t].Value;
    return "-" + ToByteSize(-value); // negative bytes (common case optimised to the end of this routine)
}

Можливо, є надмірні коментарі, але я схильний залишати їх, щоб не допустити таких же помилок у майбутніх візитах ...



1

Я поєднав деякі відповіді тут у два методи, які чудово працюють. Другий спосіб, наведений нижче, перетворить з рядка байтів (наприклад, 1,5,1 ГБ) назад у байти (наприклад, 1621350140) у велике значення типу. Сподіваюся, це корисно для інших, хто шукає рішення для перетворення байтів у рядок і назад у байти.

public static string BytesAsString(float bytes)
{
    string[] suffix = { "B", "KB", "MB", "GB", "TB" };
    int i;
    double doubleBytes = 0;

    for (i = 0; (int)(bytes / 1024) > 0; i++, bytes /= 1024)
    {
        doubleBytes = bytes / 1024.0;
    }

    return string.Format("{0:0.00} {1}", doubleBytes, suffix[i]);
}

public static long StringAsBytes(string bytesString)
{
    if (string.IsNullOrEmpty(bytesString))
    {
        return 0;
    }

    const long OneKb = 1024;
    const long OneMb = OneKb * 1024;
    const long OneGb = OneMb * 1024;
    const long OneTb = OneGb * 1024;
    double returnValue;
    string suffix = string.Empty;

    if (bytesString.IndexOf(" ") > 0)
    {
        returnValue = float.Parse(bytesString.Substring(0, bytesString.IndexOf(" ")));
        suffix = bytesString.Substring(bytesString.IndexOf(" ") + 1).ToUpperInvariant();
    }
    else
    {
        returnValue = float.Parse(bytesString.Substring(0, bytesString.Length - 2));
        suffix = bytesString.ToUpperInvariant().Substring(bytesString.Length - 2);
    }

    switch (suffix)
    {
        case "KB":
            {
                returnValue *= OneKb;
                break;
            }

        case "MB":
            {
                returnValue *= OneMb;
                break;
            }

        case "GB":
            {
                returnValue *= OneGb;
                break;
            }

        case "TB":
            {
                returnValue *= OneTb;
                break;
            }

        default:
            {
                break;
            }
    }

    return Convert.ToInt64(returnValue);
}

Можу чи я запитати , чому ви використовуєте float.Parseдля double?
John_J

1

Я знаю, це вже стара нитка. але, можливо, хтось шукатиме рішення. А ось що я використовую і найпростіший спосіб

  public static string FormatFileSize(long bytes) 
    {
        var unit = 1024;
        if (bytes < unit)
        {
            return $"{bytes} B";
        }
        var exp = (int)(Math.Log(bytes) / Math.Log(unit));
        return $"{bytes / Math.Pow(unit, exp):F2} " +
               $"{("KMGTPE")[exp - 1]}B";
    }

0

Як щодо:

public void printMB(uint sizekB)   
{
    double sizeMB = (double) sizekB / 1024;
    Console.WriteLine("Size is " + sizeMB.ToString("0.00") + "MB");
}

Наприклад, дзвінок як

printMB(123456);

Це призведе до виходу

"Size is 120,56 MB"

0

Я пішов на рішення JerKimballs, і великі пальці до цього. Однак я хотів би додати / зазначити, що це справді питання суперечки в цілому. У своєму дослідженні (з інших причин) я прийшов до наступних відомостей.

Коли нормальні люди (я чув, що вони існують) говорять про гігабайти, вони посилаються на метричну систему, де 1000 до потужності 3 від початкової кількості байтів == кількість гігабайт. Однак, звичайно, є стандарти IEC / JEDEC, які добре підсумовуються у wikipedia, які замість 1000 до потужності x мають 1024. Що для фізичних пристроїв зберігання даних (і я думаю, що це логічно, таких як amazon та інші) означає постійно зростаюча різниця між показниками та IEC. Так, наприклад, 1 ТБ == 1 мегабайт терабайт становить 1000 до потужності 4, але IEC офіційно називає аналогічне число, як 1 TiB, тебібайт - 1024, ніж потужність 4. Але, на жаль, у нетехнічних додатках (я б ідіть за аудиторією) норма метрична, і в моєму власному додатку для внутрішнього використання я пояснюю різницю в документації. Але для цілей відображення я не пропоную навіть нічого, крім метрики. Внутрішнє, навіть якщо це не актуально в моєму додатку, я зберігаю лише байти та роблю розрахунок для відображення.

Як бічне зауваження, я вважаю дещо невдалим, що .Net Framework AFAIK (і я часто помиляюся, дякую повноваженням), навіть якщо він є 4,5 втіленням, не містить нічого про це у будь-яких бібліотеках всередині країни. Можна було б очікувати, що бібліотека з відкритим кодом якогось типу буде NuGettable в якийсь момент, але я визнаю, що це маленький погляд. З іншого боку System.IO.DriveInfo та інші також мають лише байти (як довгі), що досить зрозуміло.


0
public static class MyExtension
{
    public static string ToPrettySize(this float Size)
    {
        return ConvertToPrettySize(Size, 0);
    }
    public static string ToPrettySize(this int Size)
    {
        return ConvertToPrettySize(Size, 0);
    }
    private static string ConvertToPrettySize(float Size, int R)
    {
        float F = Size / 1024f;
        if (F < 1)
        {
            switch (R)
            {
                case 0:
                    return string.Format("{0:0.00} byte", Size);
                case 1:
                    return string.Format("{0:0.00} kb", Size);
                case 2:
                    return string.Format("{0:0.00} mb", Size);
                case 3:
                    return string.Format("{0:0.00} gb", Size);
            }
        }
        return ConvertToPrettySize(F, ++R);
    }
}

0

Як щодо рекурсії:

private static string ReturnSize(double size, string sizeLabel)
{
  if (size > 1024)
  {
    if (sizeLabel.Length == 0)
      return ReturnSize(size / 1024, "KB");
    else if (sizeLabel == "KB")
      return ReturnSize(size / 1024, "MB");
    else if (sizeLabel == "MB")
      return ReturnSize(size / 1024, "GB");
    else if (sizeLabel == "GB")
      return ReturnSize(size / 1024, "TB");
    else
      return ReturnSize(size / 1024, "PB");
  }
  else
  {
    if (sizeLabel.Length > 0)
      return string.Concat(size.ToString("0.00"), sizeLabel);
    else
      return string.Concat(size.ToString("0.00"), "Bytes");
  }
}

Тоді ви можете назвати це:

ReturnSize(size, string.Empty);

0

Як було зазначено вище, рекурсія є улюбленим способом за допомогою логарифму.

Наступна функція має 3 аргументи: вхід, обмеження розміру виводу, тобто третій аргумент.

int ByteReDim(unsigned long ival, int constraint, unsigned long *oval)
{
    int base = 1 + (int) log10(ival);

    (*oval) = ival;
    if (base > constraint) {
        (*oval) = (*oval) >> 10;
        return(1 + ByteReDim((*oval), constraint, oval));
    } else
        return(0);
}

Тепер давайте перетворимо 12 ГБ оперативної пам’яті в кілька блоків:

int main(void)
{
    unsigned long RAM;
    int unit; // index of below symbols array
    char symbol[5] = {'B', 'K', 'M', 'G', 'T'};

    unit = ByteReDim(12884901888, 12, &RAM);
    printf("%lu%c\n", RAM, symbol[unit]); // output is 12884901888B

    unit = ByteReDim(12884901888, 9, &RAM);
    printf("%lu%c\n", RAM, symbol[unit]); // output is 12582912K

    unit = ByteReDim(12884901888, 6, &RAM);
    printf("%lu%c\n", RAM, symbol[unit]); // output is 12288M

    unit = ByteReDim(12884901888, 3, &RAM);
    printf("%lu%c\n", RAM, symbol[unit]); // output is 12G
}

0

Я використовую це для Windows (бінарні префікси):

static readonly string[] BinaryPrefix = { "bytes", "KB", "MB", "GB", "TB" }; // , "PB", "EB", "ZB", "YB"
string GetMemoryString(double bytes)
{
    int counter = 0;
    double value = bytes;
    string text = "";
    do
    {
        text = value.ToString("0.0") + " " + BinaryPrefix[counter];
        value /= 1024;
        counter++;
    }
    while (Math.Floor(value) > 0 && counter < BinaryPrefix.Length);
    return text;
}

0

Я включив це (майже не змінюючи) в конвертер UWP DataBinding для свого проекту і подумав, що він може бути корисним і для інших.

Код:

using System;
using System.Text;
using Windows.UI.Xaml.Data;

namespace MyApp.Converters
{
    public class ByteSizeConverter : IValueConverter
    {
        static readonly string[] sSizeSuffixes = { "bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB" };

        // The number of decimal places the formatter should include in the scaled output - default 1dp
        public int DecimalPlaces { get; set; } = 1;

        public object Convert(object value, Type targetType, object parameter, string language)
        {
            Int64 intVal = System.Convert.ToInt64(value);

            return SizeSuffix(intVal);
        }

        public object ConvertBack(object value, Type targetType, object parameter, string language)
        {
            // TODO: Parse string into number and suffix
            //       Scale number by suffix multiplier to get bytes
            throw new NotImplementedException();
        }

        string SizeSuffix(Int64 value)
        {
            if (this.DecimalPlaces < 0) { throw new ArgumentOutOfRangeException(String.Format("DecimalPlaces = {0}", this.DecimalPlaces)); }
            if (value < 0) { return "-" + SizeSuffix(-value); }
            if (value == 0) { return string.Format("{0:n" + this.DecimalPlaces + "} bytes", 0); }

            // magnitude is 0 for bytes, 1 for KB, 2, for MB, etc.
            int magnitude = (int)Math.Log(value, 1024);
            // clip magnitude - only 8 values currently supported, this prevents out-of-bounds exception
            magnitude = Math.Min(magnitude, 8);

            // 1L << (magnitude * 10) == 2 ^ (10 * magnitude) [i.e. the number of bytes in the unit corresponding to magnitude]
            decimal adjustedSize = (decimal)value / (1L << (magnitude * 10));

            // make adjustment when the value is large enough that it would round up to 1000 or more
            if (Math.Round(adjustedSize, this.DecimalPlaces) >= 1000)
            {
                magnitude += 1;
                adjustedSize /= 1024;
            }

            return String.Format("{0:n" + this.DecimalPlaces + "} {1}", adjustedSize, sSizeSuffixes[magnitude]);
        }
    }
}

Щоб використовувати його, додайте локальний ресурс до свого UserControl або Page XAML:

<UserControl.Resources>
    <converters:ByteSizeConverter x:Key="ByteFormat" DecimalPlaces="3" />
</UserControl.Resources>

Посилайтеся на нього в шаблон зв’язування даних або примірник прив'язки даних:

<TextBlock HorizontalAlignment="Left" VerticalAlignment="Center"
    Text="{x:Bind MyItem.FileSize_bytes, Mode=OneWay, Converter={StaticResource ByteFormat}}" />

І ей престо. Магія буває.


Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.