/// <summary>Determines whether the specified UnitsOfInformation is bytes.</summary> /// <param name="uoi">The UnitsOfInformation.</param> /// <returns><c>true</c> if the specified UnitsOfInformation is bytes; otherwise, <c>false</c>.</returns> private static bool IsBytes(UnitsOfInformation uoi) { switch (uoi) { case UnitsOfInformation.bytes: case UnitsOfInformation.kilobyte: case UnitsOfInformation.megabyte: case UnitsOfInformation.gigabyte: case UnitsOfInformation.terabyte: case UnitsOfInformation.petabyte: case UnitsOfInformation.exabyte: case UnitsOfInformation.zettabyte: case UnitsOfInformation.yottabyte: case UnitsOfInformation.kibibyte: case UnitsOfInformation.mebibyte: case UnitsOfInformation.gibibyte: case UnitsOfInformation.tebibyte: case UnitsOfInformation.pebibyte: case UnitsOfInformation.exbibyte: case UnitsOfInformation.zebibyte: case UnitsOfInformation.yobibyte: return(true); } return(false); }
/// <summary>Converts the number to an appropriate unit of information.</summary> /// <param name="value">The value to convert.</param> /// <param name="from">The unit of information to convert from.</param> /// <param name="radix">The desired radix to use.</param> /// <returns>The unit of information as string.</returns> private static string ConvertToUnitOfInformation(BigInteger value, UnitsOfInformation from, UnitsOfInformationRadix radix) { bool fromIsBits = IsBits(from); bool fromIsBytes = IsBytes(from); // result in bits if (fromIsBits) { // convert value "from" of any bit-unit to bits. value = AnyBitUnitToBits(value, from); // convert the bits to the "to" unit. return(BitsToAppropriateBitUnit(value, radix, out UnitsOfInformation uoi) + " " + GetPrefix(uoi)); } // result in bytes if (fromIsBytes) { // convert value "from" of any byte-unit to byte. value = AnyByteUnitToBytes(value, from); // convert the bytes to the "to" unit. return(BytesToAppropriateByteUnit(value, radix, out UnitsOfInformation uoi) + " " + GetPrefix(uoi)); } // should never happen: return(value + " ???"); }
private static BigInteger BytesToAnyByteUnit(BigInteger value, UnitsOfInformation uoi) { switch (uoi) { case UnitsOfInformation.bytes: return(value); case UnitsOfInformation.kilobyte: return(value / 1000); case UnitsOfInformation.megabyte: return(value / 1000 / 1000); case UnitsOfInformation.gigabyte: return(value / 1000 / 1000 / 1000); case UnitsOfInformation.terabyte: return(value / 1000 / 1000 / 1000 / 1000); case UnitsOfInformation.petabyte: return(value / 1000 / 1000 / 1000 / 1000 / 1000); case UnitsOfInformation.exabyte: return(value / 1000 / 1000 / 1000 / 1000 / 1000 / 1000); case UnitsOfInformation.zettabyte: return(value / 1000 / 1000 / 1000 / 1000 / 1000 / 1000 / 1000); case UnitsOfInformation.yottabyte: return(value / 1000 / 1000 / 1000 / 1000 / 1000 / 1000 / 1000 / 1000); case UnitsOfInformation.kibibyte: return(value / 1024); case UnitsOfInformation.mebibyte: return(value / 1024 / 1024); case UnitsOfInformation.gibibyte: return(value / 1024 / 1024 / 1024); case UnitsOfInformation.tebibyte: return(value / 1024 / 1024 / 1024 / 1024); case UnitsOfInformation.pebibyte: return(value / 1024 / 1024 / 1024 / 1024 / 1024); case UnitsOfInformation.exbibyte: return(value / 1024 / 1024 / 1024 / 1024 / 1024 / 1024); case UnitsOfInformation.zebibyte: return(value / 1024 / 1024 / 1024 / 1024 / 1024 / 1024 / 1024); case UnitsOfInformation.yobibyte: return(value / 1024 / 1024 / 1024 / 1024 / 1024 / 1024 / 1024 / 1024); default: return(value); } }
private static BigInteger AnyBitUnitToBits(BigInteger value, UnitsOfInformation uoi) { switch (uoi) { case UnitsOfInformation.bits: return(value); case UnitsOfInformation.kilobit: return(value * 1000); case UnitsOfInformation.megabit: return(value * 1000 * 1000); case UnitsOfInformation.gigabit: return(value * 1000 * 1000 * 1000); case UnitsOfInformation.terabit: return(value * 1000 * 1000 * 1000 * 1000); case UnitsOfInformation.petabit: return(value * 1000 * 1000 * 1000 * 1000 * 1000); case UnitsOfInformation.exabit: return(value * 1000 * 1000 * 1000 * 1000 * 1000 * 1000); case UnitsOfInformation.zettabit: return(value * 1000 * 1000 * 1000 * 1000 * 1000 * 1000 * 1000); case UnitsOfInformation.yottabit: return(value * 1000 * 1000 * 1000 * 1000 * 1000 * 1000 * 1000 * 1000); case UnitsOfInformation.kibibit: return(value * 1024); case UnitsOfInformation.mebibit: return(value * 1024 * 1024); case UnitsOfInformation.gibibit: return(value * 1024 * 1024 * 1024); case UnitsOfInformation.tebibit: return(value * 1024 * 1024 * 1024 * 1024); case UnitsOfInformation.pebibit: return(value * 1024 * 1024 * 1024 * 1024 * 1024); case UnitsOfInformation.exbibit: return(value * 1024 * 1024 * 1024 * 1024 * 1024 * 1024); case UnitsOfInformation.zebibit: return(value * 1024 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024); case UnitsOfInformation.yobibit: return(value * 1024 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024); default: return(value); } }
// ------------------------------------------------------------------------------------------------- // PRIVATE METHODS // ------------------------------------------------------------------------------------------------- /// <summary>Converts the number to the specified unit of information.</summary> /// <param name="value">The value to convert.</param> /// <param name="from">The unit of information to convert from.</param> /// <param name="to">The unit of information to convert to.</param> /// <returns>The unit of information as string.</returns> private static string ConvertToUnitOfInformation(BigInteger value, UnitsOfInformation from, UnitsOfInformation to) { bool fromIsBits = IsBits(from); bool toIsBits = IsBits(to); bool fromIsBytes = IsBytes(from); bool toIsBytes = IsBytes(to); // result in bits if (toIsBits) { // convert "from" to bits if bytes if (fromIsBytes) { value = BytesToBits(value); } // convert value "from" of any bit-unit to bits. value = AnyBitUnitToBits(value, from); // convert the bits to the "to" unit. return(BitsToAnyBitUnit(value, to) + " " + GetPrefix(to)); } // result in bytes if (toIsBytes) { // convert "from" to bytes if bits if (fromIsBits) { value = BitsToBytes(value); } // convert value "from" of any byte-unit to byte. value = AnyByteUnitToBytes(value, from); // convert the bytes to the "to" unit. return(BytesToAnyByteUnit(value, to) + " " + GetPrefix(to)); } // should never happen: return(value + " ???"); }
/// <summary>Converts the number to a unit of information.<para>Ansprechpartner: Henry de Jongh</para></summary> /// <param name="value">The value to convert.</param> /// <param name="from">The unit of information to convert from.</param> /// <param name="to">The unit of information to convert to.</param> /// <returns>The unit of information as string.</returns> public static string ToUnitOfInformation(this long value, UnitsOfInformation from, UnitsOfInformation to) => ConvertToUnitOfInformation(value, from, to);
private static BigInteger BytesToAppropriateByteUnit(BigInteger value, UnitsOfInformationRadix radix, out UnitsOfInformation uoi) { switch (radix) { case UnitsOfInformationRadix.Decimal: if (value < 1000) { uoi = UnitsOfInformation.bytes; return(value); } value /= 1000; if (value < 1000) { uoi = UnitsOfInformation.kilobyte; return(value); } value /= 1000; if (value < 1000) { uoi = UnitsOfInformation.megabyte; return(value); } value /= 1000; if (value < 1000) { uoi = UnitsOfInformation.gigabyte; return(value); } value /= 1000; if (value < 1000) { uoi = UnitsOfInformation.terabyte; return(value); } value /= 1000; if (value < 1000) { uoi = UnitsOfInformation.petabyte; return(value); } value /= 1000; if (value < 1000) { uoi = UnitsOfInformation.exabyte; return(value); } value /= 1000; if (value < 1000) { uoi = UnitsOfInformation.zettabyte; return(value); } value /= 1000; if (value < 1000) { uoi = UnitsOfInformation.yottabyte; return(value); } value /= 1000; uoi = UnitsOfInformation.bytes; return(value); case UnitsOfInformationRadix.Binary: if (value < 1024) { uoi = UnitsOfInformation.bytes; return(value); } value /= 1024; if (value < 1024) { uoi = UnitsOfInformation.kibibyte; return(value); } value /= 1024; if (value < 1024) { uoi = UnitsOfInformation.mebibyte; return(value); } value /= 1024; if (value < 1024) { uoi = UnitsOfInformation.gibibyte; return(value); } value /= 1024; if (value < 1024) { uoi = UnitsOfInformation.tebibyte; return(value); } value /= 1024; if (value < 1024) { uoi = UnitsOfInformation.pebibyte; return(value); } value /= 1024; if (value < 1024) { uoi = UnitsOfInformation.exbibyte; return(value); } value /= 1024; if (value < 1024) { uoi = UnitsOfInformation.zebibyte; return(value); } value /= 1024; if (value < 1024) { uoi = UnitsOfInformation.yobibyte; return(value); } value /= 1024; uoi = UnitsOfInformation.bytes; return(value); } uoi = UnitsOfInformation.bytes; return(value); }
/// <summary>Converts the number to a unit of information.<para>Ansprechpartner: Henry de Jongh</para></summary> /// <param name="value">The value to convert.</param> /// <param name="from">The unit of information to convert from.</param> /// <param name="to">The unit of information to convert to.</param> /// <returns>The unit of information as string.</returns> public static string ToUnitOfInformation(this float value, UnitsOfInformation from, UnitsOfInformation to) => ConvertToUnitOfInformation((BigInteger)value, from, to);
private static string GetPrefix(UnitsOfInformation uoi) { switch (uoi) { case UnitsOfInformation.bits: return("b"); case UnitsOfInformation.bytes: return("B"); case UnitsOfInformation.kilobit: return("Kbit"); // officially should be "kbit" case UnitsOfInformation.megabit: return("Mbit"); case UnitsOfInformation.gigabit: return("Gbit"); case UnitsOfInformation.terabit: return("Tbit"); case UnitsOfInformation.petabit: return("Pbit"); case UnitsOfInformation.exabit: return("Ebit"); case UnitsOfInformation.zettabit: return("Zbit"); case UnitsOfInformation.yottabit: return("Ybit"); case UnitsOfInformation.kibibit: return("Kibit"); case UnitsOfInformation.mebibit: return("Mibit"); case UnitsOfInformation.gibibit: return("Gibit"); case UnitsOfInformation.tebibit: return("Tibit"); case UnitsOfInformation.pebibit: return("Pibit"); case UnitsOfInformation.exbibit: return("Eibit"); case UnitsOfInformation.zebibit: return("Zibit"); case UnitsOfInformation.yobibit: return("Yibit"); case UnitsOfInformation.kilobyte: return("KB"); // officially should be "kB" case UnitsOfInformation.megabyte: return("MB"); case UnitsOfInformation.gigabyte: return("GB"); case UnitsOfInformation.terabyte: return("TB"); case UnitsOfInformation.petabyte: return("PB"); case UnitsOfInformation.exabyte: return("EB"); case UnitsOfInformation.zettabyte: return("ZB"); case UnitsOfInformation.yottabyte: return("YB"); case UnitsOfInformation.kibibyte: return("KiB"); case UnitsOfInformation.mebibyte: return("MiB"); case UnitsOfInformation.gibibyte: return("GiB"); case UnitsOfInformation.tebibyte: return("TiB"); case UnitsOfInformation.pebibyte: return("PiB"); case UnitsOfInformation.exbibyte: return("EiB"); case UnitsOfInformation.zebibyte: return("ZiB"); case UnitsOfInformation.yobibyte: return("YiB"); default: return("???"); } }
/// <summary>Converts the number to a unit of information.<para>Ansprechpartner: Henry de Jongh</para></summary> /// <param name="value">The value to convert.</param> /// <param name="from">The unit of information to convert from.</param> /// <param name="radix">The desired radix to use.</param> /// <returns>The unit of information as string.</returns> public static string ToUnitOfInformation(this ushort value, UnitsOfInformation from, UnitsOfInformationRadix radix) => ConvertToUnitOfInformation(value, from, radix);
/// <summary>Converts the number to a unit of information.<para>Ansprechpartner: Henry de Jongh</para></summary> /// <param name="value">The value to convert.</param> /// <param name="from">The unit of information to convert from.</param> /// <param name="radix">The desired radix to use.</param> /// <returns>The unit of information as string.</returns> public static string ToUnitOfInformation(this double value, UnitsOfInformation from, UnitsOfInformationRadix radix) => ConvertToUnitOfInformation((BigInteger)value, from, radix);