web-dev-qa-db-fra.com

Comment convertir correctement les fichiers dans des octets en Mega ou GigaBytes?

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? La division par 1024 ne fera pas le travail, je suppose. Les résultats diffèrent toujours de ceux présentés dans l'explorateur Windows.

c#bytediskdriveinfomegabyte
21
Mats

1024 est correct pour l'utilisation dans les programmes.

La raison pour laquelle vous pourriez avoir des différences est probablement due à des différences dans ce que DRIVEINFO rapporte comme "espace disponible" et ce que Windows considère l'espace disponible.

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

De plus, pendant que votre compilateur devrait l'optimiser de toute façon, ce calcul peut être effectué en déplaçant simplement les bits de 10 pour chaque grandeur:

KB = B >> 10
[.____] MB = KB >> 10 = B >> 20
[.____] GB = MB >> 10 = KB >> 20 = B >> 30

Bien que pour la lisibilité, je m'attends à ce que la division successive de 1024 soit plus claire.

48
Adam Davis

XKCD a la réponse définitive :

Single, definitive standard for KB

24
starblue
/// <summary>
/// Function to convert the given bytes to either Kilobyte, Megabyte, or Gigabyte
/// </summary>
/// <param name="bytes">Double -> Total bytes to be converted</param>
/// <param name="type">String -> Type of conversion to perform</param>
/// <returns>Int32 -> Converted bytes</returns>
/// <remarks></remarks>
public static double ConvertSize(double bytes, string type)
{
    try
    {
        const int CONVERSION_VALUE = 1024;
        //determine what conversion they want
        switch (type)
        {
            case "BY":
                 //convert to bytes (default)
                 return bytes;
                 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;
      }
}

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


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

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

1024 est en fait faux. La communauté internationale d'ingénierie (CEI) a mis au point une norme en 2000, qui est malheureusement ignorée par l'industrie informatique. Cette norme dit essentiellement que

  • 1000 octets est un kilobyte, 1000 Ko sont un MB et ainsi de suite. Les abréviations sont KB, MB, GB et ainsi de suite.
  • Les 1024 octets largement utilisés = 1 kiloByte devraient plutôt par appelé 1024 octets = 1 kibibyte (kib), 1024 kib = 1 mébibyte (mib), 1024 mib = 1 gibibyte (gib) et ainsi de suite.

Vous pouvez tous la lire sur la Zone IEC Si .

Ainsi, pour que vos conversions soient correctes et correctes selon la normalisation internationale, vous devez utiliser cette notation scientifique.

11
grover

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

4
EBGreen

J'ai un léger souvenir que la réponse à l'utilisation de 1000 ou 1024 réside dans le boîtier du préfixe. Exemple: si la mise à l'échelle "scientifique" 1000 est utilisée, l'unité "scientifique" sera KB (comme dans kg, kN, etc.). Si la mise à l'échelle Centric Centric 1024 est utilisée, l'unité sera alors KB. Ainsi, la barre-culasse du préfixe scientifique le rend centré sur ordinateur.

1
Anders

Diviser par 1024.

0
Fabian Vilers