netcore/System.Private.CoreLib/shared/System/UInt64.cs

   1 // Licensed to the .NET Foundation under one or more agreements.
   2 // The .NET Foundation licenses this file to you under the MIT license.
   3 // See the LICENSE file in the project root for more information.
   4
   5 using System.Globalization;
   6 using System.Runtime.CompilerServices;
   7 using System.Runtime.InteropServices;
   8 using System.Runtime.Versioning;
   9
  10 namespace System
  11 {
  12     [Serializable]
  13     [CLSCompliant(false)]
  14     [StructLayout(LayoutKind.Sequential)]
  15     [TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
  16     public readonly struct UInt64 : IComparable, IConvertible, IFormattable, IComparable<ulong>, IEquatable<ulong>, ISpanFormattable
  17     {
  18         private readonly ulong m_value; // Do not rename (binary serialization)
  19
  20         public const ulong MaxValue = (ulong)0xffffffffffffffffL;
  21         public const ulong MinValue = 0x0;
  22
  23         // Compares this object to another object, returning an integer that
  24         // indicates the relationship.
  25         // Returns a value less than zero if this  object
  26         // null is considered to be less than any instance.
  27         // If object is not of type UInt64, this method throws an ArgumentException.
  28         //
  29         public int CompareTo(object? value)
  30         {
  31             if (value == null)
  32             {
  33                 return 1;
  34             }
  35
  36             // Need to use compare because subtraction will wrap
  37             // to positive for very large neg numbers, etc.
  38             if (value is ulong i)
  39             {
  40                 if (m_value < i) return -1;
  41                 if (m_value > i) return 1;
  42                 return 0;
  43             }
  44
  45             throw new ArgumentException(SR.Arg_MustBeUInt64);
  46         }
  47
  48         public int CompareTo(ulong value)
  49         {
  50             // Need to use compare because subtraction will wrap
  51             // to positive for very large neg numbers, etc.
  52             if (m_value < value) return -1;
  53             if (m_value > value) return 1;
  54             return 0;
  55         }
  56
  57         public override bool Equals(object? obj)
  58         {
  59             if (!(obj is ulong))
  60             {
  61                 return false;
  62             }
  63             return m_value == ((ulong)obj).m_value;
  64         }
  65
  66         [NonVersionable]
  67         public bool Equals(ulong obj)
  68         {
  69             return m_value == obj;
  70         }
  71
  72         // The value of the lower 32 bits XORed with the uppper 32 bits.
  73         public override int GetHashCode()
  74         {
  75             return ((int)m_value) ^ (int)(m_value >> 32);
  76         }
  77
  78         public override string ToString()
  79         {
  80             return Number.FormatUInt64(m_value, null, null);
  81         }
  82
  83         public string ToString(IFormatProvider? provider)
  84         {
  85             return Number.FormatUInt64(m_value, null, provider);
  86         }
  87
  88         public string ToString(string? format)
  89         {
  90             return Number.FormatUInt64(m_value, format, null);
  91         }
  92
  93         public string ToString(string? format, IFormatProvider? provider)
  94         {
  95             return Number.FormatUInt64(m_value, format, provider);
  96         }
  97
  98         public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format = default, IFormatProvider? provider = null)
  99         {
 100             return Number.TryFormatUInt64(m_value, format, provider, destination, out charsWritten);
 101         }
 102
 103         [CLSCompliant(false)]
 104         public static ulong Parse(string s)
 105         {
 106             if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
 107             return Number.ParseUInt64(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo);
 108         }
 109
 110         [CLSCompliant(false)]
 111         public static ulong Parse(string s, NumberStyles style)
 112         {
 113             NumberFormatInfo.ValidateParseStyleInteger(style);
 114             if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
 115             return Number.ParseUInt64(s, style, NumberFormatInfo.CurrentInfo);
 116         }
 117
 118         [CLSCompliant(false)]
 119         public static ulong Parse(string s, IFormatProvider? provider)
 120         {
 121             if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
 122             return Number.ParseUInt64(s, NumberStyles.Integer, NumberFormatInfo.GetInstance(provider));
 123         }
 124
 125         [CLSCompliant(false)]
 126         public static ulong Parse(string s, NumberStyles style, IFormatProvider? provider)
 127         {
 128             NumberFormatInfo.ValidateParseStyleInteger(style);
 129             if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
 130             return Number.ParseUInt64(s, style, NumberFormatInfo.GetInstance(provider));
 131         }
 132
 133         [CLSCompliant(false)]
 134         public static ulong Parse(ReadOnlySpan<char> s, NumberStyles style = NumberStyles.Integer, IFormatProvider? provider = null)
 135         {
 136             NumberFormatInfo.ValidateParseStyleInteger(style);
 137             return Number.ParseUInt64(s, style, NumberFormatInfo.GetInstance(provider));
 138         }
 139
 140         [CLSCompliant(false)]
 141         public static bool TryParse(string? s, out ulong result)
 142         {
 143             if (s == null)
 144             {
 145                 result = 0;
 146                 return false;
 147             }
 148
 149             return Number.TryParseUInt64IntegerStyle(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo, out result) == Number.ParsingStatus.OK;
 150         }
 151
 152         [CLSCompliant(false)]
 153         public static bool TryParse(ReadOnlySpan<char> s, out ulong result)
 154         {
 155             return Number.TryParseUInt64IntegerStyle(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo, out result) == Number.ParsingStatus.OK;
 156         }
 157
 158         [CLSCompliant(false)]
 159         public static bool TryParse(string? s, NumberStyles style, IFormatProvider? provider, out ulong result)
 160         {
 161             NumberFormatInfo.ValidateParseStyleInteger(style);
 162
 163             if (s == null)
 164             {
 165                 result = 0;
 166                 return false;
 167             }
 168
 169             return Number.TryParseUInt64(s, style, NumberFormatInfo.GetInstance(provider), out result) == Number.ParsingStatus.OK;
 170         }
 171
 172         [CLSCompliant(false)]
 173         public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider, out ulong result)
 174         {
 175             NumberFormatInfo.ValidateParseStyleInteger(style);
 176             return Number.TryParseUInt64(s, style, NumberFormatInfo.GetInstance(provider), out result) == Number.ParsingStatus.OK;
 177         }
 178
 179         //
 180         // IConvertible implementation
 181         //
 182
 183         public TypeCode GetTypeCode()
 184         {
 185             return TypeCode.UInt64;
 186         }
 187
 188         bool IConvertible.ToBoolean(IFormatProvider? provider)
 189         {
 190             return Convert.ToBoolean(m_value);
 191         }
 192
 193         char IConvertible.ToChar(IFormatProvider? provider)
 194         {
 195             return Convert.ToChar(m_value);
 196         }
 197
 198         sbyte IConvertible.ToSByte(IFormatProvider? provider)
 199         {
 200             return Convert.ToSByte(m_value);
 201         }
 202
 203         byte IConvertible.ToByte(IFormatProvider? provider)
 204         {
 205             return Convert.ToByte(m_value);
 206         }
 207
 208         short IConvertible.ToInt16(IFormatProvider? provider)
 209         {
 210             return Convert.ToInt16(m_value);
 211         }
 212
 213         ushort IConvertible.ToUInt16(IFormatProvider? provider)
 214         {
 215             return Convert.ToUInt16(m_value);
 216         }
 217
 218         int IConvertible.ToInt32(IFormatProvider? provider)
 219         {
 220             return Convert.ToInt32(m_value);
 221         }
 222
 223         uint IConvertible.ToUInt32(IFormatProvider? provider)
 224         {
 225             return Convert.ToUInt32(m_value);
 226         }
 227
 228         long IConvertible.ToInt64(IFormatProvider? provider)
 229         {
 230             return Convert.ToInt64(m_value);
 231         }
 232
 233         ulong IConvertible.ToUInt64(IFormatProvider? provider)
 234         {
 235             return m_value;
 236         }
 237
 238         float IConvertible.ToSingle(IFormatProvider? provider)
 239         {
 240             return Convert.ToSingle(m_value);
 241         }
 242
 243         double IConvertible.ToDouble(IFormatProvider? provider)
 244         {
 245             return Convert.ToDouble(m_value);
 246         }
 247
 248         decimal IConvertible.ToDecimal(IFormatProvider? provider)
 249         {
 250             return Convert.ToDecimal(m_value);
 251         }
 252
 253         DateTime IConvertible.ToDateTime(IFormatProvider? provider)
 254         {
 255             throw new InvalidCastException(SR.Format(SR.InvalidCast_FromTo, "UInt64", "DateTime"));
 256         }
 257
 258         object IConvertible.ToType(Type type, IFormatProvider? provider)
 259         {
 260             return Convert.DefaultToType((IConvertible)this, type, provider);
 261         }
 262     }
 263 }