ICODEBROKER

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

    }

}

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

    }

}