netcore/System.Private.CoreLib/shared/System/Globalization/NumberFormatInfo.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 namespace System.Globalization
   6 {
   7     /// <remarks>
   8     /// Property             Default Description
   9     /// PositiveSign           '+'   Character used to indicate positive values.
  10     /// NegativeSign           '-'   Character used to indicate negative values.
  11     /// NumberDecimalSeparator '.'   The character used as the decimal separator.
  12     /// NumberGroupSeparator   ','   The character used to separate groups of
  13     ///                              digits to the left of the decimal point.
  14     /// NumberDecimalDigits    2     The default number of decimal places.
  15     /// NumberGroupSizes       3     The number of digits in each group to the
  16     ///                              left of the decimal point.
  17     /// NaNSymbol             "NaN"  The string used to represent NaN values.
  18     /// PositiveInfinitySymbol"Infinity" The string used to represent positive
  19     ///                              infinities.
  20     /// NegativeInfinitySymbol"-Infinity" The string used to represent negative
  21     ///                              infinities.
  22     ///
  23     /// Property                  Default  Description
  24     /// CurrencyDecimalSeparator  '.'      The character used as the decimal
  25     ///                                    separator.
  26     /// CurrencyGroupSeparator    ','      The character used to separate groups
  27     ///                                    of digits to the left of the decimal
  28     ///                                    point.
  29     /// CurrencyDecimalDigits     2        The default number of decimal places.
  30     /// CurrencyGroupSizes        3        The number of digits in each group to
  31     ///                                    the left of the decimal point.
  32     /// CurrencyPositivePattern   0        The format of positive values.
  33     /// CurrencyNegativePattern   0        The format of negative values.
  34     /// CurrencySymbol            "$"      String used as local monetary symbol.
  35     /// </remarks>
  36     public sealed class NumberFormatInfo : IFormatProvider, ICloneable
  37     {
  38         private static volatile NumberFormatInfo? s_invariantInfo;
  39
  40         internal int[] _numberGroupSizes = new int[] { 3 };
  41         internal int[] _currencyGroupSizes = new int[] { 3 };
  42         internal int[] _percentGroupSizes = new int[] { 3 };
  43         internal string _positiveSign = "+";
  44         internal string _negativeSign = "-";
  45         internal string _numberDecimalSeparator = ".";
  46         internal string _numberGroupSeparator = ",";
  47         internal string _currencyGroupSeparator = ",";
  48         internal string _currencyDecimalSeparator = ".";
  49         internal string _currencySymbol = "\x00a4";  // U+00a4 is the symbol for International Monetary Fund.
  50         internal string _nanSymbol = "NaN";
  51         internal string _positiveInfinitySymbol = "Infinity";
  52         internal string _negativeInfinitySymbol = "-Infinity";
  53         internal string _percentDecimalSeparator = ".";
  54         internal string _percentGroupSeparator = ",";
  55         internal string _percentSymbol = "%";
  56         internal string _perMilleSymbol = "\u2030";
  57
  58         internal string[] _nativeDigits = { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" };
  59
  60         internal int _numberDecimalDigits = 2;
  61         internal int _currencyDecimalDigits = 2;
  62         internal int _currencyPositivePattern = 0;
  63         internal int _currencyNegativePattern = 0;
  64         internal int _numberNegativePattern = 1;
  65         internal int _percentPositivePattern = 0;
  66         internal int _percentNegativePattern = 0;
  67         internal int _percentDecimalDigits = 2;
  68
  69         internal int _digitSubstitution = (int)DigitShapes.None;
  70
  71         internal bool _isReadOnly = false;
  72
  73         private bool _hasInvariantNumberSigns = true;
  74
  75         public NumberFormatInfo()
  76         {
  77         }
  78
  79         private static void VerifyDecimalSeparator(string decSep, string propertyName)
  80         {
  81             if (decSep == null)
  82             {
  83                 throw new ArgumentNullException(propertyName);
  84             }
  85
  86             if (decSep.Length == 0)
  87             {
  88                 throw new ArgumentException(SR.Argument_EmptyDecString, propertyName);
  89             }
  90         }
  91
  92         private static void VerifyGroupSeparator(string groupSep, string propertyName)
  93         {
  94             if (groupSep == null)
  95             {
  96                 throw new ArgumentNullException(propertyName);
  97             }
  98         }
  99
 100         private static void VerifyNativeDigits(string[] nativeDig, string propertyName)
 101         {
 102             if (nativeDig == null)
 103             {
 104                 throw new ArgumentNullException(propertyName, SR.ArgumentNull_Array);
 105             }
 106
 107             if (nativeDig.Length != 10)
 108             {
 109                 throw new ArgumentException(SR.Argument_InvalidNativeDigitCount, propertyName);
 110             }
 111
 112             for (int i = 0; i < nativeDig.Length; i++)
 113             {
 114                 if (nativeDig[i] == null)
 115                 {
 116                     throw new ArgumentNullException(propertyName, SR.ArgumentNull_ArrayValue);
 117                 }
 118
 119                 if (nativeDig[i].Length != 1)
 120                 {
 121                     if (nativeDig[i].Length != 2)
 122                     {
 123                         // Not 1 or 2 UTF-16 code points
 124                         throw new ArgumentException(SR.Argument_InvalidNativeDigitValue, propertyName);
 125                     }
 126                     else if (!char.IsSurrogatePair(nativeDig[i][0], nativeDig[i][1]))
 127                     {
 128                         // 2 UTF-6 code points, but not a surrogate pair
 129                         throw new ArgumentException(SR.Argument_InvalidNativeDigitValue, propertyName);
 130                     }
 131                 }
 132
 133                 if (CharUnicodeInfo.GetDecimalDigitValue(nativeDig[i], 0) != i &&
 134                     CharUnicodeInfo.GetUnicodeCategory(nativeDig[i], 0) != UnicodeCategory.PrivateUse)
 135                 {
 136                     // Not the appropriate digit according to the Unicode data properties
 137                     // (Digit 0 must be a 0, etc.).
 138                     throw new ArgumentException(SR.Argument_InvalidNativeDigitValue, propertyName);
 139                 }
 140             }
 141         }
 142
 143         private static void VerifyDigitSubstitution(DigitShapes digitSub, string propertyName)
 144         {
 145             switch (digitSub)
 146             {
 147                 case DigitShapes.Context:
 148                 case DigitShapes.None:
 149                 case DigitShapes.NativeNational:
 150                     // Success.
 151                     break;
 152
 153                 default:
 154                     throw new ArgumentException(SR.Argument_InvalidDigitSubstitution, propertyName);
 155             }
 156         }
 157
 158         internal bool HasInvariantNumberSigns => _hasInvariantNumberSigns;
 159
 160         private void UpdateHasInvariantNumberSigns()
 161         {
 162             _hasInvariantNumberSigns = _positiveSign == "+" && _negativeSign == "-";
 163         }
 164
 165         internal NumberFormatInfo(CultureData? cultureData)
 166         {
 167             if (cultureData != null)
 168             {
 169                 // We directly use fields here since these data is coming from data table or Win32, so we
 170                 // don't need to verify their values (except for invalid parsing situations).
 171                 cultureData.GetNFIValues(this);
 172
 173                 UpdateHasInvariantNumberSigns();
 174             }
 175         }
 176
 177         private void VerifyWritable()
 178         {
 179             if (_isReadOnly)
 180             {
 181                 throw new InvalidOperationException(SR.InvalidOperation_ReadOnly);
 182             }
 183         }
 184
 185         /// <summary>
 186         /// Returns a default NumberFormatInfo that will be universally
 187         /// supported and constant irrespective of the current culture.
 188         /// Used by FromString methods.
 189         /// </summary>
 190         public static NumberFormatInfo InvariantInfo => s_invariantInfo ??=
 191             // Lazy create the invariant info. This cannot be done in a .cctor because exceptions can
 192             // be thrown out of a .cctor stack that will need this.
 193             new NumberFormatInfo { _isReadOnly = true };
 194
 195         public static NumberFormatInfo GetInstance(IFormatProvider? formatProvider)
 196         {
 197             return formatProvider == null ?
 198                 CurrentInfo : // Fast path for a null provider
 199                 GetProviderNonNull(formatProvider);
 200
 201             static NumberFormatInfo GetProviderNonNull(IFormatProvider provider)
 202             {
 203                 // Fast path for a regular CultureInfo
 204                 if (provider is CultureInfo cultureProvider && !cultureProvider._isInherited)
 205                 {
 206                     return cultureProvider._numInfo ?? cultureProvider.NumberFormat;
 207                 }
 208
 209                 return
 210                     provider as NumberFormatInfo ?? // Fast path for an NFI
 211                     provider.GetFormat(typeof(NumberFormatInfo)) as NumberFormatInfo ??
 212                     CurrentInfo;
 213             }
 214         }
 215
 216         public object Clone()
 217         {
 218             NumberFormatInfo n = (NumberFormatInfo)MemberwiseClone();
 219             n._isReadOnly = false;
 220             return n;
 221         }
 222
 223         public int CurrencyDecimalDigits
 224         {
 225             get => _currencyDecimalDigits;
 226             set
 227             {
 228                 if (value < 0 || value > 99)
 229                 {
 230                     throw new ArgumentOutOfRangeException(
 231                         nameof(value),
 232                         value,
 233                         SR.Format(SR.ArgumentOutOfRange_Range, 0, 99));
 234                 }
 235
 236                 VerifyWritable();
 237                 _currencyDecimalDigits = value;
 238             }
 239         }
 240
 241         public string CurrencyDecimalSeparator
 242         {
 243             get => _currencyDecimalSeparator;
 244             set
 245             {
 246                 VerifyWritable();
 247                 VerifyDecimalSeparator(value, nameof(value));
 248                 _currencyDecimalSeparator = value;
 249             }
 250         }
 251
 252         public bool IsReadOnly => _isReadOnly;
 253
 254         /// <summary>
 255         /// Check the values of the groupSize array.
 256         /// Every element in the groupSize array should be between 1 and 9
 257         /// except the last element could be zero.
 258         /// </summary>
 259         internal static void CheckGroupSize(string propName, int[] groupSize)
 260         {
 261             for (int i = 0; i < groupSize.Length; i++)
 262             {
 263                 if (groupSize[i] < 1)
 264                 {
 265                     if (i == groupSize.Length - 1 && groupSize[i] == 0)
 266                     {
 267                         return;
 268                     }
 269
 270                     throw new ArgumentException(SR.Argument_InvalidGroupSize, propName);
 271                 }
 272                 else if (groupSize[i] > 9)
 273                 {
 274                     throw new ArgumentException(SR.Argument_InvalidGroupSize, propName);
 275                 }
 276             }
 277         }
 278
 279         public int[] CurrencyGroupSizes
 280         {
 281             get => (int[])_currencyGroupSizes.Clone();
 282             set
 283             {
 284                 if (value == null)
 285                 {
 286                     throw new ArgumentNullException(nameof(value));
 287                 }
 288
 289                 VerifyWritable();
 290
 291                 int[] inputSizes = (int[])value.Clone();
 292                 CheckGroupSize(nameof(value), inputSizes);
 293                 _currencyGroupSizes = inputSizes;
 294             }
 295         }
 296
 297         public int[] NumberGroupSizes
 298         {
 299             get => (int[])_numberGroupSizes.Clone();
 300             set
 301             {
 302                 if (value == null)
 303                 {
 304                     throw new ArgumentNullException(nameof(value));
 305                 }
 306
 307                 VerifyWritable();
 308
 309                 int[] inputSizes = (int[])value.Clone();
 310                 CheckGroupSize(nameof(value), inputSizes);
 311                 _numberGroupSizes = inputSizes;
 312             }
 313         }
 314
 315         public int[] PercentGroupSizes
 316         {
 317             get => (int[])_percentGroupSizes.Clone();
 318             set
 319             {
 320                 if (value == null)
 321                 {
 322                     throw new ArgumentNullException(nameof(value));
 323                 }
 324
 325                 VerifyWritable();
 326                 int[] inputSizes = (int[])value.Clone();
 327                 CheckGroupSize(nameof(value), inputSizes);
 328                 _percentGroupSizes = inputSizes;
 329             }
 330         }
 331
 332         public string CurrencyGroupSeparator
 333         {
 334             get => _currencyGroupSeparator;
 335             set
 336             {
 337                 VerifyWritable();
 338                 VerifyGroupSeparator(value, nameof(value));
 339                 _currencyGroupSeparator = value;
 340             }
 341         }
 342
 343         public string CurrencySymbol
 344         {
 345             get => _currencySymbol;
 346             set
 347             {
 348                 if (value == null)
 349                 {
 350                     throw new ArgumentNullException(nameof(value));
 351                 }
 352
 353                 VerifyWritable();
 354                 _currencySymbol = value;
 355             }
 356         }
 357
 358         /// <summary>
 359         /// Returns the current culture's NumberFormatInfo. Used by Parse methods.
 360         /// </summary>
 361
 362         public static NumberFormatInfo CurrentInfo
 363         {
 364             get
 365             {
 366                 System.Globalization.CultureInfo culture = CultureInfo.CurrentCulture;
 367                 if (!culture._isInherited)
 368                 {
 369                     NumberFormatInfo? info = culture._numInfo;
 370                     if (info != null)
 371                     {
 372                         return info;
 373                     }
 374                 }
 375                 // returns non-nullable when passed typeof(NumberFormatInfo)
 376                 return (NumberFormatInfo)culture.GetFormat(typeof(NumberFormatInfo))!;
 377             }
 378         }
 379
 380         public string NaNSymbol
 381         {
 382             get => _nanSymbol;
 383             set
 384             {
 385                 if (value == null)
 386                 {
 387                     throw new ArgumentNullException(nameof(value));
 388                 }
 389
 390                 VerifyWritable();
 391                 _nanSymbol = value;
 392             }
 393         }
 394
 395         public int CurrencyNegativePattern
 396         {
 397             get => _currencyNegativePattern;
 398             set
 399             {
 400                 if (value < 0 || value > 15)
 401                 {
 402                     throw new ArgumentOutOfRangeException(
 403                         nameof(value),
 404                         value,
 405                         SR.Format(SR.ArgumentOutOfRange_Range, 0, 15));
 406                 }
 407
 408                 VerifyWritable();
 409                 _currencyNegativePattern = value;
 410             }
 411         }
 412
 413         public int NumberNegativePattern
 414         {
 415             get => _numberNegativePattern;
 416             set
 417             {
 418                 // NOTENOTE: the range of value should correspond to negNumberFormats[] in vm\COMNumber.cpp.
 419                 if (value < 0 || value > 4)
 420                 {
 421                     throw new ArgumentOutOfRangeException(
 422                         nameof(value),
 423                         value,
 424                         SR.Format(SR.ArgumentOutOfRange_Range, 0, 4));
 425                 }
 426
 427                 VerifyWritable();
 428                 _numberNegativePattern = value;
 429             }
 430         }
 431
 432         public int PercentPositivePattern
 433         {
 434             get => _percentPositivePattern;
 435             set
 436             {
 437                 // NOTENOTE: the range of value should correspond to posPercentFormats[] in vm\COMNumber.cpp.
 438                 if (value < 0 || value > 3)
 439                 {
 440                     throw new ArgumentOutOfRangeException(
 441                         nameof(value),
 442                         value,
 443                         SR.Format(SR.ArgumentOutOfRange_Range, 0, 3));
 444                 }
 445
 446                 VerifyWritable();
 447                 _percentPositivePattern = value;
 448             }
 449         }
 450
 451         public int PercentNegativePattern
 452         {
 453             get => _percentNegativePattern;
 454             set
 455             {
 456                 // NOTENOTE: the range of value should correspond to posPercentFormats[] in vm\COMNumber.cpp.
 457                 if (value < 0 || value > 11)
 458                 {
 459                     throw new ArgumentOutOfRangeException(
 460                         nameof(value),
 461                         value,
 462                         SR.Format(SR.ArgumentOutOfRange_Range, 0, 11));
 463                 }
 464
 465                 VerifyWritable();
 466                 _percentNegativePattern = value;
 467             }
 468         }
 469
 470         public string NegativeInfinitySymbol
 471         {
 472             get => _negativeInfinitySymbol;
 473             set
 474             {
 475                 if (value == null)
 476                 {
 477                     throw new ArgumentNullException(nameof(value));
 478                 }
 479
 480                 VerifyWritable();
 481                 _negativeInfinitySymbol = value;
 482             }
 483         }
 484
 485         public string NegativeSign
 486         {
 487             get => _negativeSign;
 488             set
 489             {
 490                 if (value == null)
 491                 {
 492                     throw new ArgumentNullException(nameof(value));
 493                 }
 494
 495                 VerifyWritable();
 496                 _negativeSign = value;
 497                 UpdateHasInvariantNumberSigns();
 498             }
 499         }
 500
 501         public int NumberDecimalDigits
 502         {
 503             get => _numberDecimalDigits;
 504             set
 505             {
 506                 if (value < 0 || value > 99)
 507                 {
 508                     throw new ArgumentOutOfRangeException(
 509                         nameof(value),
 510                         value,
 511                         SR.Format(SR.ArgumentOutOfRange_Range, 0, 99));
 512                 }
 513
 514                 VerifyWritable();
 515                 _numberDecimalDigits = value;
 516             }
 517         }
 518
 519         public string NumberDecimalSeparator
 520         {
 521             get => _numberDecimalSeparator;
 522             set
 523             {
 524                 VerifyWritable();
 525                 VerifyDecimalSeparator(value, nameof(value));
 526                 _numberDecimalSeparator = value;
 527             }
 528         }
 529
 530         public string NumberGroupSeparator
 531         {
 532             get => _numberGroupSeparator;
 533             set
 534             {
 535                 VerifyWritable();
 536                 VerifyGroupSeparator(value, nameof(value));
 537                 _numberGroupSeparator = value;
 538             }
 539         }
 540
 541         public int CurrencyPositivePattern
 542         {
 543             get => _currencyPositivePattern;
 544             set
 545             {
 546                 if (value < 0 || value > 3)
 547                 {
 548                     throw new ArgumentOutOfRangeException(
 549                         nameof(value),
 550                         value,
 551                         SR.Format(SR.ArgumentOutOfRange_Range, 0, 3));
 552                 }
 553
 554                 VerifyWritable();
 555                 _currencyPositivePattern = value;
 556             }
 557         }
 558
 559         public string PositiveInfinitySymbol
 560         {
 561             get => _positiveInfinitySymbol;
 562             set
 563             {
 564                 if (value == null)
 565                 {
 566                     throw new ArgumentNullException(nameof(value));
 567                 }
 568
 569                 VerifyWritable();
 570                 _positiveInfinitySymbol = value;
 571             }
 572         }
 573
 574         public string PositiveSign
 575         {
 576             get => _positiveSign;
 577             set
 578             {
 579                 if (value == null)
 580                 {
 581                     throw new ArgumentNullException(nameof(value));
 582                 }
 583
 584                 VerifyWritable();
 585                 _positiveSign = value;
 586                 UpdateHasInvariantNumberSigns();
 587             }
 588         }
 589
 590         public int PercentDecimalDigits
 591         {
 592             get => _percentDecimalDigits;
 593             set
 594             {
 595                 if (value < 0 || value > 99)
 596                 {
 597                     throw new ArgumentOutOfRangeException(
 598                         nameof(value),
 599                         value,
 600                         SR.Format(SR.ArgumentOutOfRange_Range, 0, 99));
 601                 }
 602
 603                 VerifyWritable();
 604                 _percentDecimalDigits = value;
 605             }
 606         }
 607
 608         public string PercentDecimalSeparator
 609         {
 610             get => _percentDecimalSeparator;
 611             set
 612             {
 613                 VerifyWritable();
 614                 VerifyDecimalSeparator(value, nameof(value));
 615                 _percentDecimalSeparator = value;
 616             }
 617         }
 618
 619         public string PercentGroupSeparator
 620         {
 621             get => _percentGroupSeparator;
 622             set
 623             {
 624                 VerifyWritable();
 625                 VerifyGroupSeparator(value, nameof(value));
 626                 _percentGroupSeparator = value;
 627             }
 628         }
 629
 630         public string PercentSymbol
 631         {
 632             get => _percentSymbol;
 633             set
 634             {
 635                 if (value == null)
 636                 {
 637                     throw new ArgumentNullException(nameof(value));
 638                 }
 639
 640                 VerifyWritable();
 641                 _percentSymbol = value;
 642             }
 643         }
 644
 645         public string PerMilleSymbol
 646         {
 647             get => _perMilleSymbol;
 648             set
 649             {
 650                 if (value == null)
 651                 {
 652                     throw new ArgumentNullException(nameof(value));
 653                 }
 654
 655                 VerifyWritable();
 656                 _perMilleSymbol = value;
 657             }
 658         }
 659
 660         public string[] NativeDigits
 661         {
 662             get => (string[])_nativeDigits.Clone();
 663             set
 664             {
 665                 VerifyWritable();
 666                 VerifyNativeDigits(value, nameof(value));
 667                 _nativeDigits = value;
 668             }
 669         }
 670
 671         public DigitShapes DigitSubstitution
 672         {
 673             get => (DigitShapes)_digitSubstitution;
 674             set
 675             {
 676                 VerifyWritable();
 677                 VerifyDigitSubstitution(value, nameof(value));
 678                 _digitSubstitution = (int)value;
 679             }
 680         }
 681
 682         public object? GetFormat(Type? formatType)
 683         {
 684             return formatType == typeof(NumberFormatInfo) ? this : null;
 685         }
 686
 687         public static NumberFormatInfo ReadOnly(NumberFormatInfo nfi)
 688         {
 689             if (nfi == null)
 690             {
 691                 throw new ArgumentNullException(nameof(nfi));
 692             }
 693
 694             if (nfi.IsReadOnly)
 695             {
 696                 return nfi;
 697             }
 698
 699             NumberFormatInfo info = (NumberFormatInfo)(nfi.MemberwiseClone());
 700             info._isReadOnly = true;
 701             return info;
 702         }
 703
 704         // private const NumberStyles InvalidNumberStyles = unchecked((NumberStyles) 0xFFFFFC00);
 705         private const NumberStyles InvalidNumberStyles = ~(NumberStyles.AllowLeadingWhite | NumberStyles.AllowTrailingWhite
 706                                                            | NumberStyles.AllowLeadingSign | NumberStyles.AllowTrailingSign
 707                                                            | NumberStyles.AllowParentheses | NumberStyles.AllowDecimalPoint
 708                                                            | NumberStyles.AllowThousands | NumberStyles.AllowExponent
 709                                                            | NumberStyles.AllowCurrencySymbol | NumberStyles.AllowHexSpecifier);
 710
 711         internal static void ValidateParseStyleInteger(NumberStyles style)
 712         {
 713             // Check for undefined flags or invalid hex number flags
 714             if ((style & (InvalidNumberStyles | NumberStyles.AllowHexSpecifier)) != 0
 715                 && (style & ~NumberStyles.HexNumber) != 0)
 716             {
 717                 throwInvalid(style);
 718
 719                 void throwInvalid(NumberStyles value)
 720                 {
 721                     if ((value & InvalidNumberStyles) != 0)
 722                     {
 723                         throw new ArgumentException(SR.Argument_InvalidNumberStyles, nameof(style));
 724                     }
 725
 726                     throw new ArgumentException(SR.Arg_InvalidHexStyle);
 727                 }
 728             }
 729         }
 730
 731         internal static void ValidateParseStyleFloatingPoint(NumberStyles style)
 732         {
 733             // Check for undefined flags or hex number
 734             if ((style & (InvalidNumberStyles | NumberStyles.AllowHexSpecifier)) != 0)
 735             {
 736                 throwInvalid(style);
 737
 738                 void throwInvalid(NumberStyles value)
 739                 {
 740                     if ((value & InvalidNumberStyles) != 0)
 741                     {
 742                         throw new ArgumentException(SR.Argument_InvalidNumberStyles, nameof(style));
 743                     }
 744
 745                     throw new ArgumentException(SR.Arg_HexStyleNotSupported);
 746                 }
 747             }
 748         }
 749     }
 750 }