■ 바이트 크기 단위 변환하기
------------------------------------------------------------------------------------------------------------------------
TestProject.zip▶ ByteSize.cs
using System; using System.Globalization;
namespace TestProject { /// <summary> /// 바이트 크기 구조체 /// </summary> public struct ByteSize : IComparable<ByteSize>, IEquatable<ByteSize> { //////////////////////////////////////////////////////////////////////////////////////////////////// Field ////////////////////////////////////////////////////////////////////////////////////////// Static //////////////////////////////////////////////////////////////////////////////// Public
#region Field
/// <summary> /// 최소 값 /// </summary> public static readonly ByteSize MinimumValue = ByteSize.FromBitCount(0);
/// <summary> /// 최대 값 /// </summary> public static readonly ByteSize MaximumValue = ByteSize.FromBitCount(long.MaxValue);
#endregion
////////////////////////////////////////////////////////////////////////////////////////// Instance //////////////////////////////////////////////////////////////////////////////// Public
#region Field
/// <summary> /// 바이트당 비트 수 /// </summary> public const long BIT_COUNT_PER_BYTE = 8;
/// <summary> /// 킬로 바이트당 바이트 수 /// </summary> public const long BYTE_COUNT_PER_KILO_BYTE = 1024;
/// <summary> /// 메가 바이트당 바이트 수 /// </summary> public const long BYTE_COUNT_PER_MEGA_BYTE = 1048576;
/// <summary> /// 기가 바이트당 바이트 수 /// </summary> public const long BYTE_COUNT_PER_GIGA_BYTE = 1073741824;
/// <summary> /// 테라 바이트당 바이트 수 /// </summary> public const long BYTE_COUNT_PER_TERA_BYTE = 1099511627776;
/// <summary> /// 페타 바이트당 바이트 수 /// </summary> public const long BYTE_COUNT_PER_PETA_BYTE = 1125899906842624;
/// <summary> /// 비트 단위 /// </summary> public const string BIT_UNIT = "b";
/// <summary> /// 바이트 단위 /// </summary> public const string BYTE_UNIT = "B";
/// <summary> /// 킬로 바이트 단위 /// </summary> public const string KILO_BYTE_UNIT = "KB";
/// <summary> /// 메가 바이트 단위 /// </summary> public const string MEGA_BYTE_UNIT = "MB";
/// <summary> /// 기가 바이트 단위 /// </summary> public const string GIGA_BYTE_UNIT = "GB";
/// <summary> /// 테라 바이트 단위 /// </summary> public const string TERA_BYTE_UINT = "TB";
/// <summary> /// 페타 바이트 단위 /// </summary> public const string PETA_BYTE_UNIT = "PB";
#endregion
//////////////////////////////////////////////////////////////////////////////////////////////////// Property ////////////////////////////////////////////////////////////////////////////////////////// Public
#region 비트 수 - BitCount
/// <summary> /// 비트 수 /// </summary> public long BitCount { get; private set; }
#endregion #region 바이트 수 - ByteCount
/// <summary> /// 바이트 수 /// </summary> public double ByteCount { get; private set; }
#endregion #region 킬로 바이트 수 - KiloByteCount
/// <summary> /// 킬로 바이트 수 /// </summary> public double KiloByteCount { get; private set; }
#endregion #region 메가 바이트 수 - MegaByteCount
/// <summary> /// 메가 바이트 수 /// </summary> public double MegaByteCount { get; private set; }
#endregion #region 기가 바이트 수 - GigaByteCount
/// <summary> /// 기가 바이트 수 /// </summary> public double GigaByteCount { get; private set; }
#endregion #region 테라 바이트 수 - TeraByteCount
/// <summary> /// 테라 바이트 수 /// </summary> public double TeraByteCount { get; private set; }
#endregion #region 페타 바이트 수 - PetaByteCount
/// <summary> /// 페타 바이트 수 /// </summary> public double PetaByteCount { get; private set; }
#endregion
#region 가장 큰 단위 - LargestUnit
/// <summary> /// 가장 큰 단위 /// </summary> public string LargestUnit { get { if(Math.Abs(PetaByteCount) >= 1) { return ByteSize.PETA_BYTE_UNIT; } else if(Math.Abs(TeraByteCount) >= 1) { return ByteSize.TERA_BYTE_UINT; } else if(Math.Abs(GigaByteCount) >= 1) { return ByteSize.GIGA_BYTE_UNIT; } else if(Math.Abs(MegaByteCount) >= 1) { return ByteSize.MEGA_BYTE_UNIT; } else if(Math.Abs(KiloByteCount) >= 1) { return ByteSize.KILO_BYTE_UNIT; } else if(Math.Abs(ByteCount) >= 1) { return ByteSize.BYTE_UNIT; }
return ByteSize.BIT_UNIT; } }
#endregion #region 가장 큰 단위 값 - LargestUnitValue
/// <summary> /// 가장 큰 단위 값 /// </summary> public double LargestUnitValue { get { if(Math.Abs(PetaByteCount) >= 1) { return PetaByteCount; } else if(Math.Abs(TeraByteCount) >= 1) { return TeraByteCount; } else if(Math.Abs(GigaByteCount) >= 1) { return GigaByteCount; } else if(Math.Abs(MegaByteCount) >= 1) { return MegaByteCount; } else if(Math.Abs(KiloByteCount) >= 1) { return KiloByteCount; } else if(Math.Abs(ByteCount) >= 1) { return ByteCount; }
return BitCount; } }
#endregion
//////////////////////////////////////////////////////////////////////////////////////////////////// Constructor ////////////////////////////////////////////////////////////////////////////////////////// Public
#region 생성자 - ByteSize(byteSize)
/// <summary> /// 생성자 /// </summary> /// <param name="byteSize">바이트 크기</param> public ByteSize(double byteSize) { BitCount = (long)Math.Ceiling(byteSize * BIT_COUNT_PER_BYTE);
ByteCount = byteSize;
KiloByteCount = byteSize / BYTE_COUNT_PER_KILO_BYTE; MegaByteCount = byteSize / BYTE_COUNT_PER_MEGA_BYTE; GigaByteCount = byteSize / BYTE_COUNT_PER_GIGA_BYTE; TeraByteCount = byteSize / BYTE_COUNT_PER_TERA_BYTE; PetaByteCount = byteSize / BYTE_COUNT_PER_PETA_BYTE; }
#endregion
//////////////////////////////////////////////////////////////////////////////////////////////////// Method ////////////////////////////////////////////////////////////////////////////////////////// Static //////////////////////////////////////////////////////////////////////////////// Public
#region 연산자 + 재정의하기 - operator +(source1, source2)
/// <summary> /// 연산자 + 재정의하기 /// </summary> /// <param name="source1">소스 1</param> /// <param name="source2">소스 2</param> /// <returns>바이트 크기</returns> public static ByteSize operator +(ByteSize source1, ByteSize source2) { return new ByteSize(source1.ByteCount + source2.ByteCount); }
#endregion #region 연산자 ++ 재정의하기 - operator ++(source)
/// <summary> /// 연산자 ++ 재정의하기 /// </summary> /// <param name="source">소스</param> /// <returns>바이트 크기</returns> public static ByteSize operator ++(ByteSize source) { return new ByteSize(source.ByteCount + 1); }
#endregion #region 연산자 - 재정의하기 - operator -(source)
/// <summary> /// 연산자 - 재정의하기 /// </summary> /// <param name="source">소스</param> /// <returns>바이트 크기</returns> public static ByteSize operator -(ByteSize source) { return new ByteSize(-source.ByteCount); }
#endregion #region 연산자 -- 재정의하기 - --(source)
/// <summary> /// 연산자 -- 재정의하기 /// </summary> /// <param name="source">소스</param> /// <returns>바이트 크기</returns> public static ByteSize operator --(ByteSize source) { return new ByteSize(source.ByteCount - 1); }
#endregion #region 연산자 == 재정의하기 - operator ==(source1, source2)
/// <summary> /// 연산자 == 재정의하기 /// </summary> /// <param name="source1">소스 1</param> /// <param name="source2">소스 2</param> /// <returns>바이트 크기</returns> public static bool operator ==(ByteSize source1, ByteSize source2) { return source1.BitCount == source2.BitCount; }
#endregion #region 연산자 != 재정의하기 - operator !=(source1, source2)
/// <summary> /// 연산자 != 재정의하기 /// </summary> /// <param name="source1">소스 1</param> /// <param name="source2">소스 2</param> /// <returns>바이트 크기</returns> public static bool operator !=(ByteSize source1, ByteSize source2) { return source1.BitCount != source2.BitCount; }
#endregion #region 연산자 < 재정의하기 - operator <(source1, source2)
/// <summary> /// 연산자 < 재정의하기 /// </summary> /// <param name="source1">소스 1</param> /// <param name="source2">소스 2</param> /// <returns>바이트 크기</returns> public static bool operator <(ByteSize source1, ByteSize source2) { return source1.BitCount < source2.BitCount; }
#endregion #region 연산자 <= 재정의하기 - operator <=(source1, source2)
/// <summary> /// 연산자 <= 재정의하기 /// </summary> /// <param name="source1">소스 1</param> /// <param name="source2">소스 2</param> /// <returns>바이트 크기</returns> public static bool operator <=(ByteSize source1, ByteSize source2) { return source1.BitCount <= source2.BitCount; }
#endregion #region 연산자 > 재정의하기 - operator >(source1, source2)
/// <summary> /// 연산자 > 재정의하기 /// </summary> /// <param name="source1">소스 1</param> /// <param name="source2">소스 2</param> /// <returns>바이트 크기</returns> public static bool operator >(ByteSize source1, ByteSize source2) { return source1.BitCount > source2.BitCount; }
#endregion #region 연산자 >= 재정의하기 - operator >=(source1, source2)
/// <summary> /// 연산자 >= 재정의하기 /// </summary> /// <param name="source1">소스 1</param> /// <param name="source2">소스 2</param> /// <returns>바이트 크기</returns> public static bool operator >=(ByteSize source1, ByteSize source2) { return source1.BitCount >= source2.BitCount; }
#endregion
#region 비트 수에서 비트 크기 구하기 - FromBitCount(value)
/// <summary> /// 비트 수에서 비트 크기 구하기 /// </summary> /// <param name="value">값</param> /// <returns>비트 크기</returns> public static ByteSize FromBitCount(long value) { return new ByteSize(value / (double)BIT_COUNT_PER_BYTE); }
#endregion #region 바이트 수에서 비트 크기 구하기 - FromByteCount(value)
/// <summary> /// 바이트 수에서 비트 크기 구하기 /// </summary> /// <param name="value">값</param> /// <returns>비트 크기</returns> public static ByteSize FromByteCount(double value) { return new ByteSize(value); }
#endregion #region 킬로 바이트 수에서 비트 크기 구하기 - FromKiloByteCount(value)
/// <summary> /// 킬로 바이트 수에서 비트 크기 구하기 /// </summary> /// <param name="value">값</param> /// <returns>비트 크기</returns> public static ByteSize FromKiloByteCount(double value) { return new ByteSize(value * BYTE_COUNT_PER_KILO_BYTE); }
#endregion #region 메가 바이트 수에서 비트 크기 구하기 - FromMegaByteCount(value)
/// <summary> /// 메가 바이트 수에서 비트 크기 구하기 /// </summary> /// <param name="value">값</param> /// <returns>비트 크기</returns> public static ByteSize FromMegaByteCount(double value) { return new ByteSize(value * BYTE_COUNT_PER_MEGA_BYTE); }
#endregion #region 기가 바이트 수에서 비트 크기 구하기 - FromGigaByteCount(value)
/// <summary> /// 기가 바이트 수에서 비트 크기 구하기 /// </summary> /// <param name="value">값</param> /// <returns>비트 크기</returns> public static ByteSize FromGigaByteCount(double value) { return new ByteSize(value * BYTE_COUNT_PER_GIGA_BYTE); }
#endregion #region 테라 바이트 수에서 비트 크기 구하기 - FromTeraByteCount(value)
/// <summary> /// 테라 바이트 수에서 비트 크기 구하기 /// </summary> /// <param name="value">값</param> /// <returns>비트 크기</returns> public static ByteSize FromTeraByteCount(double value) { return new ByteSize(value * BYTE_COUNT_PER_TERA_BYTE); }
#endregion #region 페타 바이트 수에서 비트 크기 구하기 - FromPetaByteCount(value)
/// <summary> /// 페타 바이트 수에서 비트 크기 구하기 /// </summary> /// <param name="value">값</param> /// <returns>비트 크기</returns> public static ByteSize FromPetaByteCount(double value) { return new ByteSize(value * BYTE_COUNT_PER_PETA_BYTE); }
#endregion
#region 파싱 시도하기 - TryParse(source, value)
/// <summary> /// 파싱 시도하기 /// </summary> /// <param name="source">소스</param> /// <param name="value">값</param> /// <returns>처리 결과</returns> public static bool TryParse(string source, out ByteSize value) { if(string.IsNullOrWhiteSpace(source)) { throw new ArgumentNullException("source", "String is null or whitespace"); }
value = new ByteSize();
source = source.TrimStart();
int i = 0; bool found = false; char decimalSeparator = Convert.ToChar(NumberFormatInfo.CurrentInfo.NumberDecimalSeparator); char groupSeparator = Convert.ToChar(NumberFormatInfo.CurrentInfo.NumberGroupSeparator);
int sourceLength = source.Length;
for(i = 0; i < sourceLength; i++) { if(!(char.IsDigit(source[i]) || source[i] == decimalSeparator || source[i] == groupSeparator)) { found = true;
break; } }
if(found == false) { return false; }
int lastNumber = i;
string numberPart = source.Substring(0, lastNumber).Trim(); string sizePart = source.Substring(lastNumber, source.Length - lastNumber).Trim();
double number;
if(!double.TryParse(numberPart, NumberStyles.Float | NumberStyles.AllowThousands, NumberFormatInfo.CurrentInfo, out number)) { return false; }
switch(sizePart) { case "b" :
if(number % 1 != 0) { return false; }
value = FromBitCount((long)number);
break;
case "B" :
value = FromByteCount(number);
break;
case "KB" : case "kB" : case "kb" :
value = FromKiloByteCount(number);
break;
case "MB" : case "mB" : case "mb" :
value = FromMegaByteCount(number);
break;
case "GB" : case "gB" : case "gb" :
value = FromGigaByteCount(number);
break;
case "TB" : case "tB" : case "tb" :
value = FromTeraByteCount(number);
break;
case "PB" : case "pB" : case "pb" :
value = FromPetaByteCount(number);
break; }
return true; }
#endregion #region 파싱하기 - Parse(source)
/// <summary> /// 파싱하기 /// </summary> /// <param name="source">소스</param> /// <returns>바이트 크기</returns> public static ByteSize Parse(string source) { ByteSize byteSize;
if(TryParse(source, out byteSize)) { return byteSize; }
throw new FormatException("source is not in the correct format"); }
#endregion
////////////////////////////////////////////////////////////////////////////////////////// Instance //////////////////////////////////////////////////////////////////////////////// Public
#region 문자열 구하기 - ToString(format, formatProvider)
/// <summary> /// 문자열 구하기 /// </summary> /// <param name="format">포맷 문자열</param> /// <param name="formatProvider">포맷 공급자</param> /// <returns>문자열</returns> public string ToString(string format, IFormatProvider formatProvider) { if(!format.Contains("#") && !format.Contains("0")) { format = "#.## " + format; }
if(formatProvider == null) { formatProvider = CultureInfo.CurrentCulture; }
Func<string, bool> containsFunc = s => format.IndexOf(s, StringComparison.CurrentCultureIgnoreCase) != -1;
Func<double, string> outputFimc = n => n.ToString(format, formatProvider);
if(containsFunc("PB")) { return outputFimc(PetaByteCount); } else if(containsFunc("TB")) { return outputFimc(TeraByteCount); } else if(containsFunc("GB")) { return outputFimc(GigaByteCount); } else if(containsFunc("MB")) { return outputFimc(MegaByteCount); } else if(containsFunc("KB")) { return outputFimc(KiloByteCount); }
if(format.IndexOf(ByteSize.BYTE_UNIT) != -1) { return outputFimc(this.ByteCount); }
if(format.IndexOf(ByteSize.BIT_UNIT) != -1) { return outputFimc(this.BitCount); }
return string.Format("{0} {1}", LargestUnitValue.ToString(format, formatProvider), LargestUnit); }
#endregion #region 문자열 구하기 - ToString(formatString)
/// <summary> /// 문자열 구하기 /// </summary> /// <param name="formatString">포맷 문자열</param> /// <returns>문자열</returns> public string ToString(string formatString) { return ToString(formatString, CultureInfo.CurrentCulture); }
#endregion #region 문자열 구하기 - ToString()
/// <summary> /// 문자열 구하기 /// </summary> /// <returns>문자열</returns> public override string ToString() { return ToString("#.##", CultureInfo.CurrentCulture); }
#endregion
#region 동일 여부 구하기 - Equals(value)
/// <summary> /// 동일 여부 구하기 /// </summary> /// <param name="value">값</param> /// <returns>동일 여부</returns> public override bool Equals(object value) { if(value == null) { return false; }
ByteSize other;
if(value is ByteSize) { other = (ByteSize)value; } else { return false; }
return Equals(other); }
#endregion #region 동일 여부 구하기 - Equals(value)
/// <summary> /// 동일 여부 구하기 /// </summary> /// <param name="value">값</param> /// <returns>덩일 여부</returns> public bool Equals(ByteSize value) { return this.BitCount == value.BitCount; }
#endregion
#region 해시 코드 구하기 - GetHashCode()
/// <summary> /// 해시 코드 구하기 /// </summary> /// <returns>해시 코드</returns> public override int GetHashCode() { return BitCount.GetHashCode(); }
#endregion
#region 비교하기 - CompareTo(value)
/// <summary> /// 비교하기 /// </summary> /// <param name="value">값</param> /// <returns>비교 결과</returns> public int CompareTo(ByteSize value) { return this.BitCount.CompareTo(value.BitCount); }
#endregion
#region 추가하기 - Add(value)
/// <summary> /// 추가하기 /// </summary> /// <param name="value">값</param> /// <returns>추가 값</returns> public ByteSize Add(ByteSize value) { return new ByteSize(ByteCount + value.ByteCount); }
#endregion #region 비트 수 추가하기 - AddBitCount(value)
/// <summary> /// 비트 수 추가하기 /// </summary> /// <param name="value">값</param> /// <returns>바이트 크기</returns> public ByteSize AddBitCount(long value) { return this + FromBitCount(value); }
#endregion #region 바이트 수 추가하기 - AddByteCount(value)
/// <summary> /// 바이트 수 추가하기 /// </summary> /// <param name="value">값</param> /// <returns>바이트 크기</returns> public ByteSize AddByteCount(double value) { return this + ByteSize.FromByteCount(value); }
#endregion #region 킬로 바이트 수 추가하기 - AddKiloByteCount(value)
/// <summary> /// 킬로 바이트 수 추가하기 /// </summary> /// <param name="value">값</param> /// <returns>바이트 크기</returns> public ByteSize AddKiloByteCount(double value) { return this + ByteSize.FromKiloByteCount(value); }
#endregion #region 메가 바이트 수 추가하기 - AddMegaByteCount(value)
/// <summary> /// 메가 바이트 수 추가하기 /// </summary> /// <param name="value">값</param> /// <returns>바이트 크기</returns> public ByteSize AddMegaByteCount(double value) { return this + ByteSize.FromMegaByteCount(value); }
#endregion #region 기가 바이트 수 추가하기 - AddGigaByteCount(value)
/// <summary> /// 기가 바이트 수 추가하기 /// </summary> /// <param name="value">값</param> /// <returns>바이트 크기</returns> public ByteSize AddGigaByteCount(double value) { return this + ByteSize.FromGigaByteCount(value); }
#endregion #region 테라 바이트 수 추가하기 - AddTeraByteCount(value)
/// <summary> /// 테라 바이트 수 추가하기 /// </summary> /// <param name="value">값</param> /// <returns>바이트 크기</returns> public ByteSize AddTeraByteCount(double value) { return this + ByteSize.FromTeraByteCount(value); }
#endregion #region 페타 바이트 수 추가하기 - AddPetaByteCount(value)
/// <summary> /// 페타 바이트 수 추가하기 /// </summary> /// <param name="value">값</param> /// <returns>바이트 크기</returns> public ByteSize AddPetaByteCount(double value) { return this + ByteSize.FromPetaByteCount(value); }
#endregion
#region 빼기 - Subtract(value)
/// <summary> /// 빼기 /// </summary> /// <param name="value">값</param> /// <returns>바이트 크기</returns> public ByteSize Subtract(ByteSize value) { return new ByteSize(ByteCount - value.ByteCount); }
#endregion } }
|
▶ Program.cs
using System;
namespace TestProject { /// <summary> /// 프로그램 /// </summary> class Program { //////////////////////////////////////////////////////////////////////////////////////////////////// Method ////////////////////////////////////////////////////////////////////////////////////////// Static //////////////////////////////////////////////////////////////////////////////// Private
#region 프로그램 시작하기 - Main()
/// <summary> /// 프로그램 시작하기 /// </summary> private static void Main() { ByteSize size = new ByteSize(1029343342);
Console.WriteLine(size.ByteCount ); Console.WriteLine(size.KiloByteCount); Console.WriteLine(size.MegaByteCount); Console.WriteLine(size.GigaByteCount); Console.WriteLine(size.TeraByteCount);
Console.WriteLine($"{size.LargestUnitValue.ToString("F")}{size.LargestUnit}"); }
#endregion } }
|
------------------------------------------------------------------------------------------------------------------------
'C# > Common' 카테고리의 다른 글
| [C#/COMMON] 객체 값 복사하기 (0) | 2020.02.02 |
|---|---|
| [C#/COMMON] DataRow 클래스 : 객체에서 값 복사하기 (0) | 2020.02.02 |
| [C#/COMMON] DataRow 클래스 : 객체에 값 복사하기 (0) | 2020.02.02 |
| [C#/COMMON] 숫자 임의(Random) ID 구하기 (0) | 2020.02.02 |
| [C#/COMMON] 임의(Random) ID 구하기 (0) | 2020.02.02 |
| [C#/COMMON] 바이트 크기 단위 변환하기 (0) | 2020.02.02 |
| [C#/COMMON] 단일 프로세스 여부 구하기 (0) | 2020.02.02 |
| [C#/COMMON] 개발 프로세스 여부 구하기 (0) | 2020.02.02 |
| [C#/COMMON] 64비트 프로세스 여부 구하기 (0) | 2020.02.02 |
| [C#/COMMON] ICloneable 인터페이스 : 객체 DEEP COPY 사용하기 (0) | 2020.02.01 |
| [C#/COMMON] 바이트 배열 병합하기 (0) | 2020.01.12 |
댓글을 달아 주세요