在C＃中将字节转换为GB？

18

如果准确的精度并不重要，使用双：

double gb = kb/1048576D

与帕维尔在这里同意 - 有没有真正的任何需要重构的代码......其实，如果这是在你的代码库的最大问题，我想你可能会坐在有史以来最好的软件上。

来源

2009-08-07 00:30:28

+2

+ 1对使用双重，但我认为原来执行的意图更清晰。 – Marc 2009-08-07 00:40:28

+1

@Marc可能。我认为gb = kb ...部分是一个很好的线索:) – 2009-08-07 00:41:59

+0

你可以通过声明一个常量来提高值1048576的可读性，这个意图揭示了一个名字...... – mezoid 2009-08-15 00:52:45

2

就我个人而言，我会这样写：decimal GB = KB/(1024 * 1024);，但确实没有必要重写代码。

来源

2009-08-07 00:42:35 mattnewport

7

原始代码简洁，易于阅读，并具有合理的变量名称，自我记录;我不会改变它。

如果你绝对必须重构，你可以创建上的数字类型的一组扩展方法：

public static double BytesToKilobytes(this Int32 bytes) 
{ 
    return bytes/1024d; 
} 
public static double BytesToMegabytes(this Int32 bytes) 
{ 
    return bytes/1024d/1024d; 
} 
public static double KilobytesToBytes(this double kilobytes) 
{ 
    return kilobytes * 1024d; 
} 

//You can then do something like: 
double filesize = 32.5d; 
double bytes = filesize.KilobytesToBytes();

但是，除非你的代码做几乎没有，但字节转换为千字节等等，这一切真的会做的是混乱了Intellisense没有真正的收益。

来源

2009-08-07 00:50:58 technophile

2

那么，公式是错误的（在千兆字节中只有大约一百万千字节，而不是千万字节），但除此之外，没关系。任何以前使用这些号码的人都会知道它的含义。

我会注意的一件事（我不知道这是否是C＃的问题）是如果x不是基本类型，编译器可能无法优化x/1024/1024。使用C和整数，编译器可以很容易地将其转换为“盲目快速移位 - 右乘20位”指令。

如果十进制是一个类而不是基本类型，编译器可能不得不做两个除法操作。这是否对速度有任何实际影响（或者甚至是否真的发生）都超出了我的知识领域。

我会考虑改变的一件事是实际的变量名称。它对编译代码并没有真正的区别，但我更喜欢较长的变量名称而不是缩写，所以我会选择kiloBytes/gigaBytes或类似的东西。根据您的编码标准，KB/GB太容易与常量混淆。

来源

2009-08-07 01:12:46 paxdiablo

+0

decimal是一个内置的类型，而不是类。但它也不支持bitshifts，即使它们有意义。也许编译器可以在这种情况下使用它们，即使程序员不能。 – 2014-08-20 03:15:13

1

为了确保预编译计算除数：

decimal GB = KB/(1024 * 1024);

请注意，您在实际计算吉布（gibibyte），而不是GB（千兆字节）。如果你真的想计算国标，那将是：

decimal GB = KB/(1000 * 1000);

来源

2009-08-07 01:24:17 Guffa

+1

在一般用法中，千兆字节用于表示1024^3字节，兆字节表示1024^2，千字节表示1024.它在技术上可能不正确，但我不认为这里有任何人（其他人）会介意。 – snarf 2009-08-07 01:30:23

+0

是的，大多数人都没有意识到标准事件，尽管它已经存在了十年以上，这就是为什么我对它做了一个说明...... – Guffa 2009-08-07 07:14:38

+0

“标准”只是没有真正的标准事件，因为它改变了常见的意义为常见的事物创造新词。这就是为什么没有人接受这个标准，来自行业制定的标准。 – 2009-08-08 13:42:49

1

理论上，这是更快的（预计算常数做乘法而不是除法）。它可能没有足够重要，但以防万一。

double const KbToGbFactor = 1d/1024 /1024; 

double gb = kb * KbToGbFactor;

来源

2009-08-08 13:38:19

+1

我非常肯定这将在程序编译时进行优化。不管你是否想要一个const在这里，这更多的是品味的问题。 – Spoike 2010-01-17 22:29:37

+0

我不太确定 - http://blogs.msdn.com/ericlippert/archive/2009/06/11/what-does-the-optimize-switch-do.aspx – 2010-01-18 10:57:33

+0

我喜欢这个答案的“清晰度” （在我看来），但不是用于“优化”。 Uhg :-) – 2010-10-21 06:21:19

80

我在这里开发了这个方法，工作到结核病。

private static string FormatBytes(long bytes) 
{ 
    string[] Suffix = { "B", "KB", "MB", "GB", "TB" }; 
    int i; 
    double dblSByte = bytes; 
    for (i = 0; i < Suffix.Length && bytes >= 1024; i++, bytes /= 1024) 
    { 
     dblSByte = bytes/1024.0; 
    } 

    return String.Format("{0:0.##} {1}", dblSByte, Suffix[i]); 
}

来源

2010-01-17 22:18:31 JLopez

+3

有点从主题走了，但我喜欢这个把戏。 +1 – ktutnik 2011-09-25 01:41:58

+0

我同意@ktutnik关于第二部分！ – Shimmy 2012-12-20 10:36:33

+0

这是如何工作的？你在if/else中缺少返回类型 – Kimtho6 2013-08-07 10:22:32

3

/// <summary> 
/// Function to convert the given bytes to either Kilobyte, Megabyte, or Gigabyte 
/// </summary> 
/// <param name="bytes">Double -> Total bytes to be converted</param> 
/// <param name="type">String -> Type of conversion to perform</param> 
/// <returns>Int32 -> Converted bytes</returns> 
/// <remarks></remarks> 
public static double ConvertSize(double bytes, string type) 
{ 
    try 
    { 
     const int CONVERSION_VALUE = 1024; 
     //determine what conversion they want 
     switch (type) 
     { 
      case "BY": 
       //convert to bytes (default) 
       return bytes; 
      case "KB": 
       //convert to kilobytes 
       return (bytes/CONVERSION_VALUE); 
      case "MB": 
       //convert to megabytes 
       return (bytes/CalculateSquare(CONVERSION_VALUE)); 
      case "GB": 
       //convert to gigabytes 
       return (bytes/CalculateCube(CONVERSION_VALUE)); 
      default: 
       //default 
       return bytes; 
      } 
    } 
    catch (Exception ex) 
    { 
     Console.WriteLine(ex.Message); 
     return 0; 
     } 
} 

/// <summary> 
/// Function to calculate the square of the provided number 
/// </summary> 
/// <param name="number">Int32 -> Number to be squared</param> 
/// <returns>Double -> THe provided number squared</returns> 
/// <remarks></remarks> 
public static double CalculateSquare(Int32 number) 
{ 
    return Math.Pow(number, 2); 
} 


/// <summary> 
/// Function to calculate the cube of the provided number 
/// </summary> 
/// <param name="number">Int32 -> Number to be cubed</param> 
/// <returns>Double -> THe provided number cubed</returns> 
/// <remarks></remarks> 
public static double CalculateCube(Int32 number) 
{ 
    return Math.Pow(number, 3); 
} 

//Sample Useage 
String Size = "File is " + ConvertSize(250222,"MB") + " Megabytes in size"

来源

2010-10-21 06:11:34

1

我需要它周围的其他方法，从在词语第三方组件文字大小转换（例如，“0字节”，“1.1 MB”）转换成通用的大小以字节计。所以我用这种方式：

 private static long UnformatBytes(string sizeInWords) 
    { 
     if(string.IsNullOrWhiteSpace(sizeInWords)) 
      return -1; 

     string size = sizeInWords.Split(' ').FirstOrDefault(); 
     double result; 
     if (string.IsNullOrWhiteSpace(size) || !double.TryParse(size, out result)) 
     { 
      Debugger.Break(); 
      return -1; 
     } 

     int pow; 

     if (sizeInWords.IndexOf("byte", StringComparison.OrdinalIgnoreCase) > -1) 
      pow = 0; 
     else if (sizeInWords.IndexOf("kb", StringComparison.OrdinalIgnoreCase) > -1) 
      pow = 1; 
     else if (sizeInWords.IndexOf("mb", StringComparison.OrdinalIgnoreCase) > -1) 
      pow = 2; 
     else if (sizeInWords.IndexOf("gb", StringComparison.OrdinalIgnoreCase) > -1) 
      pow = 3; 
     else if (sizeInWords.IndexOf("tb", StringComparison.OrdinalIgnoreCase) > -1) 
      pow = 4; 
     else 
      return -1; 

     return System.Convert.ToInt64((result * Math.Pow(1024, pow))); 
    }

来源

2013-04-02 18:53:01

2

我写了一个小工具类执行单位之间的转换，心连心..

#region StorageDifferential 
/// <summary> 
/// Converts between Base 2 or Base 10 storage units [TB, GB, MB, KB, Bytes] 
/// </summary> 
public enum Differential : int 
{ 
    /// <summary> 
    /// Convert Bytes to Kilobytes 
    /// </summary> 
    ByteToKilo, 
    /// <summary> 
    /// Convert Bytes to Megabytes 
    /// </summary> 
    ByteToMega, 
    /// <summary> 
    /// Convert Bytes to Gigabytes 
    /// </summary> 
    ByteToGiga, 
    /// <summary> 
    /// Convert Bytes to Teraytes 
    /// </summary> 
    ByteToTera, 
    /// <summary> 
    /// Convert Kilobytes to Bytes 
    /// </summary> 
    KiloToByte, 
    /// <summary> 
    /// Convert Kilobytes to Megabytes 
    /// </summary> 
    KiloToMega, 
    /// <summary> 
    /// Convert Kilobytes to Gigabytes 
    /// </summary> 
    KiloToGiga, 
    /// <summary> 
    /// Convert Kilobytes to Terabytes 
    /// </summary> 
    KiloToTera, 
    /// <summary> 
    /// Convert Megabytes to Bytes 
    /// </summary> 
    MegaToByte, 
    /// <summary> 
    /// Convert Megabytes to Kilobytes 
    /// </summary> 
    MegaToKilo, 
    /// <summary> 
    /// Convert Megabytes to Gigabytes 
    /// </summary> 
    MegaToGiga, 
    /// <summary> 
    /// Convert Megabytes to Terabytes 
    /// </summary> 
    MegaToTera, 
    /// <summary> 
    /// Convert Gigabytes to Bytes 
    /// </summary> 
    GigaToByte, 
    /// <summary> 
    /// Convert Gigabytes to Kilobytes 
    /// </summary> 
    GigaToKilo, 
    /// <summary> 
    /// Convert Gigabytes to Megabytes 
    /// </summary> 
    GigaToMega, 
    /// <summary> 
    /// Convert Gigabytes to Terabytes 
    /// </summary> 
    GigaToTerra, 
    /// <summary> 
    /// Convert Terabyte to Bytes 
    /// </summary> 
    TeraToByte, 
    /// <summary> 
    /// Convert Terabyte to Kilobytes 
    /// </summary> 
    TeraToKilo, 
    /// <summary> 
    /// Convert Terabytes to Megabytes 
    /// </summary> 
    TeraToMega, 
    /// <summary> 
    /// Convert Terabytes to Gigabytes 
    /// </summary> 
    TeraToGiga, 
} 
#endregion 

#region Storage Sizes 
/// <summary> 
/// Enumeration of recognized storage sizes [in Bytes] 
/// </summary> 
public enum StorageSizes : long 
{ 
    /// <summary> 
    /// Base 10 Conversion 
    /// </summary> 
    KILOBYTE = 1000, 
    MEGABYTE = 1000000, 
    GIGABYTE = 1000000000, 
    TERABYTE = 1000000000000, 
    /// <summary> 
    /// Base 2 Conversion 
    /// </summary> 
    KIBIBYTE = 1024, 
    MEBIBYTE = 1048576, 
    GIBIBYTE = 1073741824, 
    TEBIBYTE = 1099511627776, 
} 
#endregion 

#region StorageBase 
/// <summary> 
/// Storage powers 10 based or 1024 based 
/// </summary> 
public enum StorageBase : int 
{ 
    /// <summary> 
    /// 1024 Base power, Typically used in memory measurements 
    /// </summary> 
    BASE2, 
    /// <summary> 
    /// 10 Base power, Used in storage mediums like harddrives 
    /// </summary> 
    BASE10, 
} 
#endregion 

/// <summary> 
/// Convert between base 1024 storage units [TB, GB, MB, KB, Byte] 
/// </summary> 
public static class StorageConverter 
{ 
    /// <summary> 
    /// Convert between base 1024 storage units [TB, GB, MB, KB, Byte] 
    /// </summary> 
    /// <param name="SizeDifferential">Storage conversion differential [enum]</param> 
    /// <param name="UnitSize">Size as mutiple of unit type units [double]</param> 
    /// <param name="BaseUnit">Size of the base power [enum]</param> 
    /// <returns>Converted unit size [double]</returns> 
    public static double Convert(Differential SizeDifferential, double UnitSize, StorageBase BaseUnit = StorageBase.BASE10) 
    { 
     if (UnitSize < 0.000000000001) return 0; 

     double POWER1 = 1000; 
     double POWER2 = 1000000; 
     double POWER3 = 1000000000; 
     double POWER4 = 1000000000000; 

     if (BaseUnit == StorageBase.BASE2) 
     { 
      POWER1 = 1024; 
      POWER2 = 1048576; 
      POWER3 = 1073741824; 
      POWER4 = 1099511627776; 
     } 

     switch (SizeDifferential) 
     { 
      case Differential.ByteToKilo: 
       return UnitSize/POWER1; 
      case Differential.ByteToMega: 
       return UnitSize/POWER2; 
      case Differential.ByteToGiga: 
       return UnitSize/POWER3; 
      case Differential.ByteToTera: 
       return UnitSize/POWER4; 
      case Differential.KiloToByte: 
       return UnitSize * POWER1; 
      case Differential.KiloToMega: 
       return UnitSize/POWER1; 
      case Differential.KiloToGiga: 
       return UnitSize/POWER2; 
      case Differential.KiloToTera: 
       return UnitSize/POWER3; 
      case Differential.MegaToByte: 
       return UnitSize * POWER2; 
      case Differential.MegaToKilo: 
       return UnitSize * POWER1; 
      case Differential.MegaToGiga: 
       return UnitSize/POWER1; 
      case Differential.MegaToTera: 
       return UnitSize/POWER2; 
      case Differential.GigaToByte: 
       return UnitSize * POWER3; 
      case Differential.GigaToKilo: 
       return UnitSize * POWER2; 
      case Differential.GigaToMega: 
       return UnitSize * POWER1; 
      case Differential.GigaToTerra: 
       return UnitSize/POWER1; 
      case Differential.TeraToByte: 
       return UnitSize * POWER4; 
      case Differential.TeraToKilo: 
       return UnitSize * POWER3; 
      case Differential.TeraToMega: 
       return UnitSize * POWER2; 
      case Differential.TeraToGiga: 
       return UnitSize * POWER1; 
     } 

     return 0; 
    } 
}

来源

2013-12-02 21:55:18 JGU

0

public static string BytesToString(this long bytes, string format = "#,##0.00") { 
     var unitstr = new string[] { "B", "KB", "MB", "GB", "TB" }; 
     var bytesd = Convert.ToDouble(bytes); 
     var unit = 0; 
     while (bytesd/1024D > 1 && unit < unitstr.Length) { 
      unit++; bytesd /= 1024D; 
     } 
     return string.Format("{0:" + format + "}{1}", bytesd, unitstr[unit]); 
    }

来源

2014-03-03 09:52:12 Leo

0

#region AutoFileSize 
    public string AutoFileSize(long number) 
    { 
     double tmp = number; 
     string suffix = " B "; 
     if (tmp > 1024) { tmp = tmp/1024; suffix = " KB"; } 
     if (tmp > 1024) { tmp = tmp/1024; suffix = " MB"; } 
     if (tmp > 1024) { tmp = tmp/1024; suffix = " GB"; } 
     if (tmp > 1024) { tmp = tmp/1024; suffix = " TB"; } 
     return tmp.ToString("n") + suffix; 
    } 
    #endregion 

long number = (long)fu.PostedFile.ContentLength;

来源

2014-08-20 02:22:04 user3958481

1

这是很好的一个小改进JLopez的回答（请投票给他，不是我）。在这里，你可以选择或不单位指示和公斤单元被写入与小写字母“K”（大写一个为开尔文）

//note: this is the JLopez answer!! 
/// <summary> 
/// Return size in human readable form 
/// </summary> 
/// <param name="bytes">Size in bytes</param> 
/// <param name="useUnit ">Includes measure unit (default: false)</param> 
/// <returns>Readable value</returns> 
public static string FormatBytes(long bytes, bool useUnit = false) 
    { 
     string[] Suffix = { " B", " kB", " MB", " GB", " TB" }; 
     double dblSByte = bytes; 
     int i; 
     for (i = 0; i < Suffix.Length && bytes >= 1024; i++, bytes /= 1024) 
     { 
      dblSByte = bytes/1024.0; 
     } 
     return $"{dblSByte:0.##}{(useUnit ? Suffix[i] : null)}"; 
    }

来源

2017-05-29 14:12:45 tedebus

在C＃中将字节转换为GB？

回答

相关问题