internal static string ConvertToSizeString(long size) { DataSizeUnit totalSizeUnit = SizeConverter.GetSuitableUnit(size); return(string.Format("{0:#0.##} {1}", SizeConverter.ConvertToSize( size, totalSizeUnit), SizeConverter.GetUnitString(totalSizeUnit))); }
/// <summary> /// Returns another <see cref="DataSize"/> object with the value converted in Bytes. /// </summary> private static ulong ToBytes(double value, DataSizeUnit unit) { if (value < 0) { return(0); } switch (unit) { case DataSizeUnit.Unknown: case DataSizeUnit.Byte: return((ulong)Math.Round(value)); case DataSizeUnit.Kilobyte: return((ulong)Math.Round(value) * 1024); case DataSizeUnit.Megabyte: return((ulong)Math.Round(value) * 1024 * 1024); case DataSizeUnit.Gigabyte: return((ulong)Math.Round(value) * 1024 * 1024 * 1024); case DataSizeUnit.Terabyte: return((ulong)Math.Round(value) * 1024 * 1024 * 1024 * 1024); default: throw new ArgumentOutOfRangeException(); } }
internal int Adapt(int value, DataSizeUnit unit) { switch (unit) { case DataSizeUnit.KiB: return(value * 1024); case DataSizeUnit.MiB: return(value * 1024 * 1024); case DataSizeUnit.GiB: return(value * 1024 * 1024 * 1024); } return(0); }
static string GetUnitString(DataSizeUnit unit) { switch (unit) { case DataSizeUnit.Bytes: return("bytes"); case DataSizeUnit.KiloBytes: return("KB"); case DataSizeUnit.MegaBytes: return("MB"); case DataSizeUnit.GigaBytes: return("GB"); } return(string.Empty); }
/// <summary> /// Parses the specified text and creates a <see cref="DataSize"/> object with the obtained values. /// </summary> public static DataSize Parse(string text) { Match match = Regex.Match(text); if (!match.Success) { throw new ArgumentException("The text is not a string representation of a data size.", nameof(text)); } double value = double.Parse(match.Groups[1].Value); DataSizeUnit unit = ParseUnit(match.Groups[2].Value); return(new DataSize(value, unit)); }
public static long GetFactor(this DataSizeUnit unit) { switch (unit) { case DataSizeUnit.BYTE: { return(1); } case DataSizeUnit.KILOBYTE: { return(1 << 10); } case DataSizeUnit.MEGABYTE: { return(1 << 20); } case DataSizeUnit.GIGABYTE: { return(1 << 30); } case DataSizeUnit.TERABYTE: { return(1 << 40); } case DataSizeUnit.PETABYTE: { return(1 << 50); } case DataSizeUnit.EXABYTE: { return(1 << 60); } default: { throw new ArgumentException($"The unit {unit} is unknown."); } } }
public DataSize ConvertToMostSuccinctDataSize() { DataSizeUnit UnitToUse = DataSizeUnit.BYTE; foreach (DataSizeUnit UnitToTest in Enum.GetValues(typeof(DataSizeUnit))) { if (this.GetValue(UnitToTest) >= 1.0) { UnitToUse = UnitToTest; } else { break; } } return(this.ConvertTo(UnitToUse)); }
public DataSize(double size, DataSizeUnit unit) { if (Double.IsInfinity(size)) { throw new ArgumentOutOfRangeException("size", "The size is infinity."); } if (Double.IsNaN(size)) { throw new ArgumentOutOfRangeException("size", "The size is NaN."); } if (size < 0) { throw new ArgumentOutOfRangeException("size", "The size is less than 0."); } this.Size = size; this.Unit = unit; }
protected override void ProcessRecord() { string displayAs; DataSizeUnit convertFrom = ToDataEnum(_fromUnit); if (_toUnit.ToUpperInvariant() == "AUTO") { displayAs = ConvertDataUnit(_inputObject, convertFrom, _exact, _precisionLevel); } else { DataSizeUnit convertTo = ToDataEnum(_toUnit); displayAs = ConvertDataUnit(_inputObject, convertFrom, convertTo, _exact, _precisionLevel); } string unitName = displayAs.Substring(displayAs.LastIndexOf(" ") + 1); if (unitName == "Bits" || unitName == "Bytes") { unitName = unitName.TrimEnd('s'); } double convertToValue; if (double.TryParse(displayAs.Substring(0, displayAs.LastIndexOf(" ")), out convertToValue)) { PSObject responseObj = new PSObject(); responseObj.Members.Add(new PSNoteProperty("DisplayAs", displayAs.Substring(0, displayAs.LastIndexOf(" ")) + unitName)); responseObj.Members.Add(new PSNoteProperty("Unit", unitName)); responseObj.Members.Add(new PSNoteProperty("Value", convertToValue)); base.WriteObject(responseObj); } else { // this shouldn't happen throw new InvalidOperationException(RS.InternalError); } }
/// <summary> /// Returns a string representation of the size converted in the specified measurement unit. /// </summary> public string ToString(DataSizeUnit unit) { switch (unit) { case DataSizeUnit.Unknown: case DataSizeUnit.Byte: return(string.Format("{0:N0} B", Value)); case DataSizeUnit.Kilobyte: return(string.Format("{0:N0} KB", Kilobytes)); case DataSizeUnit.Megabyte: return(string.Format("{0:N0} MB", Megabytes)); case DataSizeUnit.Gigabyte: return(string.Format("{0:N0} GB", Gigabytes)); case DataSizeUnit.Terabyte: return(string.Format("{0:N0} TB", Terabytes)); default: throw new ArgumentOutOfRangeException(nameof(unit), unit, null); } }
private double To(DataSizeUnit unit) { switch (unit) { case DataSizeUnit.Unknown: case DataSizeUnit.Byte: return(Value); case DataSizeUnit.Kilobyte: return(Kilobytes); case DataSizeUnit.Megabyte: return(Megabytes); case DataSizeUnit.Gigabyte: return(Gigabytes); case DataSizeUnit.Terabyte: return(Terabytes); default: throw new ArgumentOutOfRangeException(nameof(unit), unit, null); } }
/// <summary> /// Returns another <see cref="DataSize"/> object with the value converted in Bytes. /// </summary> private static ulong ToBytes(ulong value, DataSizeUnit unit) { switch (unit) { case DataSizeUnit.Unknown: case DataSizeUnit.Byte: return(value); case DataSizeUnit.Kilobyte: return(value * 1024); case DataSizeUnit.Megabyte: return(value * 1024 * 1024); case DataSizeUnit.Gigabyte: return(value * 1024 * 1024 * 1024); case DataSizeUnit.Terabyte: return(value * 1024 * 1024 * 1024 * 1024); default: throw new ArgumentOutOfRangeException(); } }
/// <summary> /// Returns a string representation of the size converted in the specified measurement unit. /// </summary> public string ToString(DataSizeUnit unit) { switch (unit) { case DataSizeUnit.Unknown: case DataSizeUnit.Byte: return($"{Value:N0} B"); case DataSizeUnit.Kilobyte: return($"{Kilobytes:N0} KB"); case DataSizeUnit.Megabyte: return($"{Megabytes:N0} MB"); case DataSizeUnit.Gigabyte: return($"{Gigabytes:N0} GB"); case DataSizeUnit.Terabyte: return($"{Terabytes:N0} TB"); default: throw new ArgumentOutOfRangeException(nameof(unit), unit, null); } }
public static DataSize SuccinctDataSize(double size, DataSizeUnit unit) { return(new DataSize(size, unit).ConvertToMostSuccinctDataSize()); }
private string ConvertDataUnitCore(double size, DataSizeUnit fromUnit, bool autoConvert, DataSizeUnit toUnit, bool strict = true, int precision = 0) { double szMulti = 0; switch (fromUnit) { case DataSizeUnit.YB: szMulti = (double)(strict ? DataYib : DataYb); break; case DataSizeUnit.ZB: szMulti = (double)(strict ? DataZib : DataZb); break; case DataSizeUnit.EB: szMulti = (double)(strict ? DataEib : DataEb); break; case DataSizeUnit.PB: szMulti = (double)(strict ? DataPib : DataPb); break; case DataSizeUnit.TB: szMulti = (double)(strict ? DataTib : DataTb); break; case DataSizeUnit.GB: szMulti = (double)(strict ? DataGib : DataGb); break; case DataSizeUnit.MB: szMulti = (double)(strict ? DataMib : DataMb); break; case DataSizeUnit.KB: szMulti = (double)(strict ? DataKib : DataKb); break; case DataSizeUnit.Byte: szMulti = (double)DataByte; break; case DataSizeUnit.Bit: szMulti = (double)DataBit; break; default: throw new ArgumentOutOfRangeException(nameof(fromUnit)); } double toBase = 0; string resultUnit = "Bit"; if (!autoConvert) { switch (toUnit) { case DataSizeUnit.YB: toBase = (double)(strict ? DataYib : DataYb); break; case DataSizeUnit.ZB: toBase = (double)(strict ? DataZib : DataZb); break; case DataSizeUnit.EB: toBase = (double)(strict ? DataEib : DataEb); break; case DataSizeUnit.PB: toBase = (double)(strict ? DataPib : DataPb); break; case DataSizeUnit.TB: toBase = (double)(strict ? DataTib : DataTb); break; case DataSizeUnit.GB: toBase = (double)(strict ? DataGib : DataGb); break; case DataSizeUnit.MB: toBase = (double)(strict ? DataMib : DataMb); break; case DataSizeUnit.KB: toBase = (double)(strict ? DataKib : DataKb); break; case DataSizeUnit.Byte: toBase = (double)DataByte; break; case DataSizeUnit.Bit: toBase = (double)DataBit; break; default: throw new ArgumentOutOfRangeException(nameof(toUnit)); } resultUnit = toUnit.ToString(); } double sizeBytes = size * szMulti; if (autoConvert) { if (sizeBytes < DataByte) { toBase = DataBit; resultUnit = "Bit"; } else if (sizeBytes < (strict ? DataKib : DataKb)) { toBase = DataByte; resultUnit = DataSizeUnit.Byte.ToString(); } else if (sizeBytes < (strict ? DataMib : DataMb)) { toBase = strict ? DataKib : DataKb; resultUnit = DataSizeUnit.KB.ToString(); } else if (sizeBytes < (strict ? DataGib : DataGb)) { toBase = strict ? DataMib : DataMb; resultUnit = DataSizeUnit.MB.ToString(); } else if (sizeBytes < (strict ? DataTib : DataTb)) { toBase = strict ? DataGib : DataGb; resultUnit = DataSizeUnit.GB.ToString(); } else if (sizeBytes < (strict ? DataPib : DataPb)) { toBase = strict ? DataTib : DataTb; resultUnit = DataSizeUnit.TB.ToString(); } else if (sizeBytes < (strict ? DataEib : DataEb)) { toBase = strict ? DataPib : DataPb; resultUnit = DataSizeUnit.PB.ToString(); } else if (sizeBytes < (strict ? DataZib : DataZb)) { toBase = strict ? DataEib : DataEb; resultUnit = DataSizeUnit.EB.ToString(); } else if (sizeBytes < (strict ? DataYib : DataYb)) { toBase = strict ? DataZib : DataZb; resultUnit = DataSizeUnit.ZB.ToString(); } else { toBase = strict ? DataYib : DataYb; resultUnit = DataSizeUnit.YB.ToString(); } } double result = sizeBytes / toBase; if ((resultUnit == "Bit" || resultUnit == "Byte") && (result > 1)) { resultUnit = resultUnit + "s"; } if (precision < 1) { return(string.Format("{0:#,#.##} {1}", result, resultUnit)); } else { return(string.Format("{0:N" + precision.ToString() + "} {1}", result, resultUnit)); } }
internal static float ConvertToSize(long size, DataSizeUnit unit) { return((float)size / (float)unit); }
private static long GetMultiplier(DataSizeUnit unit) { return(1L << (10 * (int)unit)); }
/// <summary> /// converts the current value into /// </summary> /// <param name="unit"></param> /// <returns></returns> public Decimal ConvertTo(DataSizeUnit unit) { return(Decimal.Divide(this.bytes, GetMultiplier(unit))); }
/// <summary> /// Loads an amount of bytes /// </summary> /// <param name="unit">unit to load</param> /// <param name="value">bytes to load</param> public static DataSize GetFrom(Decimal value, DataSizeUnit unit = DataSizeUnit.Byte) { return(new DataSize(Decimal.ToUInt64(value * GetMultiplier(unit)))); }
/// <summary> /// Loads an amount of bytes /// </summary> /// <param name="unit">unit to load</param> /// <param name="value">bytes to load</param> public static DataSize GetFrom(ulong value, DataSizeUnit unit = DataSizeUnit.Byte) { return(new DataSize(value * (ulong)GetMultiplier(unit))); }
public static string GetUnitString(this DataSizeUnit unit) { return(unit.GetType().GetCustomAttribute <DescriptionAttribute>().Description); }
/// <summary> /// Convert into value with unit /// </summary> /// <param name="unit">the selected unit</param> /// <returns>the format string</returns> public string GetString(DataSizeUnit unit) { return(string.Format("{0:0.###} {1}", this.ConvertTo(unit), unit)); }
public DataSize ConvertTo(DataSizeUnit unit) { return(new DataSize(this.GetValue(unit), unit)); }
public double GetValue(DataSizeUnit unit) { return(this.Size * (this.Unit.GetFactor() * (1.0 / unit.GetFactor()))); }
/// <summary> /// Initializes a new instance of the <see cref="DataSize"/> struct. /// </summary> public DataSize(ulong value, DataSizeUnit unit = DataSizeUnit.Byte) { Value = ToBytes(value, unit); }
/// <summary> /// Initializes a new instance of the <see cref="DataSize"/> struct. /// </summary> public DataSize(double value, DataSizeUnit unit = DataSizeUnit.Byte) { Value = ToBytes(value, unit); }
private string ConvertDataUnit(double size, DataSizeUnit fromUnit, DataSizeUnit toUnit, bool strict = true, int precision = 0) { return(ConvertDataUnitCore(size, fromUnit, false, toUnit, strict, precision)); }