.NET có cung cấp một cách dễ dàng để chuyển đổi byte sang KB, MB, GB, v.v. không?

Chỉ cần tự hỏi liệu .NET có cung cấp một cách rõ ràng để thực hiện việc này hay không:

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

Vân vân...

Đây là một cách khá ngắn gọn để làm điều này:

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

Và đây là cách triển khai ban đầu mà tôi đã đề xuất, có thể chậm hơn một chút, nhưng dễ thực hiện hơn một chút:

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

Một điều cần lưu ý - trong ký hiệu SI, "kilo" thường sử dụng chữ k viết thường trong khi tất cả các đơn vị lớn hơn sử dụng chữ hoa. Windows sử dụng KB, MB, GB, vì vậy tôi đã sử dụng KB ở trên, nhưng bạn có thể cân nhắc kB để thay thế.

Kiểm tra thư viện ByteSize . Đó là System.TimeSpancho byte!

Nó xử lý việc chuyển đổi và định dạng cho bạn.

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

Nó cũng biểu diễn và phân tích cú pháp chuỗi.

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

Vì mọi người khác đang đăng các phương pháp của họ, tôi đã nghĩ rằng tôi sẽ đăng phương pháp mở rộng mà tôi thường sử dụng cho việc này:

CHỈNH SỬA: đã thêm biến thể int / long ... và sửa lỗi đánh máy 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;
    }
}

Tôi sẽ giải quyết nó bằng cách sử dụng Extension methods, Math.Powhàm và 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");
    }
}

và sử dụng nó như:

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

Phiên bản ngắn của câu trả lời được bình chọn nhiều nhất có vấn đề với giá trị TB.

Tôi đã điều chỉnh nó một cách thích hợp để xử lý các giá trị tb mà vẫn không có vòng lặp và cũng thêm một chút lỗi kiểm tra các giá trị âm. Đây là giải pháp của tôi:

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

Không. Chủ yếu là vì nó là một nhu cầu khá thích hợp và có quá nhiều biến thể có thể xảy ra. (Đó là "KB", "Kb" hay "Ko"? Là megabyte 1024 * 1024 byte hay 1024 * 1000 byte? - vâng, một số nơi sử dụng điều đó!)

Đây là một tùy chọn dễ mở rộng hơn của bạn, nhưng không, không có tùy chọn nào được tích hợp sẵn trong thư viện.

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

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

Đây là một cách để làm điều đó (Số 1073741824.0 là từ 1024 * 1024 * 1024 hay còn gọi là GB)

Câu trả lời của @ Servy rất hay và ngắn gọn. Tôi nghĩ nó thậm chí có thể đơn giản hơn?

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

Dựa trên giải pháp thanh lịch của 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)
}

Có thể có những nhận xét quá đáng, nhưng tôi có xu hướng để lại chúng để ngăn bản thân mắc phải những sai lầm tương tự trong những lần thăm sau ...

Không.

Nhưng bạn có thể thực hiện như thế này;

    static double ConvertBytesToMegabytes(long bytes)
    {
    return (bytes / 1024f) / 1024f;
    }

    static double ConvertKilobytesToMegabytes(long kilobytes)
    {
    return kilobytes / 1024f;
    }

Ngoài ra, hãy xem Làm thế nào để chuyển đổi chính xác kích thước tệp tính bằng byte thành mega hoặc gigabyte?

Tôi đã kết hợp một số câu trả lời ở đây thành hai phương pháp hoạt động hiệu quả. Phương thức thứ hai bên dưới sẽ chuyển đổi từ chuỗi byte (như 1,5,1 GB) trở lại thành byte (như 1621350140) dưới dạng giá trị kiểu dài. Tôi hy vọng điều này hữu ích cho những người khác đang tìm kiếm giải pháp để chuyển đổi byte thành một chuỗi và trở lại thành byte.

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

Tôi biết đây là chủ đề cũ rồi. nhưng có thể ai đó sẽ tìm kiếm giải pháp. Và đây là những gì tôi sử dụng và cách dễ nhất

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

Làm thế nào về:

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

Vd: gọi like

printMB(123456);

Sẽ dẫn đến đầu ra

"Size is 120,56 MB"

Tôi đã chọn giải pháp JerKimballs và đồng ý với điều đó. Tuy nhiên, tôi muốn nói thêm / chỉ ra rằng đây thực sự là một vấn đề gây tranh cãi nói chung. Trong nghiên cứu của mình (vì những lý do khác), tôi đã đưa ra những thông tin sau.

Khi những người bình thường (tôi nghe nói rằng họ tồn tại) nói về gigabyte, họ đề cập đến hệ thống số liệu trong đó 1000 đến lũy thừa của 3 từ số byte ban đầu == số gigabyte. Tuy nhiên, tất nhiên có các tiêu chuẩn IEC / JEDEC được tóm tắt độc đáo trong wikipedia, thay vì 1000 với sức mạnh của x, chúng có 1024. Đối với các thiết bị lưu trữ vật lý (và tôi đoán hợp lý như amazon và những người khác) có nghĩa là sự khác biệt ngày càng tăng giữa metric và IEC. Vì vậy, ví dụ, số liệu 1 TB == 1 terabyte là 1000 bằng lũy ​​thừa của 4, nhưng IEC chính thức gọi con số tương tự là 1 TiB, tebibyte là 1024 bằng lũy ​​thừa của 4. Nhưng, than ôi, trong các ứng dụng phi kỹ thuật (tôi sẽ theo đối tượng) tiêu chuẩn là số liệu và trong ứng dụng của riêng tôi để sử dụng nội bộ hiện tại, tôi giải thích sự khác biệt trong tài liệu. Nhưng đối với mục đích hiển thị, tôi thậm chí không cung cấp bất cứ thứ gì ngoài số liệu. Trong nội bộ mặc dù nó không có liên quan trong ứng dụng của tôi, tôi chỉ lưu trữ byte và thực hiện tính toán để hiển thị.

Một lưu ý nhỏ là tôi thấy hơi mờ nhạt rằng .Net framework AFAIK (và tôi thường xuyên nhầm lẫn, cảm ơn các quyền hạn đó) ngay cả trong phiên bản 4.5 của nó không chứa bất kỳ điều gì về điều này trong bất kỳ thư viện nội bộ nào. Người ta sẽ mong đợi một thư viện mã nguồn mở nào đó giống như NuGettable vào một thời điểm nào đó, nhưng tôi thừa nhận rằng đây là một lỗi nhỏ. Mặt khác, System.IO.DriveInfo và những người khác cũng chỉ có byte (miễn là) khá rõ ràng.

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

Làm thế nào về một số đệ quy:

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

Sau đó, bạn có thể gọi nó là:

ReturnSize(size, string.Empty);

Như đã đăng ở trên, đệ quy là cách ưa thích, với sự trợ giúp của logarit.

Hàm sau có 3 đối số: đầu vào, ràng buộc thứ nguyên của đầu ra, đó là đối số thứ ba.

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

Bây giờ, hãy chuyển đổi 12GB RAM thành một số đơn vị:

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
}

Tôi sử dụng cái này cho Windows (tiền tố nhị phân):

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

Tôi đã kết hợp điều này (với ít hoặc không sửa đổi) vào một Công cụ chuyển đổi dữ liệu UWP cho dự án của mình và nghĩ rằng nó cũng có thể hữu ích cho những người khác.

Mã là:

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

Để sử dụng nó, hãy thêm tài nguyên cục bộ vào UserControl hoặc Trang XAML của bạn:

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

Tham chiếu nó trong một mẫu liên kết dữ liệu hoặc phiên bản liên kết dữ liệu:

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

Và hey presto. Điều kỳ diệu xảy ra.

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)

(KHUYẾN CÁO: Tôi đã viết mã này, ngay cả mã trong liên kết!)