public FileSize(long size)
{
this.size = size;
this.unit = FileSizeUnit.Auto;
calculatedSize = calculate(this.size, this.unit, out calculatedUnit);
}
/// <inheritdoc/>
public double GetFileSize(FileSizeUnit fileSizeUnit = FileSizeUnit.Byte)
{
double power = ((int)fileSizeUnit);
double divisor = Math.Pow(1024.0d, power);
return(RawFileSize / divisor);
}
public static string FileSizeUnitToString(FileSizeUnit fsu)
{
switch (fsu)
{
case FileSizeUnit.Byte:
return("Byte");
case FileSizeUnit.Kilobyte:
return("Kilobyte");
case FileSizeUnit.Megabyte:
return("Megabyte");
case FileSizeUnit.Gigabyte:
return("Gigabyte");
case FileSizeUnit.Terabyte:
return("Terabyte");
case FileSizeUnit.Petabyte:
return("Petabyte");
case FileSizeUnit.Exabyte:
return("Exabyte");
case FileSizeUnit.Zettabyte:
return("Zettabyte");
}
return(string.Empty);
}
/// <summary>
/// 将B单位转换为1024内的长度
/// </summary>
/// <param name="fileSizeForBytes">文件字节长度</param>
/// <param name="fileSizeUnit">单位类型</param>
/// <returns></returns>
public static string ChangeFileSizeUnit2Decimal(this long fileSizeForBytes, FileSizeUnit fileSizeUnit)
{
decimal fileSizeUnitResult = 0M;
switch (fileSizeUnit)
{
case FileSizeUnit.KB:
fileSizeUnitResult = fileSizeForBytes / 1024M;
break;
case FileSizeUnit.MB:
fileSizeUnitResult = fileSizeForBytes / (1024M * 1024M);
break;
case FileSizeUnit.GB:
fileSizeUnitResult = fileSizeForBytes / (1024M * 1024M * 1024M);
break;
case FileSizeUnit.TB:
fileSizeUnitResult = fileSizeForBytes / (1024M * 1024M * 1024M * 1024M);
break;
}
return(fileSizeUnitResult.ToString("F2"));
}
/// <summary>
/// Get corresponding file size string representation value based on specific parameters.
/// </summary>
/// <param name="size">File size.</param>
/// <param name="unit">File size measuring unit.</param>
/// <param name="precision">Measuring precision.</param>
/// <returns>String representation of file size.</returns>
private static string GetStringValue(long size, FileSizeUnit unit, FileSizePrecision precision)
{
// Force using "CultureInfo.CurrentCulture" instead of "culture.NumberFormat".
// Note: "culture.NumberFormat" is the same as "CultureInfo.CurrentUICulture".
switch (unit)
{
case FileSizeUnit.TeraByte:
return(string.Format(
string.Format("{0} {1}", FileSizeUtility.Format[precision], FileSizeUtility.TBYTE),
(decimal)size / FileSizeUtility.Size[FileSizeUnit.TeraByte]));
case FileSizeUnit.GigaByte:
return(string.Format(
string.Format("{0} {1}", FileSizeUtility.Format[precision], FileSizeUtility.GBYTE),
(decimal)size / FileSizeUtility.Size[FileSizeUnit.GigaByte]));
case FileSizeUnit.MegaByte:
return(string.Format(
string.Format("{0} {1}", FileSizeUtility.Format[precision], FileSizeUtility.MBYTE),
(decimal)size / FileSizeUtility.Size[FileSizeUnit.MegaByte]));
case FileSizeUnit.KiloByte:
return(string.Format(
string.Format("{0} {1}", FileSizeUtility.Format[precision], FileSizeUtility.KBYTE),
(decimal)size / FileSizeUtility.Size[FileSizeUnit.KiloByte]));
default: // FileSizeUnit.Byte
return(string.Format(
string.Format("{0} {1}", FileSizeUtility.Format[precision], FileSizeUtility.BYTE), (decimal)size));
}
}
/// <summary>
/// Short ToString of FileSizeUnit
/// </summary>
/// <param name="unit">Unit to string</param>
/// <returns>Shortcut of unit</returns>
public string ShortUnitForm(FileSizeUnit unit)
{
switch (unit)
{
case FileSizeUnit.Unknown:
return(string.Empty);
case FileSizeUnit.Bit:
return("b");
case FileSizeUnit.Byte:
return("B");
case FileSizeUnit.KiloByte:
return("kB");
case FileSizeUnit.MegaByte:
return("MB");
case FileSizeUnit.GigaByte:
return("GB");
case FileSizeUnit.TeraByte:
return("TB");
case FileSizeUnit.PetaByte:
return("PB");
default:
throw new NotImplementedException("There is no such unit");
}
}
/// <summary>
/// 获取文件大小
/// </summary>
/// <param name="length">长度：字节</param>
/// <param name="unit">单位，枚举：FileSizeUnit</param>
/// <returns></returns>
public static string GetFileSize(decimal length, FileSizeUnit unit = FileSizeUnit.KB)
{
decimal num = 0m;
switch (unit)
{
case FileSizeUnit.TB:
num = Math.Round((decimal)(length / (1024m * 1024m * 1024m * 1024m)), 2, MidpointRounding.AwayFromZero);
break;
case FileSizeUnit.GB:
num = Math.Round((decimal)(length / (1024m * 1024m * 1024m)), 2, MidpointRounding.AwayFromZero);
break;
case FileSizeUnit.MB:
num = Math.Round((decimal)(length / (1024m * 1024m)), 2, MidpointRounding.AwayFromZero);
break;
case FileSizeUnit.KB:
default:
num = Math.Round((decimal)(length / 1024m), 2, MidpointRounding.AwayFromZero);
break;
}
return(num.ToString() + unit.ToString());
}
/// <summary>
/// Round up size to specified unit
/// </summary>
/// <param name="fileSizeUnit">New FileSizeUnit</param>
private void UnitUp(FileSizeUnit upUnit)
{
while (unit != upUnit && unit < FileSizeUnit.PetaByte)
{
size /= 1024.0;
++unit;
}
}
/// <summary>
/// Genarate empty file/files but in new thread.
/// </summary>
/// <param name="count"> number of files (a negetive number for filling the drive)</param>
/// <param name="Unit">B or KB or MG or GB</param>
/// <param name="onEnd"> this will run at the end</param>
public void FileGen(int count, FileSizeUnit Unit, Action onEnd)
{
new Thread(() =>
{
FileGen(count, Unit);
onEnd();
}).Start();
}
private static Boolean DiscriminateFile(this FileInfo fileInfo, Int64 lowerBound, Int64 upperBound, FileSizeUnit fileSizeUnit = FileSizeUnit.Byte)
{
switch (fileSizeUnit)
{
case FileSizeUnit.Byte: return fileInfo.Length.IsBetween(lowerBound, upperBound);
default: throw new ArgumentException(nameof(fileSizeUnit));
}
}
protected override long GetItemValue(string name, int id, bool isNew, MessageDisplay msgDisplay, out bool hasError)
{
hasError = false;
string valueName, filetypeName;
if (isNew)
{
valueName = "new_" + name + "_value";
filetypeName = "new_" + name + "_filesize";
}
else
{
valueName = name + "_value_" + id;
filetypeName = name + "_filesize_" + id;
}
string valueString = _Request.Get(valueName, Method.Post, string.Empty);
long tempValue;
if (long.TryParse(valueString, out tempValue) == false)
{
hasError = true;
if (isNew)
{
msgDisplay.AddError("new_" + name, "大小必须为整数");
}
else
{
msgDisplay.AddError(name, id, "大小必须为整数");
}
return(0);
}
//long tempValue = long.Parse(value.ToString());
string errors = CheckValue(tempValue);
if (errors != null)
{
hasError = true;
if (isNew)
{
msgDisplay.AddError("new_" + name, errors);
}
else
{
msgDisplay.AddError(name, id, errors);
}
return(0);
}
FileSizeUnit fileSizeUnit = _Request.Get <FileSizeUnit>(filetypeName, Method.Post, FileSizeUnit.K);
return(ConvertUtil.GetFileSize(tempValue, fileSizeUnit));
}
/// <summary>
/// Format a size to a specific unit
/// </summary>
/// <param name="size">The size</param>
/// <param name="unit">The unit</param>
/// <returns></returns>
public static string FormatToUnit(decimal size, FileSizeUnit unit)
{
decimal sizeConverted = ConvertToUnit(size, unit);
decimal sizeRounded = 0;
if (unit == FileSizeUnit.KB)
sizeRounded = Math.Round(sizeConverted, 0);
else
sizeRounded = Math.Round(sizeConverted, 2);
return String.Format("{0} {1}", sizeRounded, unit);
}
public FileServiceConfig(MimeTypeHelper.GetMimeTypeDelegate getMimeTypeDelegate, double maxUploadSize, FileSizeUnit fileSizeUnit, string rootDirectory, params string[] allowedExtensions)
{
GetMimeType = getMimeTypeDelegate;
MaxUploadSize = maxUploadSize;
FileSizeUnit = fileSizeUnit;
RootDirectory = rootDirectory;
Rules = new RuleContainer();
Rules.AddRule <FileSizeLimitRule>();
Rules.AddRule <FileExtensionValidationRule>();
AllowedExtensions = allowedExtensions;
}
public static string ToFileSize(this ulong nbBytes, FileSizeUnit unit = FileSizeUnit.BINARY)
{
foreach (var unitRange in _unitRanges)
{
if (nbBytes < unitRange.GetThreshold(unit))
{
return(unitRange.ToString(nbBytes, unit));
}
}
return(_unitRanges.LastOrDefault()?.ToString(nbBytes, unit) ?? nbBytes.ToString());
}
/// <summary>
/// 初始化文件大小
/// </summary>
/// <param name="size">文件大小</param>
/// <param name="unit">文件大小单位</param>
public FileSize(long size, FileSizeUnit unit = FileSizeUnit.Byte)
{
switch (unit)
{
case FileSizeUnit.K:
Size = size * 1024; break;
case FileSizeUnit.M:
Size = size * 1024 * 1024; break;
case FileSizeUnit.G:
Size = size * 1024 * 1024 * 1024; break;
default:
Size = size; break;
}
}
/// <summary>Converts a file-size in the give unit to a different unit.</summary>
/// <param name="sourceUnit">The source unit the 'value' is currently in.</param>
/// <param name="targetUnit">The unit to convert to.</param>
/// <param name="value">The file-size value to convert.</param>
public static double ConvertTo(this FileSizeUnit sourceUnit, FileSizeUnit targetUnit, double value)
{
// Setup initial conditions.
var bytes = sourceUnit.ToBytes(value);
// Perform conversion.
const int multiplier = 1024;
if (targetUnit == FileSizeUnit.Byte) return bytes;
if (targetUnit == FileSizeUnit.Kilobyte) return bytes / multiplier;
if (targetUnit == FileSizeUnit.Megabyte) return bytes / multiplier / multiplier;
if (targetUnit == FileSizeUnit.Gigabyte) return bytes / multiplier / multiplier / multiplier;
if (targetUnit == FileSizeUnit.Terabyte) return bytes / multiplier / multiplier / multiplier / multiplier;
throw new NotSupportedException(targetUnit.ToString());
}
public static long GetFileSize(long value, FileSizeUnit fileSizeUnit)
{
switch (fileSizeUnit)
{
case FileSizeUnit.B: return(value);
case FileSizeUnit.K: return(value * 1024);
case FileSizeUnit.M: return(value * 1024 * 1024);
case FileSizeUnit.G: return(value * 1024 * 1024 * 1024);
default: return(value * 1024 * 1024 * 1024 * 1024);
}
}
/// <summary>
/// Format a size to a specific unit
/// </summary>
/// <param name="size">The size</param>
/// <param name="unit">The unit</param>
/// <returns></returns>
public static string FormatToUnit(decimal size, FileSizeUnit unit)
{
decimal sizeConverted = ConvertToUnit(size, unit);
decimal sizeRounded = 0;
if (unit == FileSizeUnit.KB)
{
sizeRounded = Math.Round(sizeConverted, 0);
}
else
{
sizeRounded = Math.Round(sizeConverted, 2);
}
return(String.Format("{0} {1}", sizeRounded, unit));
}
public static string ToUnitString(FileSizeMode mode, FileSizeUnit unit)
{
if (mode == FileSizeMode.Binary && unit != FileSizeUnit.Bytes)
{
var str = unit.ToString();
var index = str.IndexOf('B');
return(str.Insert(index, "i"));
}
else if (mode == FileSizeMode.SI)
{
return(unit.ToString());
}
return(unit.ToString());
}
/// <summary>
/// 获取文件大小
/// </summary>
private static long GetSize(long size, FileSizeUnit unit)
{
switch (unit)
{
case FileSizeUnit.K:
return(size * 1024);
case FileSizeUnit.M:
return(size * 1024 * 1024);
case FileSizeUnit.G:
return(size * 1024 * 1024 * 1024);
default:
return(size);
}
}
/// <summary>
/// ctor
/// </summary>
/// <param name="bytes">File size</param>
/// <param name="isDir">Is directory</param>
private FileSize(long bytes)
{
if (bytes < 0)
throw new ArgumentException("File size must be grater than 0");
else if (bytes == 0)
{
size = 0;
unit = FileSizeUnit.Byte;
}
else
{
unit = FileSizeUnit.Byte;
size = bytes;
RecomputeSize();
}
}
public double FileSizeConverter(double size, FileSizeUnit unit)
{
double result = 0;
if (size > 0)
{
if (unit == FileSizeUnit.Megabyte)
{
result = size * 1024 * 1024;
}
else if (unit == FileSizeUnit.Gigabyte)
{
result = size * 1024 * 1024 * 1024;
}
}
return result;
}
public double FileSizeConverter(double size, FileSizeUnit unit)
{
double result = 0;
if (size > 0)
{
if (unit == FileSizeUnit.Megabyte)
{
result = size * 1024 * 1024;
}
else if (unit == FileSizeUnit.Gigabyte)
{
result = size * 1024 * 1024 * 1024;
}
}
return(result);
}
/// <summary>
/// Copies the file size of all selected listview items.
/// </summary>
public void CopySelectedItemsSize(FileSizeUnit size, int decimalPlaces = 1)
{
FileInfo info;
if (folderView1.ListView_.SelectedIndices.Count < 2)
{
if (folderView1.ListView_.FocusedItem == null)
{
return;
}
if (folderView1.ListView_.FocusedItem.Tag is DirectoryInfo)
{
ClipboardHelper.CopyStringDefault("Unknown Folder Size");
return;
}
else if (folderView1.ListView_.FocusedItem.Tag is FileInfo)
{
info = (FileInfo)(folderView1.ListView_.FocusedItem.Tag);
ClipboardHelper.CopyStringDefault(Helper.SizeSuffix(info.Length, size, decimalPlaces));
}
return;
}
StringBuilder paths = new StringBuilder();
int i = 0;
foreach (int ii in folderView1.ListView_.SelectedIndices)
{
if (folderView1.ListView_.Items[ii].Tag is DirectoryInfo)
{
paths.AppendLine("Unknown Folder Size");
}
else if (folderView1.ListView_.Items[ii].Tag is FileInfo)
{
info = (FileInfo)(folderView1.ListView_.Items[ii].Tag);
ClipboardHelper.CopyStringDefault(Helper.SizeSuffix(info.Length, size, decimalPlaces));
paths.AppendLine(Helper.SizeSuffix(info.Length, size, decimalPlaces));
}
i++;
}
ClipboardHelper.CopyStringDefault(paths.ToString());
}
public static void PrepareLocalFile(string filePath, long fileSizeInUnit, FileSizeUnit fileSizeUnit)
{
if (FileSizeUnit.B == fileSizeUnit)
{
Helper.GenerateFileInBytes(filePath, fileSizeInUnit);
}
else if (FileSizeUnit.KB == fileSizeUnit)
{
Helper.GenerateFileInKB(filePath, fileSizeInUnit);
}
else if (FileSizeUnit.MB == fileSizeUnit)
{
Helper.GenerateFileInMB(filePath, fileSizeInUnit);
}
else
{
Helper.GenerateFileInGB(filePath, fileSizeInUnit);
}
}
private static void AssertRangeOfBytesReturnsCorrectReadableSize(FileSizeUnit fileSizeUnit)
{
var bytesToTest = new List <ulong>
{
fileSizeUnit.Size,
fileSizeUnit.Size + 1,
fileSizeUnit.Size * 2,
fileSizeUnit.Size * 500,
fileSizeUnit.Size * 1023,
(fileSizeUnit.Size * 1024) - 1,
};
foreach (var numberOfBytes in bytesToTest)
{
string readableSize = DataHelper.GetReadableSize(numberOfBytes);
StringAssert.EndsWith(fileSizeUnit.Suffix, readableSize, "{0} should've been used for {1} bytes.", fileSizeUnit.Suffix, numberOfBytes);
}
}
/// <summary>
/// ctor
/// </summary>
/// <param name="bytes">File size</param>
/// <param name="isDir">Is directory</param>
private FileSize(long bytes)
{
if (bytes < 0)
{
throw new ArgumentException("File size must be grater than 0");
}
else if (bytes == 0)
{
size = 0;
unit = FileSizeUnit.Byte;
}
else
{
unit = FileSizeUnit.Byte;
size = bytes;
RecomputeSize();
}
}
/// <summary>
/// Converts a size to a filesize string
/// </summary>
/// <param name="size">original size</param>
/// <param name="target">target unit</param>
/// <param name="given">original unit, Byte is default</param>
/// <param name="stringFormat">Format-String for the Number output. Default is {0:0.##}</param>
/// <returns></returns>
public static string FormatFilesize(this long size, FileSizeUnit target = FileSizeUnit.Auto, FileSizeUnit given = FileSizeUnit.Byte, string stringFormat = "{0:0.##}")
{
string[] unit = new string[] { "", "B", "KB", "MB", "GB", "TB", "PB", "EB" };
given = given == FileSizeUnit.Auto ? (FileSizeUnit)1 : given; //Auto == Byte for given bytes
long sizeinbyte = (long)(size * Math.Pow(1024, (int)given - 1)); //size in byte
int steps = (int)Math.Floor(Math.Log(sizeinbyte, 1024)); //number of 1024er steps inside s (lower bound)
int upper = (int)target;
if (upper == int.MaxValue)
{
upper = steps + 1;
}
double res = sizeinbyte * Math.Pow(1024, -(upper - 1));
return(string.Format(stringFormat + " {1}", res, unit[upper]));
}
/// <summary>
/// Automatically format a size
/// </summary>
/// <param name="size">The size</param>
/// <returns></returns>
public static string Format(decimal size)
{
// return "Unknow" resource string if < 0
if (size < 0)
{
return("N/A");
}
FileSizeUnit unit = FileSizeUnit.TB; // must be last item of FileSizeUnit enum
for (decimal UnitSize = 1024; UnitSize <= (long)FileSizeUnit.TB; UnitSize *= 1024)
{
if (size < UnitSize)
{
unit = (FileSizeUnit)(long)(UnitSize / 1024);
break;
}
}
return(FormatToUnit(size, unit));
}
/// <summary>
/// 根据指定的文件大小单位，对输入的文件大小（字节表示）进行转换。
/// </summary>
/// <param name="filesize">文件文件大小，单位为字节。</param>
/// <param name="targetUnit">目标单位。</param>
/// <returns></returns>
public static double ToFileFormat(long filesize, FileSizeUnit targetUnit = FileSizeUnit.MB)
{
double size = -1;
switch (targetUnit)
{
case FileSizeUnit.KB: size = filesize / 1024.0; break;
case FileSizeUnit.MB: size = filesize / 1024.0 / 1024; break;
case FileSizeUnit.GB: size = filesize / 1024.0 / 1024 / 1024; break;
case FileSizeUnit.TB: size = filesize / 1024.0 / 1024 / 1024 / 1024; break;
case FileSizeUnit.PB: size = filesize / 1024.0 / 1024 / 1024 / 1024 / 1024; break;
default: size = filesize; break;
}
return(size);
}
public static string GetString(this Lang la, FileSizeUnit unit)
{
var result = "";
if (la is LangFa)
{
switch (unit)
{
case FileSizeUnit.Byte: result = "بایت"; break;
case FileSizeUnit.KiloByte: result = "کیلو بایت"; break;
case FileSizeUnit.MegaByte: result = "مگا بایت"; break;
case FileSizeUnit.GigaByte: result = "گیگا بایت"; break;
case FileSizeUnit.TeraByte: result = "ترا بایت"; break;
default: result = ""; break;
}
}
else
{
switch (unit)
{
case FileSizeUnit.Byte: result = "byte"; break;
case FileSizeUnit.KiloByte: result = "KB"; break;
case FileSizeUnit.MegaByte: result = "MB"; break;
case FileSizeUnit.GigaByte: result = "GB"; break;
case FileSizeUnit.TeraByte: result = "TB"; break;
default: result = ""; break;
}
}
return(result);
}
public static double ToFileSize(double size, FileSizeMode mode, out FileSizeUnit unit)
{
var factor = (int)mode;
var fileSize = size;
var units = EnumUtils.Values <FileSizeUnit>();
int count = 0;
while (true)
{
if (count + 1 >= units.Length || fileSize < factor)
{
break;
}
fileSize /= factor;
count++;
}
unit = units[count];
return(fileSize);
}
public static string SizeSuffix(Int64 value, FileSizeUnit fsu, int decimalPlaces = 1)
{
if (decimalPlaces < 0)
{
throw new ArgumentOutOfRangeException("decimalPlaces");
}
if (value < 0)
{
return("-" + SizeSuffix(-value, fsu, decimalPlaces));
}
if (value == 0)
{
return(string.Format("{0:n" + decimalPlaces + "} {1}", 0, SizeSuffixes[(int)fsu]));
}
int mag = (int)fsu;
// 1L << (mag * 10) == 2 ^ (10 * mag)
// [i.e. the number of bytes in the unit corresponding to mag]
double adjustedSize = (double)value / (1L << (mag * 10));
return(string.Format("{0:n" + decimalPlaces + "} {1}", adjustedSize, SizeSuffixes[mag]));
}
private void CopySelectedFileSize_Click(object sender, EventArgs e)
{
FileSizeUnit fsu = (FileSizeUnit)((ToolStripItem)sender).Tag;
switch (fsu)
{
case FileSizeUnit.Byte:
CopySelectedItemsSize(fsu, 0);
return;
case FileSizeUnit.Kilobyte:
CopySelectedItemsSize(fsu, 0);
return;
case FileSizeUnit.Megabyte:
CopySelectedItemsSize(fsu, 1);
return;
case FileSizeUnit.Gigabyte:
CopySelectedItemsSize(fsu, 2);
return;
case FileSizeUnit.Terabyte:
CopySelectedItemsSize(fsu, 3);
return;
case FileSizeUnit.Petabyte:
CopySelectedItemsSize(fsu, 4);
return;
case FileSizeUnit.Exabyte:
CopySelectedItemsSize(fsu, 5);
return;
case FileSizeUnit.Zettabyte:
CopySelectedItemsSize(fsu, 6);
return;
}
}
private void ComputeDecimalRepresentation()
{
if (length < 10)
{
Size = length;
Unit = FileSizeUnit.Byte;
}
else if (length < 100 * (double)FileSizeUnit.kB)
{
Size = length / (double)FileSizeUnit.kB;
Unit = FileSizeUnit.kB;
}
else if (length < 100 * (double)FileSizeUnit.MB)
{
Size = length / (double)FileSizeUnit.MB;
Unit = FileSizeUnit.MB;
}
else
{
Size = length / (double)FileSizeUnit.GB;
Unit = FileSizeUnit.GB;
}
}
/// <summary>
/// Convert bytes to unit (KB or MB...)
/// </summary>
/// <param name="size">The size</param>
/// <param name="unit">The unit</param>
/// <returns></returns>
public static decimal ConvertToUnit(decimal size, FileSizeUnit unit)
{
return size / (decimal)unit;
}
public static List<string> GenerateFileWithAttributes(
string folder,
string filePrefix,
int number,
List<FileAttributes> includeAttributes,
List<FileAttributes> excludeAttributes,
int fileSizeInUnit = 1,
FileSizeUnit unit = FileSizeUnit.KB)
{
List<string> fileNames = new List<string>(number);
for (int i = 0; i < number; i++)
{
string fileName = filePrefix + i.ToString();
string filePath = Path.Combine(folder, fileName);
fileNames.Add(fileName);
DMLibTestHelper.PrepareLocalFile(filePath, fileSizeInUnit, unit);
if (includeAttributes != null)
foreach (FileAttributes fa in includeAttributes)
FileOp.SetFileAttribute(filePath, fa);
if (excludeAttributes != null)
foreach (FileAttributes fa in excludeAttributes)
FileOp.RemoveFileAttribute(filePath, fa);
}
return fileNames;
}
public static long GetFileSize(long value,FileSizeUnit fileSizeUnit)
{
switch (fileSizeUnit)
{
case FileSizeUnit.B: return value;
case FileSizeUnit.K: return value * 1024;
case FileSizeUnit.M: return value * 1024 * 1024;
case FileSizeUnit.G: return value * 1024 * 1024 * 1024;
default: return value * 1024 * 1024 * 1024 * 1024;
}
}
public FileSize(decimal size, FileSizeUnit unit)
{
_size = size;
_unit = unit;
}
private decimal UnitDifference(FileSizeUnit x, FileSizeUnit y)
{
return (decimal)x / (decimal)y;
}
public FileSize In(FileSizeUnit newUnit)
{
return new FileSize(_size * UnitDifference(_unit, newUnit), newUnit);
}
public static void PrepareLocalFile(string filePath, long fileSizeInUnit, FileSizeUnit fileSizeUnit)
{
if (FileSizeUnit.B == fileSizeUnit)
{
Helper.GenerateFileInBytes(filePath, fileSizeInUnit);
}
else if (FileSizeUnit.KB == fileSizeUnit)
{
Helper.GenerateFileInKB(filePath, fileSizeInUnit);
}
else if (FileSizeUnit.MB == fileSizeUnit)
{
Helper.GenerateFileInMB(filePath, fileSizeInUnit);
}
else
{
Helper.GenerateFileInGB(filePath, fileSizeInUnit);
}
}
/// <summary>
/// Short ToString of FileSizeUnit
/// </summary>
/// <param name="unit">Unit to string</param>
/// <returns>Shortcut of unit</returns>
public string ShortUnitForm(FileSizeUnit unit)
{
switch (unit)
{
case FileSizeUnit.Unknown:
return string.Empty;
case FileSizeUnit.Bit:
return "b";
case FileSizeUnit.Byte:
return "B";
case FileSizeUnit.KiloByte:
return "kB";
case FileSizeUnit.MegaByte:
return "MB";
case FileSizeUnit.GigaByte:
return "GB";
case FileSizeUnit.TeraByte:
return "TB";
case FileSizeUnit.PetaByte:
return "PB";
default:
throw new NotImplementedException("There is no such unit");
}
}
/// <summary>
/// Round up size to specified unit
/// </summary>
/// <param name="fileSizeUnit">New FileSizeUnit</param>
private void UnitUp(FileSizeUnit upUnit)
{
while (unit != upUnit && unit < FileSizeUnit.PetaByte)
{
size /= 1024.0;
++unit;
}
}
public string ToString(FileSizeUnit unit, bool printUnit = true)
{
return ReadableFileSize(_size, (int) unit, printUnit);
}
