Comment convertir correctement la taille des fichiers en octets en méga ou en gigaoctets?

J’utilise la classe DriveInfo dans mon projet C # pour récupérer les octets disponibles sur des lecteurs donnés. Comment convertir correctement ce nombre en méga ou gigaoctets? Diviser par 1024 ne fera pas le travail, je suppose. Les résultats diffèrent toujours de ceux affichés dans l’explorateur Windows.

1024 est correct pour une utilisation dans les programmes.

La raison pour laquelle vous pouvez avoir des différences est probablement due aux différences entre ce que driveinfo rapporte comme “espace disponible” et ce que Windows considère comme étant de la place disponible.

Notez que seuls les fabricants de lecteurs en utilisent 1 000. Dans Windows et la plupart des programmes, la mise à l’échelle correcte est 1024.

De plus, bien que votre compilateur doive l’optimiser de toute façon, ce calcul peut être fait en décalant simplement les bits de 10 pour chaque grandeur:

KB = B >> 10
MB = KB >> 10 = B >> 20
Go = Mo >> 10 = Ko >> 20 = B >> 30

Bien que par souci de lisibilité, je prévois une division successive de 1024 est plus claire.

XKCD a la réponse définitive :

Norme unique et définitive pour KB

 ///  /// Function to convert the given bytes to either Kilobyte, Megabyte, or Gigabyte ///  /// Double -> Total bytes to be converted /// Ssortingng -> Type of conversion to perform /// Int32 -> Converted bytes ///  public static double ConvertSize(double bytes, ssortingng type) { try { const int CONVERSION_VALUE = 1024; //determine what conversion they want switch (type) { case "BY": //convert to bytes (default) return bytes; break; case "KB": //convert to kilobytes return (bytes / CONVERSION_VALUE); break; case "MB": //convert to megabytes return (bytes / CalculateSquare(CONVERSION_VALUE)); break; case "GB": //convert to gigabytes return (bytes / CalculateCube(CONVERSION_VALUE)); break; default: //default return bytes; break; } } catch (Exception ex) { Console.WriteLine(ex.Message); return 0; } } ///  /// Function to calculate the square of the provided number ///  /// Int32 -> Number to be squared /// Double -> THe provided number squared ///  public static double CalculateSquare(Int32 number) { return Math.Pow(number, 2); } ///  /// Function to calculate the cube of the provided number ///  /// Int32 -> Number to be cubed /// Double -> THe provided number cubed ///  public static double CalculateCube(Int32 number) { return Math.Pow(number, 3); } //Sample Useage Ssortingng Size = "File is " + ConvertSize(250222,"MB") + " Megabytes in size" 

1024 est en fait faux. La communauté internationale des ingénieurs (CEI) a élaboré une norme en 2000, malheureusement ignorée par l’indussortinge informatique. Cette norme dit essentiellement que

  • 1000 octets correspondent à un kilo-octet, 1000 Ko à un Mo, etc. Les abréviations sont KB, MB, GB, etc.
  • Les 1024 octets = 1 kilo-octet largement utilisés devraient plutôt être appelés par 1024 octets = 1 kibibyte (KiB), 1024 kiB = 1 mébibyte (Mio), 1024 Mio = 1 gibyctet (Gio), etc.

Vous pouvez tous le lire sur la zone CEI SI .

Donc, pour que vos conversions soient correctes et correctes conformément à la normalisation internationale, vous devez utiliser cette notation scientifique.

Cela dépend si vous voulez la taille réelle du fichier ou la taille sur le disque. La taille réelle du fichier est le nombre réel d’octets que le fichier utilise en mémoire. La taille sur le disque est fonction de la taille du fichier et de la taille du bloc de votre disque / système de fichiers.

Je me souviens très bien que la réponse à l’utilisation de 1000 ou 1024 réside dans la casse du préfixe. Exemple: Si vous utilisez la mise à l’échelle “scientifique” 1000, l’unité “scientifique” sera alors kB (exactement comme en kg, kN, etc.). Si la mise à l’échelle centrée sur l’ordinateur 1024 est utilisée, alors l’unité sera KB. Donc, mettre en majuscule le préfixe scientifique le rend centré sur l’ordinateur.

Diviser par 1024.