blocks|key|175087|text|不是的。主要是因为它是一个相当小众的需求，而且有太多可能的变化。(是"KB"，"Kb“还是"Ko"？兆字节是1024+*+1024字节，还是1024+*+1000字节？--是的，有些地方使用它！)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|175088|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

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

blocks|key|175112|text|不是的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|175113|但是你可以像这样实现；|175114|++++static+double+ConvertBytesToMegabytes(long+bytes)
++++{
++++return+(bytes+/+1024f)+/+1024f;
++++}

++++static+double+ConvertKilobytesToMegabytes(long+kilobytes)
++++{
++++return+kilobytes+/+1024f;
++++}|code-block|syntax|javascript|175115|另请查看How+to+correctly+convert+filesize+in+bytes+into+mega+or+gigabytes?|offset|length|175116|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/565704/how-to-correctly-convert-filesize-in-bytes-into-mega-or-gigabytes^0|0|0|0|4|1U|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@$K|Y|L|Z|1|10]]|A|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

No.

But you can implement like this;

<pre><code> static double ConvertBytesToMegabytes(long bytes)
 {
 return (bytes / 1024f) / 1024f;
 }

 static double ConvertKilobytesToMegabytes(long kilobytes)
 {
 return kilobytes / 1024f;
 }
</code></pre>

Also check out <a href="https://stackoverflow.com/questions/565704/how-to-correctly-convert-filesize-in-bytes-into-mega-or-gigabytes">How to correctly convert filesize in bytes into mega or gigabytes?</a>

blocks|key|393153|text|这里有一个选项，它比你的更容易扩展，但不，库本身没有内置任何选项。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|393154|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%2B%2B)
++++{
++++++++int+temp+=+number+/+(int)Math.Pow(1024,+i+%2B+1);
++++++++if+(temp+==+0)
++++++++++++return+(number+/+(int)Math.Pow(1024,+i))+%2B+suffixes[i];
++++}
++++return+number.ToString();
}|code-block|syntax|javascript|393155|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here is an option that's easier to extend than yours, but no, there is none built into the library itself.

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

blocks|key|393192|text|下面是一个相当简明的方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|393193|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+"-"+%2B+SizeSuffix(-value,+decimalPlaces);+}+
++++if+(value+==+0)+{+return+string.Format("{0:n"+%2B+decimalPlaces+%2B+"}+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+%5E+(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+%2B=+1;
++++++++adjustedSize+/=+1024;
++++}

++++return+string.Format("{0:n"+%2B+decimalPlaces+%2B+"}+{1}",+
++++++++adjustedSize,+
++++++++SizeSuffixes[mag]);
}|code-block|syntax|javascript|393194|下面是我建议的原始实现，它可能会稍微慢一些，但更容易理解：|393195|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+"-"+%2B+SizeSuffix(-value,+decimalPlaces);+}+

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

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

Console.WriteLine(SizeSuffix(100005000L));|393196|请记住一件事-在SI表示法中，“千”通常使用小写的k，而所有较大的单位都使用大写字母。Windows使用KB、MB、GB，因此我在上面使用了KB，但您可以考虑使用kB。|393197|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Here is a fairly concise way to do this:
<pre><code>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]);
}
</code></pre>
And here's the original implementation I suggested, which may be marginally slower, but a bit easier to follow:
<pre><code>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));
</code></pre>
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.

blocks|key|175256|text|因为每个人都在发布他们的方法，所以我想我应该发布我通常用于此的扩展方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|175257|编辑:增加了整型/长型variants...and修复了copypasta打字错误...|175258|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;
++++}
}|code-block|syntax|javascript|175259|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

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

<pre><code>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;
 }
}
</code></pre>

blocks|key|393317|text|我已经将这里的一些答案组合成了两个非常有效的方法。下面的第二种方法将字节字符串(如1.5.1+GB)转换回字节(如1621350140)作为长类型的值。我希望这对其他正在寻找将字节转换成字符串再转换回字节的解决方案的人有用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|393318|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%2B%2B,+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("+")+%2B+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);
}|code-block|syntax|javascript|393319|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

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.

<pre><code>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);
}
</code></pre>

blocks|key|175370|text|投票最多的答案的简短版本存在关于TB值的问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|175371|我适当地调整了它，以处理tb值，并且仍然没有循环，还为负值添加了一些错误检查。这是我的解决方案：|175372|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]);
}|code-block|syntax|javascript|175373|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

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:

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

blocks|key|175408|text|签出ByteSize库。它是字节的System.TimeSpan！|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|175409|它为您处理转换和格式化。|175410|var+maxFileSize+=+ByteSize.FromKiloBytes(10);
maxFileSize.Bytes;
maxFileSize.MegaBytes;
maxFileSize.GigaBytes;|code-block|syntax|javascript|175411|它还可以进行字符串表示和解析。|175412|//+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");|175413|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/omar/ByteSize^0|H|F|2|8|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@$9|11|A|12|1|13]]|E|$]]|$1|F|3|G|5|6|7|14|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|15|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|16|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|17|8|@]|D|@]|E|$K|L]]|$1|Q|3|-4|5|6|7|18|8|@]|D|@]|E|$]]]|R|$S|$5|T|U|V|E|$W|X]]]]

Checkout the <a href="https://github.com/omar/ByteSize">ByteSize</a> library. It's the <code>System.TimeSpan</code> for bytes!

It handles the conversion and formatting for you.

<pre><code>var maxFileSize = ByteSize.FromKiloBytes(10);
maxFileSize.Bytes;
maxFileSize.MegaBytes;
maxFileSize.GigaBytes;
</code></pre>

It also does string representation and parsing.

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

blocks|key|175445|text|这样如何：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|175446|public+void+printMB(uint+sizekB)+++
{
++++double+sizeMB+=+(double)+sizekB+/+1024;
++++Console.WriteLine("Size+is+"+%2B+sizeMB.ToString("0.00")+%2B+"MB");
}|code-block|syntax|javascript|175447|例如，call+like|175448|printMB(123456);|175449|将导致输出|175450|"Size+is+120,56+MB"|175451|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

How about:

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

E.g. call like

<pre><code>printMB(123456);
</code></pre>

Will result in output

<pre><code>"Size is 120,56 MB"
</code></pre>

blocks|key|393456|text|我会使用Extension+methods、Math.Pow函数和Enums来解决这个问题|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|393457|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");
++++}
}|code-block|syntax|javascript|393458|并像这样使用它：|393459|string+h+=+x.ToSize(MyExtension.SizeUnits.KB);|393460|entityMap^0|4|H|M|8|X|5|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|10|8|@]|D|@]|E|$]]]|P|$]]

I would solve it using <code>Extension methods</code>, <code>Math.Pow</code> function and <code>Enums</code>:

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

and use it like:

<pre><code>string h = x.ToSize(MyExtension.SizeUnits.KB);
</code></pre>

blocks|key|393514|text|++++private+string+GetFileSize(double+byteCount)
++++{
++++++++string+size+=+"0+Bytes";
++++++++if+(byteCount+>=+1073741824.0)
++++++++++++size+=+String.Format("{0:##.##}",+byteCount+/+1073741824.0)+%2B+"+GB";
++++++++else+if+(byteCount+>=+1048576.0)
++++++++++++size+=+String.Format("{0:##.##}",+byteCount+/+1048576.0)+%2B+"+MB";
++++++++else+if+(byteCount+>=+1024.0)
++++++++++++size+=+String.Format("{0:##.##}",+byteCount+/+1024.0)+%2B+"+KB";
++++++++else+if+(byteCount+>+0+&&+byteCount+<+1024.0)
++++++++++++size+=+byteCount.ToString()+%2B+"+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+%2B=+"File:+"+%2B+Path.GetFileName(openFile1.FileName);
++++++++++++info+%2B=+Environment.NewLine;
++++++++++++info+%2B=+"File+Size:+"+%2B+GetFileSize((int)thisFile.Length);

++++++++++++label1.Text+=+info;
++++++++}
++++}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|393515|这也是一种方法(数字1073741824.0来自1024x1024x1024aka+GB)|unstyled|393516|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code> 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;
 }
 }
</code></pre>

This is one way to do it aswell (The number 1073741824.0 is from 1024*1024*1024 aka GB)

blocks|key|175587|text|我选择了JerKimballs解决方案，并竖起了大拇指。然而，我想补充/指出，这确实是一个整体上有争议的问题。在我的研究中(出于其他原因)，我得出了以下信息。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|175588|当普通人(我听说他们存在)谈到千兆字节时，他们指的是公制，其中1000的3次方从原始的字节数==等于千兆字节的数量。然而，当然还有IEC+/+JEDEC标准，维基百科很好地总结了这一标准，而不是1000的x次方，他们有1024。对于物理存储设备(我猜是符合逻辑的，如amazon和其他)，这意味着指标与IEC之间的差异越来越大。因此，举个例子，1TB+==+1TB度量是1000的4次方，但是IEC官方将这个数字定义为1+TiB，TB为1024的4次方。但是，可惜的是，在非技术应用程序中(我会使用受众)，规范是度量，在我自己的内部使用的应用程序中，目前我在文档中解释了其中的区别。但出于显示目的，我甚至不提供任何指标。在内部，即使它与我的应用程序无关，我也只存储字节并进行计算以供显示。|175589|顺便说一句，我发现.Net框架AFAIK+(感谢那些强大的力量，我经常是错的)，即使在它的4.5版本中，在内部的任何库中都没有包含任何关于这方面的东西，这有点乏味。人们可能会期望某个开源库在某种程度上是NuGettable的，但我承认这是一个小小的烦恼。另一方面，System.IO.DriveInfo和其他程序也只有字节(和长一样长)，这是相当清楚的。|175590|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

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.

blocks|key|175644|text|https://github.com/logary/logary/blob/master/src/Logary/DataModel.fs#L832-L837|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|175645|let+scaleBytes+(value+:+float)+:+float+*+string+=
++++let+log2+x+=+log+x+/+log+2.
++++let+prefixes+=+[%7C+"";+"Ki";+"Mi";+"Gi";+"Ti";+"Pi"+%7C]+//+note+the+capital+K+and+the+'i'
++++let+index+=+int+(log2+value)+/+10
++++1.+/+2.**(float+index+*+10.),
sprintf+"%25s%25s"+prefixes.[index]+(Units.symbol+Bytes)|code-block|syntax|javascript|175646|(免责声明:这段代码是我写的，甚至是链接中的代码！)|175647|entityMap|0|LINK|mutability|MUTABLE|url^0|0|26|0|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@$A|S|B|T|1|U]]|C|$]]|$1|D|3|E|5|F|7|V|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|W|8|@]|9|@]|C|$]]|$1|K|3|-4|5|6|7|X|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|4]]]]

<a href="https://github.com/logary/logary/blob/master/src/Logary/DataModel.fs#L832-L837" rel="nofollow noreferrer">https://github.com/logary/logary/blob/master/src/Logary/DataModel.fs#L832-L837</a>
<pre><code>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)
</code></pre>
(DISCLAIMER: I wrote this code, even the code in the link!)

blocks|key|393623|text|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,+%2B%2BR);
++++}
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|393624|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre class="lang-cs prettyprint-override"><code>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);
 }
}
</code></pre>

blocks|key|393662|text|有没有一些递归：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|393663|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");
++}
}|code-block|syntax|javascript|393664|然后你就可以调用它了：|393665|ReturnSize(size,+string.Empty);|393666|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

How about some recursion:

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

Then you can call it:

<pre><code>ReturnSize(size, string.Empty);
</code></pre>

blocks|key|393725|text|如前所述，在对数的帮助下，递归是最受欢迎的方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|393726|下面的函数有3个参数:输入，输出的维度约束，即第三个参数。|393727|int+ByteReDim(unsigned+long+ival,+int+constraint,+unsigned+long+*oval)
{
++++int+base+=+1+%2B+(int)+log10(ival);

++++(*oval)+=+ival;
++++if+(base+>+constraint)+{
++++++++(*oval)+=+(*oval)+>>+10;
++++++++return(1+%2B+ByteReDim((*oval),+constraint,+oval));
++++}+else
++++++++return(0);
}|code-block|syntax|javascript|393728|现在让我们以几个单位转换12+in的RAM：|393729|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("%25lu%25c\n",+RAM,+symbol[unit]);+//+output+is+12884901888B

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

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

++++unit+=+ByteReDim(12884901888,+3,+&RAM);
++++printf("%25lu%25c\n",+RAM,+symbol[unit]);+//+output+is+12G
}|393730|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

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.

<pre><code>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);
}
</code></pre>

Now let's convert 12GB of RAM in several units:

<pre><code>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
}
</code></pre>

blocks|key|393774|text|@Servy's+answer很好，也很简洁。我认为它可以更简单？|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|393775|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%2B%2B;
++++}
++++//+apply+precision+and+current+suffix
++++return+Math.Round(number,+precision)+%2B+suffixes[i];
}|code-block|syntax|javascript|393776|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/14488873/1037948^0|0|F|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

<a href="https://stackoverflow.com/a/14488873/1037948">@Servy's answer</a> was nice and succinct. I think it can be even simpler?

<pre><code>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];
}
</code></pre>

blocks|key|175833|text|基于NeverHopeless的优雅解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|175834|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+%5E+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")+%2B+Thresholds[t].Value;
++++return+"-"+%2B+ToByteSize(-value);+//+negative+bytes+(common+case+optimised+to+the+end+of+this+routine)
}|code-block|syntax|javascript|175835|也许有过多的评论，但我倾向于留下它们，以防止我自己在以后的访问中犯同样的错误。|175836|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Based on NeverHopeless's elegant solution:

<pre><code>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)
}
</code></pre>

Maybe there are excessive comments, but I tend to leave them to prevent myself from making the same mistakes over on future visits...

blocks|key|175850|text|我在Windows上使用这个(二进制前缀)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|175851|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")+%2B+"+"+%2B+BinaryPrefix[counter];
++++++++value+/=+1024;
++++++++counter%2B%2B;
++++}
++++while+(Math.Floor(value)+>+0+&&+counter+<+BinaryPrefix.Length);
++++return+text;
}|code-block|syntax|javascript|175852|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I use this for Windows (binary prefixes):

<pre><code>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;
}
</code></pre>

blocks|key|175890|text|我已经合并了这个(很少或没有修改)到我的项目的UWP转换器，并认为它也可能对其他人有用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|175891|代码是：|175892|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+"-"+%2B+SizeSuffix(-value);+}
++++++++++++if+(value+==+0)+{+return+string.Format("{0:n"+%2B+this.DecimalPlaces+%2B+"}+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+%5E+(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+%2B=+1;
++++++++++++++++adjustedSize+/=+1024;
++++++++++++}

++++++++++++return+String.Format("{0:n"+%2B+this.DecimalPlaces+%2B+"}+{1}",+adjustedSize,+sSizeSuffixes[magnitude]);
++++++++}
++++}
}|code-block|syntax|javascript|175893|要使用它，请将本地资源添加到UserControl或Page+XAML：|175894|<UserControl.Resources>
++++<converters:ByteSizeConverter+x:Key="ByteFormat"+DecimalPlaces="3"+/>
</UserControl.Resources>|175895|在数据绑定模板或数据绑定实例中引用它：|175896|<TextBlock+HorizontalAlignment="Left"+VerticalAlignment="Center"
++++Text="{x:Bind+MyItem.FileSize_bytes,+Mode=OneWay,+Converter={StaticResource+ByteFormat}}"+/>|175897|嘿，马上就来。奇迹就会发生。|175898|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|10|8|@]|9|@]|A|$G|H]]|$1|Q|3|R|5|6|7|11|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

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:

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

To use it, add a local resource to your UserControl or Page XAML:

<pre><code>&lt;UserControl.Resources&gt;
 &lt;converters:ByteSizeConverter x:Key="ByteFormat" DecimalPlaces="3" /&gt;
&lt;/UserControl.Resources&gt;
</code></pre>

Reference it in a data binding template or data binding instance:

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

And hey presto. The magic happens.

blocks|key|175934|text|我知道这已经是个老帖子了。但也许有人会去寻找解决方案。下面是我使用的，也是最简单的方法|type|unstyled|depth|inlineStyleRanges|entityRanges|data|175935|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";
}|code-block|syntax|javascript|175936|获取文件夹大小(例如用法)|175937|public+static+long+GetFolderSize(string+path,+string+ext,+bool+AllDir)
{
++++var+option+=+AllDir+?+SearchOption.AllDirectories+:+SearchOption.TopDirectoryOnly;
++++return+new+DirectoryInfo(path).EnumerateFiles("*"+%2B+ext,+option).Sum(file+=>+file.Length);
}|175938|示例用法：|175939|public+static+void+TEST()
{
++++string+folder+=+@"C:\Users\User\Videos";

++++var+bytes+=+GetFolderSize(folder,+"mp4",+true);+//or+GetFolderSize(folder,+"mp4",+false)+to+get+all+single+folder+only
++++var+totalFileSize+=+FormatFileSize(bytes);
++++Console.WriteLine(totalFileSize);
}|175940|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

I know this is old thread already. but maybe someone will look for solution.
And here's what I use and the easiest way
<pre><code>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;;
}
</code></pre>
Get folder size (for example usage)
<pre><code>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);
}
</code></pre>
EXAMPLE USAGE:
<pre><code>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);
}
</code></pre>

blocks|key|394099|text|这是我对@drzaus的回答的看法。我对它进行了修改，以利用舍入误差对我们有利，并正确地管理单元边界周围的问题。它还可以处理负值。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|394100|将此C#+Program放入LinqPad：|offset|length|style|CODE|394101|//+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[]+{+"B",+"KB",+"MB",+"GB",+"TB",+"PB",+"EB"+};

++++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+<+0+?+"-"+:+string.Empty;
++++++++var+value+=+Math.Abs(number);
++++++++double+lastValue+=+number;

++++++++while+(value+>+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%2B%2B;
++++++++}

++++++++if+(value+<+1+&&+number+!=+0)
++++++++{
++++++++++++value+=+lastValue;
++++++++++++unitIndex--;
++++++++}

++++++++return+$"{sign}{value}+{_byteUnits[unitIndex]}";
++++}
}|code-block|syntax|javascript|394102|输出为：|394103|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|394104|entityMap^0|0|2|A|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@$D|U|E|V|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|W|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|Y|8|@]|9|@]|A|$K|L]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

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 <code>C# Program</code> into LinqPad:
<pre class="lang-cs prettyprint-override"><code>// 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;;
 }
}
</code></pre>
Output is:
<pre><code>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
</code></pre>

blocks|key|394128|text|我最近需要它，并且需要将in字节转换为long中的数字。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|394129|用法：Byte.Kb.ToLong(1)应该给1024。|offset|length|style|CODE|394130|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+=>+value+*+OneKb,
++++++++++++Byte.Mb+=>+value+*+OneMb,
++++++++++++Byte.Gb+=>+value+*+OneGb,
++++++++++++Byte.Tb+=>+value+*+OneTb,
++++++++++++_+=>+throw+new+NotImplementedException("This+should+never+be+hit.")
++++++++};
++++}
}|code-block|syntax|javascript|394131|394132|使用xunit进行测试：|394133|[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);
}|394134|entityMap^0|0|3|H|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|U|8|@$D|V|E|W|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|X|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|Z|8|@]|9|@]|A|$]]|$1|P|3|Q|5|J|7|10|8|@]|9|@]|A|$K|L]]|$1|R|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|S|$]]

I recently needed this and required to convert the in bytes to a number in long.
Usage: <code>Byte.Kb.ToLong(1)</code> should give 1024.
<pre class="lang-cs prettyprint-override"><code>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;)
 };
 }
}
</code></pre>
<hr />
Tests using xunit:
<pre class="lang-cs prettyprint-override"><code>[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);
}
</code></pre>

blocks|key|394136|text|string+Convert(float+bytes)
{
++++string[]+Group+=+{+"Bytes",+"KB",+"MB",+"GB",+"TB"};
++++float+B+=+bytes;+int+G+=+0;
++++while+(B+>=+1024+&&+G+<+5)
++++{
++++++++B+/=+1024;
++++++++G+%2B=+1;
++++}
++++float+truncated+=+(float)(Math.Truncate((double)B+*+100.0)+/+100.0);
++++string+load+=+(truncated+%2B+"+"+%2B+Group[G]);

++++return+load;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|394137|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre class="lang-cs prettyprint-override"><code>string Convert(float bytes)
{
 string[] Group = { &quot;Bytes&quot;, &quot;KB&quot;, &quot;MB&quot;, &quot;GB&quot;, &quot;TB&quot;};
 float B = bytes; int G = 0;
 while (B &gt;= 1024 &amp;&amp; G &lt; 5)
 {
 B /= 1024;
 G += 1;
 }
 float truncated = (float)(Math.Truncate((double)B * 100.0) / 100.0);
 string load = (truncated + &quot; &quot; + Group[G]);

 return load;
}
</code></pre>

blocks|key|394160|text|针对C#+9.0+Relational+Patterns进行了更新|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|394161|public+const+long+OneKB+=+1024;

public+const+long+OneMB+=+OneKB+*+OneKB;

public+const+long+OneGB+=+OneMB+*+OneKB;

public+const+long+OneTB+=+OneGB+*+OneKB;

public+static+string+BytesToHumanReadable(ulong+bytes)
{
++++return+bytes+switch
++++{
++++++++(<+OneKB)+=>+$"{bytes}B",
++++++++(>=+OneKB)+and+(<+OneMB)+=>+$"{bytes+/+OneKB}KB",
++++++++(>=+OneMB)+and+(<+OneGB)+=>+$"{bytes+/+OneMB}MB",
++++++++(>=+OneGB)+and+(<+OneTB)+=>+$"{bytes+/+OneMB}GB",
++++++++(>=+OneTB)+=>+$"{bytes+/+OneTB}"
++++++++//...
++++};
}|code-block|syntax|javascript|394162|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/operators/patterns#relational-patterns^0|9|J|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

Updated for C# 9.0 <a href="https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/operators/patterns#relational-patterns" rel="nofollow noreferrer">Relational Patterns</a>
<pre><code>public const long OneKB = 1024;

public const long OneMB = OneKB * OneKB;

public const long OneGB = OneMB * OneKB;

public const long OneTB = OneGB * OneKB;

public static string BytesToHumanReadable(ulong bytes)
{
 return bytes switch
 {
 (&lt; OneKB) =&gt; $&quot;{bytes}B&quot;,
 (&gt;= OneKB) and (&lt; OneMB) =&gt; $&quot;{bytes / OneKB}KB&quot;,
 (&gt;= OneMB) and (&lt; OneGB) =&gt; $&quot;{bytes / OneMB}MB&quot;,
 (&gt;= OneGB) and (&lt; OneTB) =&gt; $&quot;{bytes / OneMB}GB&quot;,
 (&gt;= OneTB) =&gt; $&quot;{bytes / OneTB}&quot;
 //...
 };
}
</code></pre>

blocks|key|176064|text|我就是这么做的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|176065|Console.Write(FileSizeInBytes+>+1048576+?+FileSizeInBytes+/+1048576f+%2B+"+MB"+:+FileSizeInBytes+/+1024f+%2B+"+KB");+//1048576+=+1024+*+1024|code-block|syntax|javascript|176066|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This is how I do it.
<pre><code>Console.Write(FileSizeInBytes &gt; 1048576 ? FileSizeInBytes / 1048576f + &quot; MB&quot; : FileSizeInBytes / 1024f + &quot; KB&quot;); //1048576 = 1024 * 1024
</code></pre>

Just wondering if .NET provides a clean way to do this:

<pre><code>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);
}
</code></pre>

etc...

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

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋 

腾讯云代码助手

CODING DevOps

Cloud Studio

SDK中心

API中心

命令行工具

我只是想知道.NET是否提供了一种干净的方法来做到这一点：int64 x = 1000000;string y = null;if (x / 1024 == 0) {    y = x + " bytes";}else if (x / (1024 * 1024) == 0) {    y = string.Format...

问.NET是否提供了将字节转换为KB、MB、GB等的简单方法？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问.NET是否提供了将字节转换为KB、MB、GB等的简单方法？EN