C# NumberStyles类代码示例

		public static int Parse(string s, NumberStyles style)
		{
			if (style == NumberStyles.HexNumber)
				return Native.API.intval(s, 16);

			return Native.API.intval(s);
		}

	public static ulong Parse(String s, NumberStyles style,
							  IFormatProvider provider)
			{
				NumberParser.ValidateIntegerStyle(style);
				return NumberParser.ParseUInt64
					(s, style, NumberFormatInfo.GetInstance(provider), 0);
			}

        public static bool TryParse(string s, NumberStyles style, IFormatProvider provider, out sbyte result)
        {
            // Todo, consider how to implemente style and provider
            throw new NotImplementedException();

            //return TryParse(s, out result);
        }

	// Parsing methods.
	public static byte Parse(String s, NumberStyles style,
							 IFormatProvider provider)
			{
				NumberParser.ValidateIntegerStyle(style);
				return Convert.ToByte(NumberParser.ParseUInt32
					(s, style, NumberFormatInfo.GetInstance(provider), 256));
			}

 /// <summary>
 /// Parses aint value for the given string using the given number style and using
 /// the invariant culture parser.
 /// </summary>
 /// <param name="toParse">The value to parse.</param>
 /// <param name="ns">The number style used to parse the int value.</param>
 /// <returns>The int value of the string.</returns>
 public static int ccParseInt(string toParse, NumberStyles ns)
 {
     // http://www.cocos2d-x.org/boards/17/topics/11690
     // Issue #17
     // https://github.com/cocos2d/cocos2d-x-for-xna/issues/17
     return (int.Parse(toParse, ns, System.Globalization.CultureInfo.InvariantCulture));
 }

		private static bool CheckStyle(NumberStyles style, bool tryParse, ref Exception exc)
		{
			if ((style & NumberStyles.AllowHexSpecifier) != 0)
			{
				NumberStyles ne = style ^ NumberStyles.AllowHexSpecifier;
				if ((ne & NumberStyles.AllowLeadingWhite) != 0)
				{
					ne ^= NumberStyles.AllowLeadingWhite;
				}
				if ((ne & NumberStyles.AllowTrailingWhite) != 0)
				{
					ne ^= NumberStyles.AllowTrailingWhite;
				}
				if (ne != 0)
				{
					if (!tryParse)
					{
						exc = new ArgumentException(
							"With AllowHexSpecifier only " +
							"AllowLeadingWhite and AllowTrailingWhite " +
							"are permitted.");
					}
					return false;
				}
			}

			return true;
		}

	// Parsing methods.
	public static short Parse(String s, NumberStyles style,
							  IFormatProvider provider)
			{
				NumberParser.ValidateIntegerStyle(style);
				return Convert.ToInt16(NumberParser.ParseInt32
					(s, style, NumberFormatInfo.GetInstance(provider), 32768));
			}

        /// <summary>
        /// Tries to convert a string representation into a numeric value.
        /// </summary>
        public static bool TryParseDecimal(string s, NumberStyles style, out decimal result)
        {
#if PocketPC
            try
            {
                result = decimal.Parse(s, style, CultureInfo.InvariantCulture);
                return true;
            }
            catch (ArgumentException)
            {
                result = Decimal.Zero;
                return false;
            }
            catch (FormatException)
            {
                result = Decimal.Zero;
                return false;
            }
            catch (OverflowException)
            {
                result = Decimal.Zero;
                return false;
            }

#else
            return decimal.TryParse(s, style, CultureInfo.InvariantCulture, out result);
#endif
        }

 public static bool IsNumeric(this string text, NumberStyles style = NumberStyles.Number, CultureInfo culture = null)
 {
     double number;
     if (culture == null)
         culture = CultureInfo.InvariantCulture;
     return double.TryParse(text, style, culture, out number) && !string.IsNullOrWhiteSpace(text);
 }

 public ParseTest(String str, Decimal d, NumberStyles style)
 {
     this.str = str;
     this.exceptionFlag = false;
     this.style = style;
     this.d = d;
 }

 private void InitializeMembers()
 {
     this.encoding = null;
     this.culture = null;
     this.numberStyle = NumberStyles.Float;
     this.dateTimeStyle = DateTimeStyles.None;
 }

 public static Double ConvertToNumeric(object value, IFormatProvider provider, NumberStyles style)
 {
     var parsableString = value as String;
     if (parsableString == null)
     {
         var formatter = value as IFormattable;
         if (formatter != null)
         {
             string format = GeneralFormatter;
             if (formatter is Single || formatter is Double)
             {
                 format = RoundtripFormatter;
             }
             parsableString = formatter.ToString(format, provider);
         }
     }
     if (parsableString != null)
     {
         Double number;
         if (Double.TryParse(parsableString, style, provider, out number))
         {
             return number;
         }
     }
     throw new FormatException(Resources.Converter_Value_cant_be_parsed_to_numeric);
 }

        /// <summary>Converts the string representation of a money value to its <see cref="Money"/> equivalent.</summary>
        /// <param name="value">The string representation of the number to convert.</param>
        /// <param name="style">A bitwise combination of enumeration values that indicates the permitted format of value. A typical value to specify is <see cref="NumberStyles.Currency"/>.</param>
        /// <param name="provider">An object that supplies culture-specific parsing information about <i>value</i>.</param>
        /// <param name="currency">The currency to use for parsing the string representation.</param>
        /// <returns>The equivalent to the money amount contained in <i>value</i>.</returns>
        /// <exception cref="System.ArgumentNullException"><i>value</i> is <b>null</b> or empty.</exception> 
        /// <exception cref="System.FormatException"><i>value</i> is not in the correct format or the currency sign matches with multiple known currencies!</exception>
        /// <exception cref="System.OverflowException"><i>value</i> represents a number less than <see cref="Decimal.MinValue"/> or greater than <see cref="Decimal.MaxValue"/>.</exception>
        public static Money Parse(string value, NumberStyles style, IFormatProvider provider, Currency currency)
        {
            if (string.IsNullOrWhiteSpace(value))
                throw new ArgumentNullException(nameof(value));

            decimal amount = decimal.Parse(value, style, GetNumberFormatInfo(currency, provider));
            return new Money(amount, currency);
        }

 public CsvColumnAttribute(string name, int fieldIndex, bool canBeNull,
             string outputFormat, NumberStyles numberStyle, int charLength)
     : base(name, fieldIndex, canBeNull)
 {
     NumberStyle = numberStyle;
     OutputFormat = outputFormat;
     CharLength = charLength;
 }

 /// <summary>
 ///   Mono does not support the BigInteger.TryParse method. In practice,
 ///   we seldom actually need to parse huge integers, so it makes sense
 ///   to support most real-life cases by simply trying to parse using
 ///   Int64, and only falling back if needed.
 /// </summary>
 internal static BigInteger Parse(string str, NumberStyles style) {
     UInt64 parsed;
     if (UInt64.TryParse(str, style, NumberFormatInfo.CurrentInfo, out parsed)) {
         return new BigInteger(parsed);
     } else {
         // Throws on Mono 3.2.8
         return BigInteger.Parse(str, style);
     }
 }