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));
}
