La conversion d'octets de GO en C#?

J'ai été refactoring quelques vieux code et est venu à travers la ligne de code suivante pour convertir les octets de GO.

decimal GB = KB / 1024 / 1024 / 1024;

Est-il un meilleur moyen de refactoriser le code suivant?

mise à Jour

Je voulais dire octets de Gigaoctets. J'ai donné des informations erronées.

decimal GB = KB / 1024 / 1024; serait mieux...
Outre un supplément de division, il n'y a rien de mal avec le code écrit; il est parfaitement clair dans ses intentions, pas inutilement verbeux, et il n'y a aucune perf problèmes. Pourquoi voudriez-vous refactoriser le code?
Je pense que c'est bien, mais je serais probablement GO = octets * 1E-9;
Désolé d'être ce gars-là, mais c'est gibibytes pas gigaoctets.

InformationsquelleAutor Michael Kniskern | 2009-08-07

c#refactoring

90

J'ai développé cette méthode ici, fonctionne jusqu'à la TUBERCULOSE.
```
private static string FormatBytes(long bytes)
{
    string[] Suffix = { "B", "KB", "MB", "GB", "TB" };
    int i;
    double dblSByte = bytes;
    for (i = 0; i < Suffix.Length && bytes >= 1024; i++, bytes /= 1024) 
    {
        dblSByte = bytes / 1024.0;
    }

    return String.Format("{0:0.##} {1}", dblSByte, Suffix[i]);
}
```
- un peu allé à l'échelle de sujet, mais j'adore le truc. +1
- Je suis d'accord avec @ktutnik sujet de la deuxième partie!
- Comment cela fonctionne? il vous manque un type de retour dans le if/else
- Ouais, quelqu'un a modifié mon code depuis la dernière fois que je l'ai placé ici.
- Le code de bugs lorsque le nombre d'octets atteint PB.
InformationsquelleAutor JLopez
18

Si la précision n'est pas importante, l'utilisation double:
```
double gb = kb / 1048576D
```
D'accord avec Pavel ici - il n'y a pas vraiment besoin de revoir ce code... en fait, si c'est le plus gros problème dans votre base de code, je pense que vous pourriez être assis sur la plupart des écrits logiciel jamais.
- +1 sur l'utilisation de la double, mais je pense que l'origine de la mise en œuvre de l'intention est claire.
- probablement. Je pense que les go = ko... une partie est une assez bonne idée bien 🙂
- vous pourriez probablement améliorer la lisibilité de la valeur 1048576 en déclarant comme une constante avec l'intention de révéler le nom de...
InformationsquelleAutor Rex M
7

Le code d'origine est concis, facile à lire, et avec suffisamment de noms de variables, de l'auto-documentation; je ne changerai pas.

Si vous devez absolument refactoriser, vous pouvez créer un ensemble de méthodes d'extension sur les types numériques:
```
public static double BytesToKilobytes(this Int32 bytes)
{
    return bytes / 1024d;
}
public static double BytesToMegabytes(this Int32 bytes)
{
    return bytes / 1024d / 1024d;
}
public static double KilobytesToBytes(this double kilobytes)
{
    return kilobytes * 1024d;
}

//You can then do something like:
double filesize = 32.5d;
double bytes = filesize.KilobytesToBytes();
```
Mais à moins que votre code ne fait pratiquement rien, mais de convertir les octets de kilo-octets, etc, tout cela va vraiment faire est d'encombrer Intellisense pour aucun gain réel.

InformationsquelleAutor technophile

    ///<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;
case "KB":
//convert to kilobytes
return (bytes / CONVERSION_VALUE);
case "MB":
//convert to megabytes
return (bytes / CalculateSquare(CONVERSION_VALUE));
case "GB":
//convert to gigabytes
return (bytes / CalculateCube(CONVERSION_VALUE));
default:
//default
return bytes;
}
}
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"

InformationsquelleAutor AZ_

2

Personnellement je préfère l'écrire comme ceci: decimal GB = KB /(1024 * 1024); mais il n'y a vraiment pas besoin de refactoriser le code écrit.

InformationsquelleAutor mattnewport
2

Bien, la formule est fausse (il n'y a qu'environ un million de kilo-octets dans un gigaoctet, pas un millier de millions de dollars), mais, à part ça, c'est très bien. Quiconque a l'habitude de travailler avec ces numéros de savoir ce qu'il signifie.

Une chose que je voudrais regarder (et je ne sais pas si c'est un problème avec C#) est qu'un compilateur peut ne pas être en mesure d'optimiser la x/1024/1024 si x n'est pas un type de base. Avec C et entiers, le compilateur aurait assez facilement le transformer en un "absolument-rapide-shift-droit-par-20-bits" de l'enseignement.

Si la décimale est une classe plutôt que d'un type de base, le compilateur peut avoir à faire deux opérations de division. Si cela a un réel impact sur la vitesse (ou même s'il arrive à tous) est en dehors de ma sphère de la connaissance.

Une chose que je voudrais examiner en train de changer les noms de variable réels. Il ne fait aucune différence pour le code compilé, mais je préfère plus les noms de variables plutôt que des abréviations, donc je préfère kiloBytes/gigaBytes ou quelque chose comme ça. KB/GB est trop facile de se confondre avec des constantes, en fonction de vos normes de codage.
- virgule est un type, pas une classe. Mais il ne prend pas en charge bitshifts soit, même si ils aurait du sens. Peut-être que le compilateur peut utiliser dans ce scénario, même si le programmeur ne peut pas.
InformationsquelleAutor paxdiablo
2

En théorie, c'est plus rapide (precomputing la constante de multiplication au lieu de la division). Ce n'est probablement pas utilisé assez souvent à la matière, mais juste au cas où.
```
double const KbToGbFactor = 1d / 1024 /1024;
double gb = kb * KbToGbFactor;
```
- Je suis sûr que ce sera optimisé lorsque le programme est compilé. C'est plus une question de goût mais si vous voulez ou non const ici.
- Je ne suis pas si sûr - blogs.msdn.com/ericlippert/archive/2009/06/11/...
- J'aime cette réponse de "clarté" (dans mon esprit), mais pas pour "l'optimisation". Uhg 🙂
InformationsquelleAutor Kenan E. K.

J'ai écrit un petit utilitaire de la classe qui effectue des conversions entre les unités, hth..

#region StorageDifferential
///<summary>
///Converts between Base 2 or Base 10 storage units [TB, GB, MB, KB, Bytes]
///</summary>
public enum Differential : int
{
///<summary>
///Convert Bytes to Kilobytes
///</summary>
ByteToKilo,
///<summary>
///Convert Bytes to Megabytes
///</summary>
ByteToMega,
///<summary>
///Convert Bytes to Gigabytes
///</summary>
ByteToGiga,
///<summary>
///Convert Bytes to Teraytes
///</summary>
ByteToTera,
///<summary>
///Convert Kilobytes to Bytes
///</summary>
KiloToByte,
///<summary>
///Convert Kilobytes to Megabytes
///</summary>
KiloToMega,
///<summary>
///Convert Kilobytes to Gigabytes
///</summary>
KiloToGiga,
///<summary>
///Convert Kilobytes to Terabytes
///</summary>
KiloToTera,
///<summary>
///Convert Megabytes to Bytes
///</summary>
MegaToByte,
///<summary>
///Convert Megabytes to Kilobytes
///</summary>
MegaToKilo,
///<summary>
///Convert Megabytes to Gigabytes
///</summary>
MegaToGiga,
///<summary>
///Convert Megabytes to Terabytes
///</summary>
MegaToTera,
///<summary>
///Convert Gigabytes to Bytes
///</summary>
GigaToByte,
///<summary>
///Convert Gigabytes to Kilobytes
///</summary>
GigaToKilo,
///<summary>
///Convert Gigabytes to Megabytes
///</summary>
GigaToMega,
///<summary>
///Convert Gigabytes to Terabytes
///</summary>
GigaToTerra,
///<summary>
///Convert Terabyte to Bytes
///</summary>
TeraToByte,
///<summary>
///Convert Terabyte to Kilobytes
///</summary>
TeraToKilo,
///<summary>
///Convert Terabytes to Megabytes
///</summary>
TeraToMega,
///<summary>
///Convert Terabytes to Gigabytes
///</summary>
TeraToGiga,
}
#endregion
#region Storage Sizes
///<summary>
///Enumeration of recognized storage sizes [in Bytes]
///</summary>
public enum StorageSizes : long
{
///<summary>
///Base 10 Conversion
///</summary>
KILOBYTE = 1000,
MEGABYTE = 1000000,
GIGABYTE = 1000000000,
TERABYTE = 1000000000000,
///<summary>
///Base 2 Conversion
///</summary>
KIBIBYTE = 1024,
MEBIBYTE = 1048576,
GIBIBYTE = 1073741824,
TEBIBYTE = 1099511627776,
}
#endregion
#region StorageBase
///<summary>
///Storage powers 10 based or 1024 based
///</summary>
public enum StorageBase : int
{
///<summary>
///1024 Base power, Typically used in memory measurements
///</summary>
BASE2,
///<summary>
///10 Base power, Used in storage mediums like harddrives
///</summary>
BASE10,
}
#endregion
///<summary>
///Convert between base 1024 storage units [TB, GB, MB, KB, Byte]
///</summary>
public static class StorageConverter
{
///<summary>
///Convert between base 1024 storage units [TB, GB, MB, KB, Byte]
///</summary>
///<param name="SizeDifferential">Storage conversion differential [enum]</param>
///<param name="UnitSize">Size as mutiple of unit type units [double]</param>
///<param name="BaseUnit">Size of the base power [enum]</param>
///<returns>Converted unit size [double]</returns>
public static double Convert(Differential SizeDifferential, double UnitSize, StorageBase BaseUnit = StorageBase.BASE10)
{
if (UnitSize < 0.000000000001) return 0;
double POWER1 = 1000;
double POWER2 = 1000000;
double POWER3 = 1000000000;
double POWER4 = 1000000000000;
if (BaseUnit == StorageBase.BASE2)
{
POWER1 = 1024;
POWER2 = 1048576;
POWER3 = 1073741824;
POWER4 = 1099511627776;
}
switch (SizeDifferential)
{
case Differential.ByteToKilo:
return UnitSize / POWER1;
case Differential.ByteToMega:
return UnitSize / POWER2;
case Differential.ByteToGiga:
return UnitSize / POWER3;
case Differential.ByteToTera:
return UnitSize / POWER4;
case Differential.KiloToByte:
return UnitSize * POWER1;
case Differential.KiloToMega:
return UnitSize / POWER1;
case Differential.KiloToGiga:
return UnitSize / POWER2;
case Differential.KiloToTera:
return UnitSize / POWER3;
case Differential.MegaToByte:
return UnitSize * POWER2;
case Differential.MegaToKilo:
return UnitSize * POWER1;
case Differential.MegaToGiga:
return UnitSize / POWER1;
case Differential.MegaToTera:
return UnitSize / POWER2;
case Differential.GigaToByte:
return UnitSize * POWER3;
case Differential.GigaToKilo:
return UnitSize * POWER2;
case Differential.GigaToMega:
return UnitSize * POWER1;
case Differential.GigaToTerra:
return UnitSize / POWER1;
case Differential.TeraToByte:
return UnitSize * POWER4;
case Differential.TeraToKilo:
return UnitSize * POWER3;
case Differential.TeraToMega:
return UnitSize * POWER2;
case Differential.TeraToGiga:
return UnitSize * POWER1;
}
return 0;
}
}

InformationsquelleAutor JGU

1

Pour s'assurer que le compilateur pré-calcule les diviseurs:
```
decimal GB = KB / (1024 * 1024);
```
Note que vous êtes en fait, le calcul GiB (gibibyte), pas GO (gigaoctet). Si vous voulez vraiment calculer GO, ce serait:
```
decimal GB = KB / (1000 * 1000);
```
- Dans l'usage général, gigabyte est utilisé pour se référer à 1024^3 octets, méga pour une résolution 1024^2, kilo pour du 1024. Il peut ne pas être techniquement correct, mais je ne pense pas que quelqu'un (d'autre) ici les esprits.
- Oui, la plupart des gens ne sont pas conscients de la norme eventhough il a été autour depuis plus de dix ans, c'est pourquoi j'ai fait une remarque à ce sujet...
- La "norme" est simplement pas vrai, depuis qu'il a changé la commune de la signification des mots et créé de nouveaux mots pour les choses communes. C'est vraiment pas pourquoi on accepte cette norme, en dehors de l'industrie qui l'a fait.
- Ce que vous dites n'est pas vrai. J'ai vu plusieurs programmes à l'aide de la standardisation des unités. C'est un vrai standard, défini par la norme IEC et accepté par plusieurs grands organismes de normalisation comme l'IEEE et le CIPM. Le standard n'a pas changé le voir signification des unités comme il n'y a pas le même sens. Prenez par exemple le cas de "1,44 MO" de disquettes, où la capcaity était ni de 1,44 MO, ni de 1,44 MiB, mais 1.44 * 1024 * 1000 octets...
InformationsquelleAutor Guffa

J'en avais besoin, à l'inverse, convertir de la 3ème partie de la composante littérale de la taille en mots (par exemple "0 octets", "1.1 MO") dans le générique de la taille en octets. je l'ai donc utilisé de cette façon:

        private static long UnformatBytes(string sizeInWords)
{
if(string.IsNullOrWhiteSpace(sizeInWords))
return -1;
string size = sizeInWords.Split(' ').FirstOrDefault();
double result;
if (string.IsNullOrWhiteSpace(size) || !double.TryParse(size, out result))
{
Debugger.Break();
return -1;
}
int pow;
if (sizeInWords.IndexOf("byte", StringComparison.OrdinalIgnoreCase) > -1)
pow = 0;
else if (sizeInWords.IndexOf("kb", StringComparison.OrdinalIgnoreCase) > -1)
pow = 1;
else if (sizeInWords.IndexOf("mb", StringComparison.OrdinalIgnoreCase) > -1)
pow = 2;
else if (sizeInWords.IndexOf("gb", StringComparison.OrdinalIgnoreCase) > -1)
pow = 3;
else if (sizeInWords.IndexOf("tb", StringComparison.OrdinalIgnoreCase) > -1)
pow = 4;
else
return -1;
return System.Convert.ToInt64((result * Math.Pow(1024, pow)));
}

InformationsquelleAutor Elad Tal

C'est un peu d'amélioration de la bonne JLopez de la réponse (s'il vous plaît VOTER LUI, pas moi).
Ici, vous pouvez choisir d'avoir ou non des unités de l'indication et le kilo unité est écrit avec la minuscule "k" (la majuscule est de Kelvin)

//note: this is the JLopez answer!!
///<summary>
///Return size in human readable form
///</summary>
///<param name="bytes">Size in bytes</param>
///<param name="useUnit ">Includes measure unit (default: false)</param>
///<returns>Readable value</returns>
public static string FormatBytes(long bytes, bool useUnit = false)
{
string[] Suffix = { " B", " kB", " MB", " GB", " TB" };
double dblSByte = bytes;
int i;
for (i = 0; i < Suffix.Length && bytes >= 1024; i++, bytes /= 1024)
{
dblSByte = bytes / 1024.0;
}
return $"{dblSByte:0.##}{(useUnit ? Suffix[i] : null)}";
}

InformationsquelleAutor tedebus

    public static string BytesToString(this long bytes, string format = "#,##0.00") {
var unitstr = new string[] { "B", "KB", "MB", "GB", "TB" };
var bytesd = Convert.ToDouble(bytes);
var unit = 0;
while (bytesd / 1024D > 1 && unit < unitstr.Length) {
unit++; bytesd /= 1024D;
}
return string.Format("{0:" + format + "}{1}", bytesd, unitstr[unit]);
}

InformationsquelleAutor Leo

#region AutoFileSize
public string AutoFileSize(long number)
{
double tmp = number;
string suffix = " B ";
if (tmp > 1024) { tmp = tmp / 1024; suffix = " KB"; }
if (tmp > 1024) { tmp = tmp / 1024; suffix = " MB"; }
if (tmp > 1024) { tmp = tmp / 1024; suffix = " GB"; }
if (tmp > 1024) { tmp = tmp / 1024; suffix = " TB"; }
return tmp.ToString("n") + suffix;
}
#endregion
long number = (long)fu.PostedFile.ContentLength;

InformationsquelleAutor user3958481

Vous devez vous connecter pour publier un commentaire.