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); }
/// <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"); } }
public string ToString(FileSizeUnit unit, bool printUnit = true) { return ReadableFileSize(_size, (int) unit, printUnit); }