2009-02-19 48 views
19

Sto utilizzando la classe DriveInfo nel mio progetto C# per recuperare i byte disponibili su determinate unità. Come faccio a convertire correttamente questo numero in Mega o Gigabyte? Dividere per 1024 non farà il lavoro, credo. I risultati differiscono sempre da quelli mostrati in Windows-Explorer.Come convertire correttamente i file in byte in mega o in gigabyte?

+0

Eventuali duplicati di [non .net fornisce un modo semplice convertire i byte di KB, MB, GB, ecc?] (Http://stackoverflow.com/questions/14488796/does-net- fornire-un-facile-conversione-byte-to-kb-mb-gb-ecc) – Omar

risposta

46

1024 è corretto per l'utilizzo nei programmi.

Il motivo per cui si potrebbero riscontrare delle differenze è probabilmente dovuto a differenze in ciò che driveinfo segnala come "spazio disponibile" e quali finestre considerano lo spazio disponibile.

Si noti che solo i produttori di unità utilizzano 1.000. All'interno finestre e maggior parte dei programmi la scala corretta è 1024.

Inoltre, mentre il compilatore dovrebbe ottimizzare questo in ogni caso, questo calcolo può essere fatto semplicemente spostando i bit da 10 per ogni grandezza:

KB = B >> 10
MB = KB >> 10 = B >> 20
GB = MB >> 10 = KB >> 20 = B >> 30

Anche se per leggibilità prevedo successiva divisione per 1024 è più chiaro.

+0

Sì, solo i produttori di unità utilizzano le definizioni basate su 1.000. Ecco perché le unità "4,7 GB" sono in realtà 4,700,372,992 byte, "Blu-Ray da 50 GB" è solo 50,050,629,632 byte, il tuo "128 kbps" mp3 è in realtà 128.000 bit al secondo, una fotocamera "3.1 megapixel" ha solo 3.145.728 pixel, una Il processore a 2 GHz è in realtà 2.000.000.000 di Hertz, un bus di memoria di 16 GB/s è in realtà 16.000.000 di byte al secondo, ... – endolith

+0

Come stiamo parlando di unità, la dichiarazione è valida. Potrei essere più esplicito e affermare che i produttori dell'hardware rappresentano le dimensioni in miliardi mentre i progettisti software rappresentano le dimensioni in gibibyte, ma è abbastanza esplicito. Hai ragione nell'affermare che molte altre cose hanno problemi simili, ma questa discussione riguarda le dimensioni di file e unità, non le velocità del processore, le dimensioni dei sensori di immagine, ecc. Scusa se ti ho confuso, spero che questo chiarisca le cose. –

+3

1024 è solo "corretto" in quanto rappresenta il numero effettivo di bit sul disco. Se sei preoccupato della correttezza, tuttavia, devi visualizzarlo con l'unità "GiB". Usare 1024 e chiamarlo "GB" è tecnicamente scorretto. GB è ufficialmente 1000 milioni, non 1024 milioni. Direi che 1000 è l'uso corretto dal punto di vista dei fattori umani. 1 gigawatt è di 1000 megawatt. 1 GHz è 1000 MHz. Per lo stesso motivo (e per semplificare la matematica con gli umani) 1000 gigabyte sono 1000 megabyte. –

0

Divide by 1024.

4

Dipende se si desidera che la dimensione effettiva del file o la dimensione su disco. La dimensione del file effettivo è il numero effettivo di byte che il file utilizza in memoria. La dimensione su disco è una funzione della dimensione del file e della dimensione del blocco per il tuo disco/file system.

23

XKCD ha il definite answer:

Single, definitive standard for KB

+0

In KBa il bit aggiuntivo viene utilizzato per il rilevamento degli errori. ;-D –

+0

@Adam Davis Per ECC RAM è esattamente ciò che viene fatto nella pratica. – starblue

+16

mentre è divertente, non risponde alla domanda e può confondere quelli che sono facilmente confusi. –

10

1024 è in realtà sbagliato. La International Engineering Community (IEC) ha sviluppato uno standard nel 2000, che viene tristemente ignorato dall'industria informatica. Questo standard in sostanza dice che

  • 1000 byte è un kilobyte, 1000KB sono uno MB e così via. Le abbreviazioni sono KB, MB, GB e così via.
  • I 1024 byte spesso usati = 1 kilobyte devono invece essere chiamati 1024 byte = 1 Kibibyte (KiB), 1024 KiB = 1 Mebibyte (MiB), 1024 MiB = 1 Gibibyte (GiB) e così via.

Tutti possono leggere su IEC SI zone.

Pertanto, affinché le conversioni siano corrette e corrette secondo la standardizzazione internazionale, è necessario utilizzare questa notazione scientifica.

+2

Standard o no, sarebbe ridicolo segnalare l'utilizzo del disco in modo diverso rispetto al sistema operativo host! –

+1

Il problema riguarda il sistema operativo host che lo fa in modo errato e qualsiasi utente finale si chiede perché il nuovo disco acquistato nell'archivio sia meno aggiornato una volta installato rispetto a quello stampato sulla confezione. –

+1

re: "sarebbe ridicolo segnalare l'utilizzo del disco in modo diverso rispetto al sistema operativo host": Snow Leopard (Mac OSX 10.6) utilizza il valore 1000 (http://support.apple.com/kb/TS2419) –

1

Ho un debole ricordo che la risposta sull'uso di 1000 o 1024 si trova nell'involucro del prefisso. Esempio: Se viene utilizzato il ridimensionamento "scientifico" 1000, l'unità "scientifica" sarà kB (come in kg, kN ecc.). Se viene utilizzato il ridimensionamento computerizzato 1024, l'unità sarà KB. Quindi, il primato scientifico del prefisso lo rende centrato sul computer.

+0

KB = 1000 byte, KiB = 1024 byte –

+0

+1 Per k vs. K questo è corretto, ma non aiuta quando la lettera per il prefisso ISO è già in maiuscolo, come in M, G e T per Mega, Giga e Tera. E molte persone, specialmente dagli Stati Uniti, hanno la tendenza a mescolare il caso delle unità ISO e dei prefissi. – starblue

11

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