Je me demande simplement si .NET fournit un moyen propre de le faire:
int64 x = 1000000;
string y = null;
if (x / 1024 == 0) {
y = x + " bytes";
}
else if (x / (1024 * 1024) == 0) {
y = string.Format("{0:n1} KB", x / 1024f);
}
etc...
Voici une façon assez concise de procéder:
static readonly string[] SizeSuffixes =
{ "bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB" };
static string SizeSuffix(Int64 value, int decimalPlaces = 1)
{
if (decimalPlaces < 0) { throw new ArgumentOutOfRangeException("decimalPlaces"); }
if (value < 0) { return "-" + SizeSuffix(-value); }
if (value == 0) { return string.Format("{0:n" + decimalPlaces + "} bytes", 0); }
// mag is 0 for bytes, 1 for KB, 2, for MB, etc.
int mag = (int)Math.Log(value, 1024);
// 1L << (mag * 10) == 2 ^ (10 * mag)
// [i.e. the number of bytes in the unit corresponding to mag]
decimal adjustedSize = (decimal)value / (1L << (mag * 10));
// make adjustment when the value is large enough that
// it would round up to 1000 or more
if (Math.Round(adjustedSize, decimalPlaces) >= 1000)
{
mag += 1;
adjustedSize /= 1024;
}
return string.Format("{0:n" + decimalPlaces + "} {1}",
adjustedSize,
SizeSuffixes[mag]);
}
Et voici l'implémentation originale que j'ai suggérée, qui peut être légèrement plus lente, mais un peu plus facile à suivre:
static readonly string[] SizeSuffixes =
{ "bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB" };
static string SizeSuffix(Int64 value, int decimalPlaces = 1)
{
if (value < 0) { return "-" + SizeSuffix(-value); }
int i = 0;
decimal dValue = (decimal)value;
while (Math.Round(dValue, decimalPlaces) >= 1000)
{
dValue /= 1024;
i++;
}
return string.Format("{0:n" + decimalPlaces + "} {1}", dValue, SizeSuffixes[i]);
}
Console.WriteLine(SizeSuffix(100005000L));
Une chose à garder à l'esprit - en notation SI, "kilo" utilise généralement un k minuscule tandis que toutes les unités plus grandes utilisent une lettre majuscule. Windows utilise KB, MB, GB, donc j'ai utilisé KB ci-dessus, mais vous pouvez envisager Ko à la place.
if (value == 0) { return "0"; }
vérification à l'intérieur de la fonction.La caisse ByteSize bibliothèque. C'est le
System.TimeSpan
for bytes!Il gère la conversion et le formatage pour vous.
Il effectue également la représentation et l'analyse de chaînes.
la source
Puisque tout le monde publie leurs méthodes, je me suis dit que je publierais la méthode d'extension que j'utilise habituellement pour cela:
EDIT: ajout de variantes int / long ... et correction d'une typo copypasta ...
la source
Je le résoudrais en utilisant
Extension methods
,Math.Pow
fonction etEnums
:et utilisez-le comme:
la source
La version courte de la réponse la plus votée a des problèmes avec les valeurs TB.
Je l'ai ajusté de manière appropriée pour gérer également les valeurs tb et toujours sans boucle et j'ai également ajouté une petite vérification d'erreur pour les valeurs négatives. Voici ma solution:
la source
Non. Surtout parce qu'il s'agit d'un besoin plutôt de niche et qu'il y a trop de variations possibles. (S'agit-il de "Ko", "Kb" ou "Ko"? Un mégaoctet est-il de 1024 * 1024 octets ou 1024 * 1000 octets? - oui, certains endroits l'utilisent!)
la source
Voici une option plus facile à étendre que la vôtre, mais non, aucune n'est intégrée à la bibliothèque elle-même.
la source
C'est une façon de le faire également (le numéro 1073741824.0 est de 1024 * 1024 * 1024 aka GB)
la source
La réponse de @ Servy était belle et succincte. Je pense que cela peut être encore plus simple?
la source
Basé sur la solution élégante de NeverHopeless:
Peut-être qu'il y a des commentaires excessifs, mais j'ai tendance à les laisser pour m'empêcher de faire les mêmes erreurs lors de futures visites ...
la source
Non.
Mais vous pouvez implémenter comme ceci;
Consultez également Comment convertir correctement la taille des fichiers en octets en méga ou gigaoctets?
la source
J'ai combiné certaines des réponses ici en deux méthodes qui fonctionnent très bien. La deuxième méthode ci-dessous convertira une chaîne d'octets (comme 1,5,1 Go) en octets (comme 1621350140) en tant que valeur de type long. J'espère que cela sera utile à ceux qui recherchent une solution pour convertir des octets en une chaîne et les remettre en octets.
la source
float.Parse
pourdouble
?Je sais que c'est déjà un vieux fil. mais peut-être que quelqu'un cherchera une solution. Et voici ce que j'utilise et le moyen le plus simple
la source
Que diriez-vous:
Par exemple, appelez comme
Se traduira par une sortie
la source
Je suis allé chercher la solution JerKimballs, et je suis d'accord avec ça. Cependant, je voudrais ajouter / souligner que c'est effectivement une question de controverse dans son ensemble. Dans mes recherches (pour d'autres raisons), j'ai trouvé les informations suivantes.
Quand les gens normaux (j'ai entendu dire qu'ils existent) parlent de gigaoctets, ils se réfèrent au système métrique dans lequel 1000 à la puissance de 3 à partir du nombre original d'octets == le nombre de gigaoctets. Cependant, bien sûr, il y a les normes IEC / JEDEC qui se résument bien dans wikipedia, qui au lieu de 1000 à la puissance de x, elles en ont 1024. Ce qui pour les périphériques de stockage physiques (et je suppose logique comme amazon et autres) signifie un différence toujours croissante entre métrique et CEI. Ainsi, par exemple, 1 To == 1 téraoctet métrique équivaut à 1000 à la puissance de 4, mais la CEI qualifie officiellement le même nombre de 1 Tio, le tebibyte à 1024 à la puissance de 4. Mais, hélas, dans les applications non techniques (je voudrais aller par public) la norme est métrique, et dans ma propre application à usage interne, j'explique actuellement la différence dans la documentation. Mais à des fins d'affichage, je n'offre même rien d'autre que la métrique. En interne, même si ce n'est pas pertinent dans mon application, je ne stocke que les octets et je fais le calcul pour l'affichage.
En passant, je trouve quelque peu terne que le framework .Net AFAIK (et je me trompe souvent, remercie les pouvoirs en place) même dans son incarnation 4.5 ne contient rien à ce sujet dans aucune bibliothèque en interne. On pourrait s'attendre à ce qu'une bibliothèque open source quelconque soit NuGettable à un moment donné, mais j'admets que c'est une petite bête noire. D'autre part, System.IO.DriveInfo et d'autres n'ont également que des octets (aussi longs), ce qui est plutôt clair.
la source
la source
Que diriez-vous d'une récursivité:
Ensuite, vous pouvez l'appeler:
la source
Comme indiqué ci-dessus, la récursivité est la méthode préférée, à l'aide du logarithme.
La fonction suivante a 3 arguments: l'entrée, la contrainte de dimension de la sortie, c'est-à-dire le troisième argument.
Convertissons maintenant 12 Go de RAM en plusieurs unités:
la source
J'utilise ceci pour Windows (préfixes binaires):
la source
J'ai incorporé ceci (avec peu ou pas de modification) dans un convertisseur UWP DataBinding pour mon projet et j'ai pensé que cela pourrait également être utile à d'autres.
Le code est:
Pour l'utiliser, ajoutez une ressource locale à votre UserControl ou Page XAML:
Référencez-le dans un modèle de liaison de données ou une instance de liaison de données:
Et hé hop. La magie opère.
la source
https://github.com/logary/logary/blob/master/src/Logary/DataModel.fs#L832-L837
(DISCLAIMER: j'ai écrit ce code, même le code dans le lien!)
la source