Предоставляет ли .NET простой способ конвертировать байты в КБ, МБ, ГБ и т. Д.?


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

и т.д...

Ответы:


193

Вот довольно краткий способ сделать это:

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

Следует иметь в виду одну вещь: в системе СИ, «килограмм» обычно использует строчную букву k, в то время как все более крупные единицы используют заглавную букву. Windows использует КБ, МБ, ГБ, поэтому я использовал КБ выше, но вместо этого вы можете рассмотреть КБ.


Спрашивающий ищет только 1 десятичный знак точности. Не могли бы вы привести пример ввода, который дает неправильный вывод?
JLRishe

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

Спасибо, именно то, что я искал. (2-я реализация.)
snapplex

1
Очень аккуратная реализация. Обратите внимание, что если вы передадите значение 0 этой функции, она вызовет исключение IndexOutOfRangeException. Решил добавить в функцию if (value == 0) { return "0"; }проверку.
bounav 06

Можете ли вы представить случай, когда размер файла <0? Для меня это выглядит странно ...
Руслан Ф.

86

Оформить заказ в библиотеке 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 и выше.
The Joker

34
Это должно быть включено как часть .NET framework
helios456,

Единственная проблема, которую я вижу, заключается в том, что методы преобразования работают только от небайта к байту, но не наоборот.
SuperJMN

@SuperJMN что вы имеете в виду небайтовое? Как биты? Вы можете использовать метод .FromBits.
Омар

1
Если ваши исходные данные представляют собой нечто иное, чем «байты», и вам нужно иметь возможность конвертировать во что угодно ... это библиотека, которую вы должны использовать.
Джеймс Блейк

38

Поскольку все остальные публикуют свои методы, я решил опубликовать метод расширения, который обычно использую для этого:

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
Шикарное решение!
yossico

1
Я использовал вашу идею, чтобы создать тот, который автоматически определяет единицы измерения. +1
Луи Сомерс

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

6

В краткой версии ответа, получившего наибольшее количество голосов, есть проблемы со значениями TB.

Я настроил его соответствующим образом, чтобы обрабатывать также значения 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

Нет. В основном потому, что это довольно узкоспециализированная потребность, и существует слишком много возможных вариантов. (Это «КБ», «КБ» или «Ко»? Мегабайт 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, также известный как ГБ)


3

@ Servy ответил красиво и лаконично. Думаю, может быть еще проще?

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) как значение типа long. Я надеюсь, что это будет полезно для других, которые ищут решение для преобразования байтов в строку и обратно в байты.

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, которые красиво обобщены в википедии, где вместо 1000 в степени x они имеют 1024. Что для физических устройств хранения (и я думаю, что логично, например, Amazon и других) означает постоянно увеличивающаяся разница между метрикой и IEC. Так, например, 1 ТБ == 1 терабайт равен 1000 в степени 4, но IEC официально называет это число как 1 ТиБ, тебибайт как 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 Converter для своего проекта и подумал, что он также может быть полезен другим.

Код такой:

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 или 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}}" />

И привет. Волшебство случается.


0

https://github.com/logary/logary/blob/master/src/Logary/DataModel.fs#L832-L837

let scaleBytes (value : float) : float * string =
    let log2 x = log x / log 2.
    let prefixes = [| ""; "Ki"; "Mi"; "Gi"; "Ti"; "Pi" |] // note the capital K and the 'i'
    let index = int (log2 value) / 10
    1. / 2.**(float index * 10.),
sprintf "%s%s" prefixes.[index] (Units.symbol Bytes)

(ОТКАЗ ОТ ОТВЕТСТВЕННОСТИ: я написал этот код, даже код в ссылке!)

Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.