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