Does NET provide an easy way convert bytes to KB MB GB etc

Question

Just wondering if  NET provides a clean way to do this   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       etc

User · Answer

I know this is old thread already  but maybe someone will look for solution  And here s what I use and the easiest way public static string FormatFileSize long bytes        var unit   1024      if  bytes  lt  unit    return   quot  bytes  B quot          var exp    int  Math Log bytes    Math Log unit        return   quot  bytes   Math Pow unit  exp  F2     quot KMGTPE quot   exp - 1  B quot      Get folder size  for example usage  public static long GetFolderSize string path  string ext  bool AllDir        var option   AllDir   SearchOption AllDirectories   SearchOption TopDirectoryOnly      return new DirectoryInfo path  EnumerateFiles  quot   quot    ext  option  Sum file   gt  file Length      EXAMPLE USAGE  public static void TEST         string folder     quot C  Users User Videos quot        var bytes   GetFolderSize folder   quot mp4 quot   true     or GetFolderSize folder   quot mp4 quot   false  to get all single folder only     var totalFileSize   FormatFileSize bytes       Console WriteLine totalFileSize

User · Answer

I recently needed this and required to convert the in bytes to a number in long  Usage  Byte Kb ToLong 1  should give 1024  public enum Byte       Kb      Mb      Gb      Tb    public static class ByteSize       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 long ToLong this Byte size  int value                return size switch                       Byte Kb   gt  value   OneKb              Byte Mb   gt  value   OneMb              Byte Gb   gt  value   OneGb              Byte Tb   gt  value   OneTb                  gt  throw new NotImplementedException  quot This should never be hit  quot                        Tests using xunit   Theory   InlineData Byte Kb  1  1024    InlineData Byte Kb  2  2048    InlineData Byte Mb  1  1048576    InlineData Byte Mb  2  2097152    InlineData Byte Gb  1  1073741824    InlineData Byte Gb  2  2147483648    InlineData Byte Tb  1  1099511627776    InlineData Byte Tb  2  2199023255552   public void ToLong WhenConverting ShouldMatchExpected Byte size  int value  long expected        var result   size ToLong value        result Should   Be expected

User · Answer

Here is a fairly concise way to do this  static readonly string   SizeSuffixes                          quot bytes quot    quot KB quot    quot MB quot    quot GB quot    quot TB quot    quot PB quot    quot EB quot    quot ZB quot    quot YB quot     static string SizeSuffix Int64 value  int decimalPlaces   1        if  decimalPlaces  lt  0    throw new ArgumentOutOfRangeException  quot decimalPlaces quot          if  value  lt  0    return  quot - quot    SizeSuffix -value  decimalPlaces          if  value    0    return string Format  quot  0 n quot    decimalPlaces    quot   bytes quot   0             mag is 0 for bytes  1 for KB  2  for MB  etc      int mag    int Math Log value  1024           1L  lt  lt   mag   10     2    10   mag           i e  the number of bytes in the unit corresponding to mag      decimal adjustedSize    decimal value    1L  lt  lt   mag   10            make adjustment when the value is large enough that        it would round up to 1000 or more     if  Math Round adjustedSize  decimalPlaces   gt   1000                mag    1          adjustedSize    1024             return string Format  quot  0 n quot    decimalPlaces    quot    1  quot            adjustedSize           SizeSuffixes mag       And here s the original implementation I suggested  which may be marginally slower  but a bit easier to follow  static readonly string   SizeSuffixes                         quot bytes quot    quot KB quot    quot MB quot    quot GB quot    quot TB quot    quot PB quot    quot EB quot    quot ZB quot    quot YB quot      static string SizeSuffix Int64 value  int decimalPlaces   1        if  value  lt  0    return  quot - quot    SizeSuffix -value  decimalPlaces           int i   0      decimal dValue    decimal value      while  Math Round dValue  decimalPlaces   gt   1000                dValue    1024          i               return string Format  quot  0 n quot    decimalPlaces    quot    1  quot   dValue  SizeSuffixes i       Console WriteLine SizeSuffix 100005000L     One thing to bear in mind - in SI notation   quot kilo quot  usually uses a lowercase k while all of the larger units use a capital letter  Windows uses KB  MB  GB  so I have used KB above  but you may consider kB instead

User · Answer

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       quot  quot    quot Ki quot    quot Mi quot    quot Gi quot    quot Ti quot    quot Pi quot        note the capital K and the  i      let index   int  log2 value    10     1    2    float index   10    sprintf  quot  s s quot  prefixes  index   Units symbol Bytes    DISCLAIMER  I wrote this code  even the code in the link

User · Answer

Here s my spin on  drzaus s answer   I modified it to use rounding errors to our advantage and correctly manage issues around unit boundaries   It also handles negative values  Drop this C  Program into LinqPad     Kudos  https   stackoverflow com a 48467634 117797  void Main         0 ToFriendly   Dump                            0 B     857 ToFriendly   Dump                          857 B      173 1024  ToFriendly   Dump                   173 KB      9541 1024  ToFriendly   Dump                  9 32 MB      5261890L 1024  ToFriendly   Dump              5 02 GB      1 ToFriendly   Dump                            1 B     1024 ToFriendly   Dump                         1 KB     1048576 ToFriendly   Dump                      1 MB     1073741824 ToFriendly   Dump                   1 GB     1099511627776 ToFriendly   Dump                1 TB     1125899906842620 ToFriendly   Dump             1 PB     1152921504606850000 ToFriendly   Dump          1 EB    public static class Extensions       static string    byteUnits   new      quot B quot    quot KB quot    quot MB quot    quot GB quot    quot TB quot    quot PB quot    quot EB quot          public static string ToFriendly this int number  int decimals   2                return   double number  ToFriendly decimals              public static string ToFriendly this long number  int decimals   2                return   double number  ToFriendly decimals              public static string ToFriendly this double number  int decimals   2                const double divisor   1024           int unitIndex   0          var sign   number  lt  0    quot - quot    string Empty          var value   Math Abs number           double lastValue   number           while  value  gt  1                        lastValue   value                  NOTE                The following introduces ever increasing rounding errors  but at these scales we don t care                 It also means we don t have to deal with problematic rounding errors due to dividing doubles              value   Math Round value   divisor  decimals                unitIndex                       if  value  lt  1  amp  amp  number    0                        value   lastValue              unitIndex--                     return   quot  sign  value    byteUnits unitIndex   quot            Output is  0 B 857 B 173 KB 9 32 MB 1 34 MB 5 02 GB 1 B 1 KB 1 MB 1 GB 1 TB 1 PB 1 EB

User · Answer

No   Mostly because it s of a rather niche need  and there are too many possible variations    Is it  KB    Kb  or  Ko    Is a megabyte 1024   1024 bytes  or 1024   1000 bytes  -- yes  some places use that

User · Answer

I went for JerKimballs solution  and thumbs up to that   However  I would like to add   point out that this is indeed a matter of controversy as a whole  In my research  for other reasons  I have come up with the following pieces of information   When normal people  I have heard they exist  speak of gigabytes they refer to the metric system wherein 1000 to the power of 3 from the original number of bytes    the number of gigabytes  However  of course there is the IEC   JEDEC standards which is nicely summed up in wikipedia  which instead of 1000 to the power of x they have 1024  Which for physical storage devices  and I guess logical such as amazon and others  means an ever increasing difference between metric vs IEC  So for instance 1 TB    1 terabyte metric is 1000 to the power of 4  but IEC officially terms the similar number as 1 TiB  tebibyte as 1024 to the power of 4  But  alas  in non-technical applications  I would go by audience  the norm is metric  and in my own app for internal use currently I explain the difference in documentation  But for display purposes I do not even offer anything but metric  Internally even though it s not relevant in my app I only store bytes and do the calculation for display   As a side note I find it somewhat lackluster that the  Net framework AFAIK  and I am frequently wrong thank the powers that be  even in it s 4 5 incarnation does not contain anything about this in any libraries internally  One would expect an open source library of some kind to be NuGettable at some point  but I admit this is a small peeve  On the other hand System IO DriveInfo and others also only have bytes  as long  which is rather clear

User · Answer

Servy s answer was nice and succinct   I think it can be even simpler   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  gt  unit                number    unit          i                 apply precision and current suffix     return Math Round number  precision    suffixes i

User · Answer

How about   public void printMB uint sizekB           double sizeMB    double  sizekB   1024      Console WriteLine  Size is     sizeMB ToString  0 00      MB        E g  call like  printMB 123456     Will result in output   Size is 120 56 MB

User · Answer

Since everyone else is posting their methods  I figured I d post the extension method I usually use for this   EDIT  added int long variants   and fixed a copypasta typo     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  gt  1   string Format   0 Tb  asTb                asGb  gt  1   string Format   0 Gb  asGb                asMb  gt  1   string Format   0 Mb  asMb                asKb  gt  1   string Format   0 Kb  asKb                string Format   0 B   Math Round  double value  decimalPlaces            return chosenValue

User · Answer

Checkout the ByteSize library  It s the System TimeSpan for bytes   It handles the conversion and formatting for you   var maxFileSize   ByteSize FromKiloBytes 10   maxFileSize Bytes  maxFileSize MegaBytes  maxFileSize GigaBytes    It also does string representation and parsing      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

User · Answer

Here is an option that s easier to extend than yours  but no  there is none built into the library itself   private static List lt string gt  suffixes   new List lt string gt      B     KB     MB     GB     TB     PB     public static string Foo int number        for  int i   0  i  lt  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

User · Answer

As posted above  the recursion is the favorite way  with the help of logarithm   The following function has 3 arguments   the input  the dimension constraint of the output  that is the third argument   int ByteReDim unsigned long ival  int constraint  unsigned long  oval        int base   1    int  log10 ival          oval    ival      if  base  gt  constraint              oval      oval   gt  gt  10          return 1   ByteReDim   oval   constraint  oval          else         return 0       Now let s convert 12GB of RAM in several units   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   amp RAM       printf   lu c n   RAM  symbol unit       output is 12884901888B      unit   ByteReDim 12884901888  9   amp RAM       printf   lu c n   RAM  symbol unit       output is 12582912K      unit   ByteReDim 12884901888  6   amp RAM       printf   lu c n   RAM  symbol unit       output is 12288M      unit   ByteReDim 12884901888  3   amp RAM       printf   lu c n   RAM  symbol unit       output is 12G

User · Answer

No   But you can implement like this       static double ConvertBytesToMegabytes long bytes            return  bytes   1024f    1024f             static double ConvertKilobytesToMegabytes long kilobytes            return kilobytes   1024f          Also check out How to correctly convert filesize in bytes into mega or gigabytes

User · Answer

I use this for Windows  binary prefixes    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   gt  0  amp  amp  counter  lt  BinaryPrefix Length       return text

User · Answer

The short version of the most voted answer has problems with TB values   I adjusted it appropriately to handle also tb values and still without a loop and also added a little error checking for negative values  Here s my solution   static readonly string   SizeSuffixes      bytes    KB    MB    GB    TB    PB    EB    ZB    YB     static string SizeSuffix long value  int decimalPlaces   0        if  value  lt  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

User · Answer

I have combined some of the answers here into two methods that work great  The second method below will convert from a bytes string  like 1 5 1 GB  back to bytes  like 1621350140  as a long type value  I hope this is useful to others looking for a solution to convert bytes to a string and back into bytes   public static string BytesAsString float bytes        string   suffix      B    KB    MB    GB    TB         int i      double doubleBytes   0       for  i   0   int  bytes   1024   gt  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       gt  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

User · Answer

Based on NeverHopeless s elegant solution   private static readonly KeyValuePair lt long  string gt    Thresholds             new KeyValuePair lt long  string gt  0    Bytes       Don t devide by Zero      new KeyValuePair lt long  string gt  1    Byte        new KeyValuePair lt long  string gt  2    Bytes        new KeyValuePair lt long  string gt  1024    KB        new KeyValuePair lt long  string gt  1048576    MB       Note  1024   2   1026  xor operator      new KeyValuePair lt long  string gt  1073741824    GB        new KeyValuePair lt long  string gt  1099511627776    TB        new KeyValuePair lt long  string gt  1125899906842620    PB        new KeyValuePair lt long  string gt  1152921504606850000    EB            These don t fit into a int64        new KeyValuePair lt long  string gt  1180591620717410000000    ZB            new KeyValuePair lt long  string gt  1208925819614630000000000    YB             lt summary gt      Returns x Bytes  kB  Mb  etc          lt  summary gt  public static string ToByteSize this long value        if  value    0  return  0 Bytes      zero is plural     for  int t   Thresholds Length - 1  t  gt  0  t--          if  value  gt   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      Maybe there are excessive comments  but I tend to leave them to prevent myself from making the same mistakes over on future visits

User · Answer

I have incorporated this  with little to no modification  into a UWP DataBinding Converter for my project and thought it might also be useful to others   The code is   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  lt  0    throw new ArgumentOutOfRangeException String Format  DecimalPlaces    0    this DecimalPlaces                  if  value  lt  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  lt  lt   magnitude   10     2    10   magnitude   i e  the number of bytes in the unit corresponding to magnitude              decimal adjustedSize    decimal value    1L  lt  lt   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   gt   1000                                magnitude    1                  adjustedSize    1024                             return String Format   0 n    this DecimalPlaces       1    adjustedSize  sSizeSuffixes magnitude                        To use it  add a local resource to your UserControl or Page XAML    lt UserControl Resources gt       lt converters ByteSizeConverter x Key  ByteFormat  DecimalPlaces  3    gt   lt  UserControl Resources gt    Reference it in a data binding template or data binding instance    lt TextBlock HorizontalAlignment  Left  VerticalAlignment  Center      Text   x Bind MyItem FileSize bytes  Mode OneWay  Converter  StaticResource ByteFormat      gt    And hey presto  The magic happens

User · Answer

private string GetFileSize double byteCount                string size    0 Bytes           if  byteCount  gt   1073741824 0              size   String Format   0          byteCount   1073741824 0      GB           else if  byteCount  gt   1048576 0              size   String Format   0          byteCount   1048576 0      MB           else if  byteCount  gt   1024 0              size   String Format   0          byteCount   1024 0      KB           else if  byteCount  gt  0  amp  amp  byteCount  lt  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                    This is one way to do it aswell  The number 1073741824 0 is from 1024 1024 1024 aka GB

User · Answer

I would solve it using Extension methods  Math Pow function and 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              and use it like   string h   x ToSize MyExtension SizeUnits KB

User · Answer

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  lt  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

User · Answer

How about some recursion   private static string ReturnSize double size  string sizeLabel      if  size  gt  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  gt  0        return string Concat size ToString  0 00    sizeLabel       else       return string Concat size ToString  0 00     Bytes            Then you can call it   ReturnSize size  string Empty

[c#] Does .NET provide an easy way convert bytes to KB, MB, GB, etc.?

Examples related to c#

Examples related to .net

Examples related to byte

Examples related to megabyte