Comment puis-je obtenir une taille de fichier lisible par un humain en abréviations d'octets en utilisant .NET?

Question

Comment puis-je obtenir une taille de fichier lisible par l'homme en abréviations d'octets en utilisant .NET?

Exemple: Prenez entrée 7.326.629 et afficher 6,98 MB

Answer 1

Ce n'est pas la façon la plus efficace de le faire, mais il est plus facile à lire si vous n'êtes pas familier avec les mathématiques journaux et devrait être assez rapide pour la plupart des scénarios.

string[] sizes = { "B", "KB", "MB", "GB", "TB" }; 
double len = new FileInfo(filename).Length; 
int order = 0; 
while (len >= 1024 && order < sizes.Length - 1) { 
    order++; 
    len = len/1024; 
} 

// Adjust the format string to your preferences. For example "{0:0.#}{1}" would 
// show a single decimal place, and no space. 
string result = String.Format("{0:0.##} {1}", len, sizes[order]); 

Answer 2

int size = new FileInfo(filePath).Length/1024; 
string humanKBSize = string.Format("{0} KB", size); 
string humanMBSize = string.Format("{0} MB", size/1024); 
string humanGBSize = string.Format("{0} GB", size/1024/1024); 

Answer 3

Je suppose que vous êtes à la recherche de "1,4 MB" au lieu de "1468006 octets"?

Je ne pense pas qu'il existe une manière intégrée de faire cela dans .NET. Vous devrez juste déterminer quelle unité est appropriée et la formater.

Edit: Voici quelques exemples de code pour le faire que:

http://www.codeproject.com/KB/cpp/formatsize.aspx

Answer 4

string[] suffixes = { "B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB" }; 
int s = 0; 
long size = fileInfo.Length; 

while (size >= 1024) 
{ 
    s++; 
    size /= 1024; 
} 

string humanReadable = String.Format("{0} {1}", size, suffixes[s]); 

Answer 5

[DllImport ("Shlwapi.dll", CharSet = CharSet.Auto)] 
public static extern long StrFormatByteSize ( 
     long fileSize 
     , [MarshalAs (UnmanagedType.LPTStr)] StringBuilder buffer 
     , int bufferSize); 


/// <summary> 
/// Converts a numeric value into a string that represents the number expressed as a size value in bytes, kilobytes, megabytes, or gigabytes, depending on the size. 
/// </summary> 
/// <param name="filelength">The numeric value to be converted.</param> 
/// <returns>the converted string</returns> 
public static string StrFormatByteSize (long filesize) { 
    StringBuilder sb = new StringBuilder(11); 
    StrFormatByteSize(filesize, sb, sb.Capacity); 
    return sb.ToString(); 
} 

De: http://www.pinvoke.net/default.aspx/shlwapi/StrFormatByteSize.html

Answer 6

Une autre façon de la peau, sans aucune sorte de boucles et avec le soutien de taille négative (logique pour des choses comme les deltas de taille de fichier):

public static class Format 
{ 
    static string[] sizeSuffixes = { 
     "B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB" }; 

    public static string ByteSize(long size) 
    { 
     Debug.Assert(sizeSuffixes.Length > 0); 

     const string formatTemplate = "{0}{1:0.#} {2}"; 

     if (size == 0) 
     { 
      return string.Format(formatTemplate, null, 0, sizeSuffixes[0]); 
     } 

     var absSize = Math.Abs((double)size); 
     var fpPower = Math.Log(absSize, 1000); 
     var intPower = (int)fpPower; 
     var iUnit = intPower >= sizeSuffixes.Length 
      ? sizeSuffixes.Length - 1 
      : intPower; 
     var normSize = absSize/Math.Pow(1000, iUnit); 

     return string.Format(
      formatTemplate, 
      size < 0 ? "-" : null, normSize, sizeSuffixes[iUnit]); 
    } 
} 

Et voici la suite de tests:

[TestFixture] public class ByteSize 
{ 
    [TestCase(0, Result="0 B")] 
    [TestCase(1, Result = "1 B")] 
    [TestCase(1000, Result = "1 KB")] 
    [TestCase(1500000, Result = "1.5 MB")] 
    [TestCase(-1000, Result = "-1 KB")] 
    [TestCase(int.MaxValue, Result = "2.1 GB")] 
    [TestCase(int.MinValue, Result = "-2.1 GB")] 
    [TestCase(long.MaxValue, Result = "9.2 EB")] 
    [TestCase(long.MinValue, Result = "-9.2 EB")] 
    public string Format_byte_size(long size) 
    { 
     return Format.ByteSize(size); 
    } 
} 

Answer 7

en utilisant le journal pour résoudre le problème ....

static String BytesToString(long byteCount) 
{ 
    string[] suf = { "B", "KB", "MB", "GB", "TB", "PB", "EB" }; //Longs run out around EB 
    if (byteCount == 0) 
     return "0" + suf[0]; 
    long bytes = Math.Abs(byteCount); 
    int place = Convert.ToInt32(Math.Floor(Math.Log(bytes, 1024))); 
    double num = Math.Round(bytes/Math.Pow(1024, place), 1); 
    return (Math.Sign(byteCount) * num).ToString() + suf[place]; 
} 

également en C#, mais devrait être un clin d'oeil à convertir. Aussi j'ai arrondi à 1 décimale pour la lisibilité.

Fondamentalement, déterminez le nombre de décimales dans la base 1024, puis divisez par 1024^décimales.

Et quelques exemples d'utilisation et de la production:

Console.WriteLine(BytesToString(9223372036854775807)); //Results in 8EB 
Console.WriteLine(BytesToString(0));     //Results in 0B 
Console.WriteLine(BytesToString(1024));     //Results in 1KB 
Console.WriteLine(BytesToString(2000000));    //Results in 1.9MB 
Console.WriteLine(BytesToString(-9023372036854775807)); //Results in -7.8EB 

Edit: a fait remarquer que j'ai manqué un Math.floor, donc je l'intégra. (Convert.ToInt32 utilise l'arrondi, pas tronqué et c'est pourquoi Floor est nécessaire.) Merci pour la capture.

Edit2: Il y avait quelques commentaires sur les tailles négatives et les tailles de 0 octets, donc j'ai mis à jour pour gérer ces 2 cas.

Answer 8

Mélange de toutes les solutions :-)

/// <summary> 
    /// Converts a numeric value into a string that represents the number expressed as a size value in bytes, 
    /// kilobytes, megabytes, or gigabytes, depending on the size. 
    /// </summary> 
    /// <param name="fileSize">The numeric value to be converted.</param> 
    /// <returns>The converted string.</returns> 
    public static string FormatByteSize(double fileSize) 
    { 
     FileSizeUnit unit = FileSizeUnit.B; 
     while (fileSize >= 1024 && unit < FileSizeUnit.YB) 
     { 
      fileSize = fileSize/1024; 
      unit++; 
     } 
     return string.Format("{0:0.##} {1}", fileSize, unit); 
    } 

    /// <summary> 
    /// Converts a numeric value into a string that represents the number expressed as a size value in bytes, 
    /// kilobytes, megabytes, or gigabytes, depending on the size. 
    /// </summary> 
    /// <param name="fileInfo"></param> 
    /// <returns>The converted string.</returns> 
    public static string FormatByteSize(FileInfo fileInfo) 
    { 
     return FormatByteSize(fileInfo.Length); 
    } 
} 

public enum FileSizeUnit : byte 
{ 
    B, 
    KB, 
    MB, 
    GB, 
    TB, 
    PB, 
    EB, 
    ZB, 
    YB 
} 

Answer 9

A testé et la version optimisée de manière significative de la fonction demandée est affichée ici:

C# Human Readable File Size - Optimized Function

code source:

// Returns the human-readable file size for an arbitrary, 64-bit file size 
// The default format is "0.### XB", e.g. "4.2 KB" or "1.434 GB" 
public string GetBytesReadable(long i) 
{ 
    // Get absolute value 
    long absolute_i = (i < 0 ? -i : i); 
    // Determine the suffix and readable value 
    string suffix; 
    double readable; 
    if (absolute_i >= 0x1000000000000000) // Exabyte 
    { 
     suffix = "EB"; 
     readable = (i >> 50); 
    } 
    else if (absolute_i >= 0x4000000000000) // Petabyte 
    { 
     suffix = "PB"; 
     readable = (i >> 40); 
    } 
    else if (absolute_i >= 0x10000000000) // Terabyte 
    { 
     suffix = "TB"; 
     readable = (i >> 30); 
    } 
    else if (absolute_i >= 0x40000000) // Gigabyte 
    { 
     suffix = "GB"; 
     readable = (i >> 20); 
    } 
    else if (absolute_i >= 0x100000) // Megabyte 
    { 
     suffix = "MB"; 
     readable = (i >> 10); 
    } 
    else if (absolute_i >= 0x400) // Kilobyte 
    { 
     suffix = "KB"; 
     readable = i; 
    } 
    else 
    { 
     return i.ToString("0 B"); // Byte 
    } 
    // Divide by 1024 to get fractional value 
    readable = (readable/1024); 
    // Return formatted number with suffix 
    return readable.ToString("0.### ") + suffix; 
} 

Answer 10

Mes 2 cents:

• Le préfixe kilo-octet est kB (minuscule K)
• Étant donné que ces fonctions sont à des fins de présentation, il faut fournir une culture, par exemple: string.Format(CultureInfo.CurrentCulture, "{0:0.##} {1}", fileSize, unit);
• Selon l'un contexte kilobyte peut être soit 1000 or 1024 bytes. La même chose vaut pour MB, GB, etc.

Answer 11

Une approche de plus, pour ce que ça vaut. J'ai aimé @humbads solution optimisée référencé ci-dessus, donc j'ai copié le principe, mais je l'ai mis en œuvre un peu différemment. Je suppose qu'il est discutable de savoir si ce devrait être une méthode d'extension (puisque tous les longs ne sont pas nécessairement des tailles d'octets), mais je les aime, et c'est quelque part que je peux trouver la méthode quand j'en ai besoin! En ce qui concerne les unités, je ne pense pas avoir jamais dit «Kibibyte» ou «Mebibyte» dans ma vie, et même si je suis sceptique à l'égard de ces normes appliquées plutôt qu'évolues, je suppose que cela évitera la confusion. à long terme.

public static class LongExtensions 
{ 
    private static readonly long[] numberOfBytesInUnit; 
    private static readonly Func<long, string>[] bytesToUnitConverters; 

    static LongExtensions() 
    { 
     numberOfBytesInUnit = new long[6]  
     { 
      1L << 10, // Bytes in a Kibibyte 
      1L << 20, // Bytes in a Mebibyte 
      1L << 30, // Bytes in a Gibibyte 
      1L << 40, // Bytes in a Tebibyte 
      1L << 50, // Bytes in a Pebibyte 
      1L << 60  // Bytes in a Exbibyte 
     }; 

     // Shift the long (integer) down to 1024 times its number of units, convert to a double (real number), 
     // then divide to get the final number of units (units will be in the range 1 to 1023.999) 
     Func<long, int, string> FormatAsProportionOfUnit = (bytes, shift) => (((double)(bytes >> shift))/1024).ToString("0.###"); 

     bytesToUnitConverters = new Func<long,string>[7] 
     { 
      bytes => bytes.ToString() + " B", 
      bytes => FormatAsProportionOfUnit(bytes, 0) + " KiB", 
      bytes => FormatAsProportionOfUnit(bytes, 10) + " MiB", 
      bytes => FormatAsProportionOfUnit(bytes, 20) + " GiB", 
      bytes => FormatAsProportionOfUnit(bytes, 30) + " TiB", 
      bytes => FormatAsProportionOfUnit(bytes, 40) + " PiB", 
      bytes => FormatAsProportionOfUnit(bytes, 50) + " EiB", 
     }; 
    } 

    public static string ToReadableByteSizeString(this long bytes) 
    { 
     if (bytes < 0) 
      return "-" + Math.Abs(bytes).ToReadableByteSizeString(); 

     int counter = 0; 
     while (counter < numberOfBytesInUnit.Length) 
     { 
      if (bytes < numberOfBytesInUnit[counter]) 
       return bytesToUnitConverters[counter](bytes); 
      counter++; 
     } 
     return bytesToUnitConverters[counter](bytes); 
    } 
} 

Answer 12

Extrayez la bibliothèque ByteSize. C'est le System.TimeSpan pour les octets!

Il gère la conversion et le formatage pour vous.

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

Il effectue également une représentation de chaîne et une analyse syntaxique.

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

Answer 13

Il existe un projet open source qui peut faire cela et bien plus encore.

7.Bits().ToString();   // 7 b 
8.Bits().ToString();   // 1 B 
(.5).Kilobytes().Humanize(); // 512 B 
(1000).Kilobytes().ToString(); // 1000 KB 
(1024).Kilobytes().Humanize(); // 1 MB 
(.5).Gigabytes().Humanize(); // 512 MB 
(1024).Gigabytes().ToString(); // 1 TB 

http://humanizr.net/#bytesize

https://github.com/MehdiK/Humanizer

Answer 14

J'aime utiliser la méthode suivante (il prend en charge jusqu'à téraoctets, ce qui est suffisant pour la plupart des cas, mais il peut facilement être étendu):

private string GetSizeString(long length) 
{ 
    long B = 0, KB = 1024, MB = KB * 1024, GB = MB * 1024, TB = GB * 1024; 
    double size = length; 
    string suffix = nameof(B); 

    if (length >= TB) { 
     size = Math.Round((double)length/TB, 2); 
     suffix = nameof(TB); 
    } 
    else if (length >= GB) { 
     size = Math.Round((double)length/GB, 2); 
     suffix = nameof(GB); 
    } 
    else if (length >= MB) { 
     size = Math.Round((double)length/MB, 2); 
     suffix = nameof(MB); 
    } 
    else if (length >= KB) { 
     size = Math.Round((double)length/KB, 2); 
     suffix = nameof(KB); 
    } 

    return $"{size} {suffix}"; 
} 

Veuillez garder à l'esprit que ceci est écrit pour C# 6.0 (2015), donc il pourrait avoir besoin d'un peu d'édition pour les versions antérieures.

Answer 15

Si vous essayez de faire correspondre la taille comme indiqué dans la vue détaillée de l'Explorateur Windows, c'est le code que vous voulez:

[DllImport("shlwapi.dll", CharSet = CharSet.Unicode)] 
private static extern long StrFormatKBSize(
    long qdw, 
    [MarshalAs(UnmanagedType.LPTStr)] StringBuilder pszBuf, 
    int cchBuf); 

public static string BytesToString(long byteCount) 
{ 
    var sb = new StringBuilder(32); 
    StrFormatKBSize(byteCount, sb, sb.Capacity); 
    return sb.ToString(); 
} 

Cela permettra non seulement Explorer correspondre exactement, mais fournira également les chaînes traduites pour vous et correspondent aux différences dans les versions de Windows (par exemple dans Win10, K = 1000 par rapport aux versions précédentes K = 1024).

Answer 16

Comme la solution @ NET3. Utilisez shift au lieu de division pour tester la plage de bytes, car la division prend plus de coût CPU.

private static readonly string[] UNITS = new string[] { "B", "KB", "MB", "GB", "TB", "PB", "EB" }; 

public static string FormatSize(ulong bytes) 
{ 
    int c = 0; 
    for (c = 0; c < UNITS.Length; c++) 
    { 
     ulong m = (ulong)1 << ((c + 1) * 10); 
     if (bytes < m) 
      break; 
    } 

    double n = bytes/(double)((ulong)1 << (c * 10)); 
    return string.Format("{0:0.##} {1}", n, UNITS[c]); 
} 

Answer 17

Que diriez-vous récursion:

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

Alors vous l'appelez:

return ReturnSize(size, string.Empty);