public static int Parse(string s, NumberStyles style) { if (style == NumberStyles.HexNumber) return Native.API.intval(s, 16); return Native.API.intval(s); }
/// <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; }
public ParseTest(String str, Decimal d, NumberStyles style) { this.str = str; this.exceptionFlag = false; this.style = style; this.d = d; }
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 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)); }
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); }
private void InitializeMembers() { this.encoding = null; this.culture = null; this.numberStyle = NumberStyles.Float; this.dateTimeStyle = DateTimeStyles.None; }
public static ulong Parse(String s, NumberStyles style, IFormatProvider provider) { NumberParser.ValidateIntegerStyle(style); return NumberParser.ParseUInt64 (s, style, NumberFormatInfo.GetInstance(provider), 0); }
// 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 CsvColumnAttribute(string name, int fieldIndex, bool canBeNull, string outputFormat, NumberStyles numberStyle, int charLength) : base(name, fieldIndex, canBeNull) { NumberStyle = numberStyle; OutputFormat = outputFormat; CharLength = charLength; }
/// <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 static bool TryParse(string s, NumberStyles style, IFormatProvider provider, out byte result) { // Todo, consider how to implemente style and provider // Exponent, "1E0", "1e3"... // Decimal point "1.0", "3.5" throw new NotImplementedException(); //return TryParse(s, out result); }
public static sbyte? ToSByteOrNull(this string s, NumberStyles numberStyles, IFormatProvider formatProvider) { sbyte result; if(sbyte.TryParse(s, numberStyles, formatProvider,out result)) { return result; } return null; }
public static sbyte? ToSByteOrNull(this string s, NumberStyles numberStyles) { sbyte result; if(sbyte.TryParse(s, numberStyles, null, out result)) { return result; } return null; }
public static sbyte ToSByteOrDefault(this string s, NumberStyles numberStyles, IFormatProvider formatProvider, sbyte defaultValue = default(sbyte)) { sbyte result; if(sbyte.TryParse(s,numberStyles, formatProvider, out result)) { return result; } return defaultValue; }
/// <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); } }
public UnparsedNumber(string value, Type type, NumberStyles numberStyles) { Require.NotEmpty(value, "value"); Require.NotNull(type, "type"); Value = value; Type = type; NumberStyles = numberStyles; }
/// <summary> /// Converts the string representation of a number in a specified numberStyle and culture-specific /// format to its System.Byte equivalent. A return value indicates whether the /// conversion succeeded or failed. /// </summary> /// <param name="value"> /// A string containing a number to convert. The string is interpreted using /// the numberStyle specified by numberStyle. /// </param> /// <param name="numberStyle"> /// A bitwise combination of enumeration values that indicates the numberStyle elements /// that can be present in s. A typical value to specify is System.Globalization.NumberStyles.Integer. /// </param> /// <param name="formatProvider"> /// An object that supplies culture-specific formatting information about s. /// If formatProvider is null, the thread current culture is used. /// </param> /// <param name="outValue"> /// When this method returns, contains the 8-bit unsigned integer value equivalent /// to the number contained in s if the conversion succeeded, or zero if the /// conversion failed. The conversion fails if the s parameter is null or System.String.Empty, /// is not of the correct format, or represents a number less than System.Byte.MinValue /// or greater than System.Byte.MaxValue. This parameter is passed uninitialized. /// </param> /// <returns>Returns true if the parsing was successful, otherwise false.</returns> public static Boolean TryParsByte( this String value, NumberStyles numberStyle, IFormatProvider formatProvider, out Byte outValue ) { value.ThrowIfNull( nameof( value ) ); formatProvider.ThrowIfNull( nameof( formatProvider ) ); return Byte.TryParse( value, numberStyle, formatProvider, out outValue ); }
/// <summary> /// Converts the string representation of a number in a specified numberStyles and culture-specific /// format to its 32-bit signed integer equivalent. A return value indicates /// whether the conversion succeeded or failed. /// </summary> /// <param name="value"> /// A string containing a number to convert. The string is interpreted using /// </param> /// <param name="numberStyles"> /// A bitwise combination of enumeration values that indicates the numberStyles elements /// that can be present in value. A typical value to specify is <see cref="NumberStyles.Integer" />. /// </param> /// <param name="formatProvider">An object that supplies culture-specific formatting information about value.</param> /// <param name="outValue"> /// When this method returns, contains the 32-bit signed integer value equivalent /// to the number contained in s, if the conversion succeeded, or zero if the /// conversion failed. The conversion fails if the s parameter is null or System.String.Empty, /// is not in a format compliant with numberStyles, or represents a number less than /// System.Int32.MinValue or greater than System.Int32.MaxValue. This parameter /// is passed uninitialized. /// </param> /// <returns>Returns true if the parsing was successful, otherwise false.</returns> public static Boolean TryParsInt32( this String value, NumberStyles numberStyles, IFormatProvider formatProvider, out Int32 outValue ) { value.ThrowIfNull( nameof( value ) ); formatProvider.ThrowIfNull( nameof( formatProvider ) ); return Int32.TryParse( value, numberStyles, formatProvider, out outValue ); }
/// <summary> /// Converts the string representation of a number to its System.Decimal equivalent /// using the specified numberStyle and culture-specific format. A return value indicates /// whether the conversion succeeded or failed. /// </summary> /// <param name="value">The string representation of the number to convert.</param> /// <param name="numberStyle"> /// A bitwise combination of enumeration values that indicates the permitted /// format of value. A typical value to specify is System.Globalization.NumberStyles.Number. /// </param> /// <param name="formatProvider">An object that supplies culture-specific parsing information about value.</param> /// <param name="outValue"> /// When this method returns, contains the System.Decimal number that is equivalent /// to the numeric value contained in s, if the conversion succeeded, or is zero /// if the conversion failed. The conversion fails if the s parameter is null /// or System.String.Empty, is not in a format compliant with numberStyle, or represents /// a number less than System.Decimal.MinValue or greater than System.Decimal.MaxValue. /// This parameter is passed uninitialized. /// </param> /// <returns>Returns true if the parsing was successful, otherwise false.</returns> public static Boolean TryParsDecimal( this String value, NumberStyles numberStyle, IFormatProvider formatProvider, out Decimal outValue ) { value.ThrowIfNull( nameof( value ) ); formatProvider.ThrowIfNull( nameof( formatProvider ) ); return Decimal.TryParse( value, NumberStyles.Any, CultureInfo.InvariantCulture, out outValue ); }
public static bool IsDouble(string strValue, NumberStyles numberStyles) { bool isNum = true; double value; if (!String.IsNullOrEmpty(strValue)) isNum = (double.TryParse(Convert.ToString(strValue), numberStyles, CultureInfo.CurrentCulture, out value) || double.TryParse(Convert.ToString(strValue), numberStyles, CultureInfo.InvariantCulture, out value)); return isNum; }
/// <summary> /// Converts a string to a <see cref="sbyte" />. /// </summary> /// <param name="str">The string to convert.</param> /// <param name="styles">The options.</param> /// <param name="provider">The custom provider to use.</param> /// <returns> /// The converted value or <see langword="null" /> if <paramref name="str" /> is /// <see langword="null" /> or contains whitespaces only. /// </returns> /// <exception cref="FormatException"> /// <paramref name="str" /> has an invalid format. /// </exception> /// <exception cref="OverflowException"> /// <paramref name="str" /> represents a value that is too big. /// </exception> public static sbyte? ToSByte(this string str, NumberStyles styles = NumberStyles.Integer, IFormatProvider provider = null) { if (string.IsNullOrWhiteSpace(str)) { return null; } return provider == null ? sbyte.Parse(str, styles) : sbyte.Parse(str, styles, provider); }
/// <summary> /// Convert string value to long value /// </summary> /// <param name="strValue">string value to convert</param> /// <param name="defaultValue">default value when error on convert value</param> /// <param name="allowZero">allow zero on convert</param> /// <param name="numberStyle">string number style</param> /// <param name="culture">current culture</param> /// <returns>long value</returns> public static long TryParseLong(this string strValue, long defaultValue, bool allowZero, NumberStyles numberStyle, CultureInfo culture) { long longValue; var converted = long.TryParse(strValue, numberStyle, culture, out longValue); return converted ? longValue == 0 && !allowZero ? defaultValue : longValue : defaultValue; }
/// <summary> /// Convert float string value in float value /// </summary> /// <param name="strValue">string to convert</param> /// <param name="defaultValue">default value to return on convert error</param> /// <param name="allowZero">allow 0 valuen on convert</param> /// <param name="numberStyle">number style to convert</param> /// <param name="culture">float culture origin</param> /// <returns>float value</returns> public static float TryParseFloat(this string strValue, float defaultValue, bool allowZero, NumberStyles numberStyle, CultureInfo culture) { float floatValue; var converted = float.TryParse(strValue, numberStyle, culture, out floatValue); return converted ? floatValue.Equals(0) && !allowZero ? defaultValue : floatValue : defaultValue; }
/// <summary> /// <para>Convert string to short</para> /// <para>Set default value on error</para> /// </summary> /// <param name="strValue">string value</param> /// <param name="defaultValue">default value</param> /// <param name="allowZero">allow 0 on convert.</param> /// <param name="numberStyle">number style to convert</param> /// <param name="culture">culture origin</param> /// <returns>converted value or default value</returns> public static short TryParseShort(this string strValue, short defaultValue, bool allowZero, NumberStyles numberStyle, CultureInfo culture) { short shortValue; var converted = short.TryParse(strValue, numberStyle, culture, out shortValue); return converted ? shortValue == 0 && !allowZero ? defaultValue : shortValue : defaultValue; }
/// <summary> /// Convert double string value in double value /// </summary> /// <param name="strValue">string to convert</param> /// <param name="defaultValue">default value to return on convert error</param> /// <param name="allowZero">allow 0 valuen on convert</param> /// <param name="numberStyle">number style to convert</param> /// <param name="culture">double culture origin</param> /// <returns>double value</returns> public static double TryParseDouble(this string strValue, double defaultValue, bool allowZero, NumberStyles numberStyle, CultureInfo culture) { double doubleValue; var converted = double.TryParse(strValue, numberStyle, culture, out doubleValue); return converted ? doubleValue.Equals(0) && !allowZero ? defaultValue : doubleValue : defaultValue; }
/// <summary> /// Converts a string to an <see cref="uint" />. /// </summary> /// <param name="str">The string to convert.</param> /// <param name="styles">The options.</param> /// <param name="provider">The custom provider to use.</param> /// <returns> /// The converted value or <see langword="null" /> if <paramref name="str" /> is /// <see langword="null" /> or contains whitespaces only. /// </returns> /// <exception cref="FormatException"> /// <paramref name="str" /> has an invalid format. /// </exception> /// <exception cref="OverflowException"> /// <paramref name="str" /> represents a value that is too big. /// </exception> public static uint? ToUInt32(this string str, NumberStyles styles = NumberStyles.Integer, IFormatProvider provider = null) { if (string.IsNullOrWhiteSpace(str)) { return null; } return provider == null ? uint.Parse(str, styles) : uint.Parse(str, styles, provider); }
public static bool TryParse(ReadOnlySpan <char> s, NumberStyles style, IFormatProvider provider, out int result) { NumberFormatInfo.ValidateParseStyleInteger(style); return(Number.TryParseInt32(s, style, NumberFormatInfo.GetInstance(provider), out result, out _)); }
/// <summary> /// Parse string array in decimal array /// </summary> /// <param name="strValue">string to parse</param> /// <param name="defaultValue">default value when default tryparse</param> /// <param name="allowDefaultConversion">Allow default tryparse values</param> /// <param name="numberStyle">number style to convert</param> /// <param name="culture">culture origin</param> /// <returns>decimal array</returns> public static decimal[] TryParseDecimalArray(this string strValue, decimal[] defaultValue, bool allowDefaultConversion, NumberStyles numberStyle, CultureInfo culture) { if (String.IsNullOrEmpty(strValue)) { return defaultValue ?? new decimal[] { } } ; var decimalList = defaultValue != null ? defaultValue.ToList() : new List <decimal>(); foreach (var l in strValue.Split(',')) { var strDecimal = l ?? ""; if (String.IsNullOrEmpty(strDecimal)) { if (allowDefaultConversion) { decimalList.Add(BasePrimitivesExtensions.GetDefaultDecimalConversionValue()); } continue; } decimal decimalConvert; if (!decimal.TryParse(strDecimal, numberStyle, culture, out decimalConvert)) { if (allowDefaultConversion) { decimalList.Add(BasePrimitivesExtensions.GetDefaultDecimalConversionValue()); } } else { decimalList.Add(decimalConvert); } } return(decimalList.ToArray()); }
/// <include file='doc\Int32.uex' path='docs/doc[@for="Int32.Parse1"]/*' /> public static int Parse(String s, NumberStyles style) { NumberFormatInfo.ValidateParseStyle(style); return Parse(s, style, null); }
public static int Parse(String s, NumberStyles style) { NumberFormatInfo.ValidateParseStyleInteger(style); return(Number.ParseInt32(s, style, NumberFormatInfo.CurrentInfo)); }
public static int Parse(String s, NumberStyles style, IFormatProvider provider) { NumberFormatInfo.ValidateParseStyleInteger(style); return(Number.ParseInt32(s, style, NumberFormatInfo.GetInstance(provider))); }
public static Either <TLeft, sbyte> ParseToSbyte <TLeft>(this string source, NumberStyles style, TLeft left) { return(SbyteParser.Parse <TLeft>(source, style, left)); }
public static Boolean TryParse(String s, NumberStyles style, IFormatProvider provider, out Single result) { NumberFormatInfo.ValidateParseStyleFloatingPoint(style); return(TryParse(s, style, NumberFormatInfo.GetInstance(provider), out result)); }
private static bool TryParse(ReadOnlySpan <char> s, NumberStyles style, NumberFormatInfo info, out double result) { return(Number.TryParseDouble(s, style, info, out result)); }
/// <summary> /// Convert decimal string value in decimal value /// </summary> /// <param name="strValue">string to convert</param> /// <param name="defaultValue">default value to return on convert error</param> /// <param name="allowZero">allow 0 valuen on convert</param> /// <param name="numberStyle">number style to convert</param> /// <param name="culture">decimal culture origin</param> /// <returns>decimal value</returns> public static decimal TryParseDecimal(this string strValue, decimal defaultValue, bool allowZero, NumberStyles numberStyle, CultureInfo culture) { decimal decimalValue; var converted = decimal.TryParse(strValue, numberStyle, culture, out decimalValue); return(converted ? decimalValue == 0 && !allowZero ? defaultValue : decimalValue : defaultValue); }
ValueTask <byte> IAsyncBinaryReader.ReadByteAsync(LengthFormat lengthFormat, DecodingContext context, NumberStyles style, IFormatProvider?provider, CancellationToken token) => StreamExtensions.ReadByteAsync(stream, lengthFormat, context, buffer, style, provider, token);
public static Raw_AniDB_Anime ProcessAnimeDetails(XmlDocument docAnime, int animeID) { // most of the genral anime data will be over written by the UDP command Raw_AniDB_Anime anime = new Raw_AniDB_Anime { AnimeID = animeID }; // check if there is any data if (docAnime?["anime"]?.Attributes["id"]?.Value == null) { logger.Warn("AniDB ProcessAnimeDetails - Received no or invalid info in XML"); return(null); } anime.Description = TryGetProperty(docAnime, "anime", "description")?.Replace('`', '\''); anime.AnimeTypeRAW = TryGetProperty(docAnime, "anime", "type"); string episodecount = TryGetProperty(docAnime, "anime", "episodecount"); int.TryParse(episodecount, out int epCount); anime.EpisodeCount = epCount; anime.EpisodeCountNormal = epCount; int convertedAirDate = AniDB.GetAniDBDateAsSeconds(TryGetProperty(docAnime, "anime", "startdate"), true); int convertedEndDate = AniDB.GetAniDBDateAsSeconds(TryGetProperty(docAnime, "anime", "enddate"), false); //anime.AirDate = TryGetProperty(docAnime, "anime", "startdate"); //anime.EndDate = TryGetProperty(docAnime, "anime", "enddate"); anime.AirDate = AniDB.GetAniDBDateAsDate(convertedAirDate); anime.EndDate = AniDB.GetAniDBDateAsDate(convertedEndDate); anime.BeginYear = anime.AirDate?.Year ?? 0; anime.EndYear = anime.EndDate?.Year ?? 0; //string enddate = TryGetProperty(docAnime, "anime", "enddate"); string restricted = docAnime["anime"].Attributes["restricted"]?.Value; if (bool.TryParse(restricted, out bool res)) { anime.Restricted = res ? 1 : 0; } else { anime.Restricted = 0; } anime.URL = TryGetProperty(docAnime, "anime", "url"); anime.Picname = TryGetProperty(docAnime, "anime", "picture"); anime.DateTimeUpdated = DateTime.Now; anime.DateTimeDescUpdated = anime.DateTimeUpdated; anime.ImageEnabled = 1; #region Related Anime XmlNodeList raItems = docAnime["anime"]["relatedanime"]?.GetElementsByTagName("anime"); if (raItems != null) { anime.RelatedAnimeIdsRAW = string.Empty; anime.RelatedAnimeTypesRAW = string.Empty; foreach (XmlNode node in raItems) { if (node?.Attributes?["id"]?.Value == null) { continue; } if (!int.TryParse(node.Attributes["id"].Value, out int id)) { continue; } int relType = ConvertReltTypeTextToEnum(TryGetAttribute(node, "type")); if (anime.RelatedAnimeIdsRAW.Length > 0) { anime.RelatedAnimeIdsRAW += "'"; } if (anime.RelatedAnimeTypesRAW.Length > 0) { anime.RelatedAnimeTypesRAW += "'"; } anime.RelatedAnimeIdsRAW += id.ToString(); anime.RelatedAnimeTypesRAW += relType.ToString(); } } #endregion #region Titles XmlNodeList titleItems = docAnime["anime"]["titles"]?.GetElementsByTagName("title"); if (titleItems != null) { foreach (XmlNode node in titleItems) { string titleType = node?.Attributes?["type"]?.Value?.Trim().ToLower(); if (string.IsNullOrEmpty(titleType)) { continue; } string languageType = node.Attributes["xml:lang"]?.Value?.Trim().ToLower(); if (string.IsNullOrEmpty(languageType)) { continue; } string titleValue = node.InnerText.Trim(); if (string.IsNullOrEmpty(titleValue)) { continue; } if (titleType.Trim().ToUpper().Equals("MAIN")) { anime.MainTitle = titleValue.Replace('`', '\''); } } } #endregion #region Ratings // init ratings anime.VoteCount = 0; anime.TempVoteCount = 0; anime.Rating = 0; anime.TempRating = 0; anime.ReviewCount = 0; anime.AvgReviewRating = 0; NumberStyles style = NumberStyles.Number; CultureInfo culture = CultureInfo.CreateSpecificCulture("en-GB"); XmlNodeList ratingItems = docAnime["anime"]["ratings"]?.ChildNodes; if (ratingItems == null) { return(anime); } foreach (XmlNode node in ratingItems) { string name = node?.Name?.Trim().ToLower(); if (string.IsNullOrEmpty(name)) { continue; } if (!int.TryParse(TryGetAttribute(node, "count"), out int iCount)) { continue; } if (!decimal.TryParse(node.InnerText.Trim(), style, culture, out decimal iRating)) { continue; } iRating = (int)Math.Round(iRating * 100); if (name.Equals("permanent")) { anime.VoteCount = iCount; anime.Rating = (int)iRating; } else if (name.Equals("temporary")) { anime.TempVoteCount = iCount; anime.TempRating = (int)iRating; } else if (name.Equals("review")) { anime.ReviewCount = iCount; anime.AvgReviewRating = (int)iRating; } } #endregion return(anime); }
public static bool TryParse(ReadOnlySpan <char> s, out Int16 result, NumberStyles style = NumberStyles.Integer, IFormatProvider provider = null) { NumberFormatInfo.ValidateParseStyleInteger(style); return(TryParse(s, style, NumberFormatInfo.GetInstance(provider), out result)); }
public override bool TryParse(string text, NumberStyles numberStyles, IFormatProvider culture, out int result) { return(int.TryParse(text, numberStyles, culture, out result)); }
public NullableSingleConverter(IFormatProvider formatProvider, NumberStyles numberStyles) : base(new SingleConverter(formatProvider, numberStyles)) { }
public NumericTextBox() { numberStyle = NumberStyles.Decimal; maxValue = uint.MaxValue - 1; //Value = 0; }
public static int Parse(ReadOnlySpan <char> s, NumberStyles style = NumberStyles.Integer, IFormatProvider provider = null) { NumberFormatInfo.ValidateParseStyleInteger(style); return(Number.ParseInt32(s, style, NumberFormatInfo.GetInstance(provider))); }
private static float Parse(String s, NumberStyles style, NumberFormatInfo info) { return(Number.ParseSingle(s, style, info)); }
public static float Parse(String s, NumberStyles style) { NumberFormatInfo.ValidateParseStyleFloatingPoint(style); return(Parse(s, style, NumberFormatInfo.CurrentInfo)); }
public static Boolean TryParse(String s, NumberStyles style, IFormatProvider provider, out Int64 result) { UInt32.ValidateParseStyleInteger(style); return(FormatProvider.TryParseInt64(s, style, provider, out result)); }
// Parses an integer from a String in the given style. If // a NumberFormatInfo isn't specified, the current culture's // NumberFormatInfo is assumed. // /// <include file='doc\Int32.uex' path='docs/doc[@for="Int32.Parse3"]/*' /> public static int Parse(String s, NumberStyles style, IFormatProvider provider) { NumberFormatInfo info = NumberFormatInfo.GetInstance(provider); NumberFormatInfo.ValidateParseStyle(style); return Number.ParseInt32(s, style, info); }
public static float Parse(String s, NumberStyles style, IFormatProvider provider) { NumberFormatInfo.ValidateParseStyleFloatingPoint(style); return(Parse(s, style, NumberFormatInfo.GetInstance(provider))); }
// Parses a long from a String in the given style. If // a NumberFormatInfo isn't specified, the current culture's // NumberFormatInfo is assumed. // public static long Parse(String s, NumberStyles style, IFormatProvider provider) { UInt32.ValidateParseStyleInteger(style); return(FormatProvider.ParseInt64(s, style, provider)); }
public static bool TryParse(String s, NumberStyles style, IFormatProvider provider, out Int32 result) { NumberFormatInfo.ValidateParseStyleInteger(style); return(Number.TryParseInt32(s, style, NumberFormatInfo.GetInstance(provider), out result)); }
static bool IsValidPrecision(string s, NumberStyles style, IFormatProvider provider) { var precision = GetPrecision(s, style, NumberFormatInfo.GetInstance(provider)); return(precision <= 29); }
public static bool TryParseExact(string s, out decimal result, NumberStyles style = NumberStyles.Number, IFormatProvider provider = null) { // NOTE: Always call base method first return(decimal.TryParse(s, style, provider, out result) && !IsValidPrecision(s, style, provider)); }
/// <summary> /// Parse string array in decimal array /// </summary> /// <param name="strValue">string to parse</param> /// <param name="numberStyle">number style to convert</param> /// <param name="culture">culture origin</param> /// <returns>decimal array</returns> public static decimal[] TryParseDecimalArray(this string strValue, NumberStyles numberStyle, CultureInfo culture) { return(strValue.TryParseDecimalArray(null, BasePrimitivesExtensions.GetDefaultDecimalArrayAllowDefaultConversion(), numberStyle, culture)); }
public static bool TryParse(ReadOnlySpan <char> s, NumberStyles style, IFormatProvider?provider, out double result) { NumberFormatInfo.ValidateParseStyleFloatingPoint(style); return(TryParse(s, style, NumberFormatInfo.GetInstance(provider), out result)); }
/// <summary> /// Tries to parse the specified string and convert it to double /// </summary> /// <param name="input">The string input to be parsed</param> /// <param name="style">The supported <see cref="NumberStyles"/></param> /// <param name="format">The format used for parsing</param> /// <param name="result">The parsing result</param> /// <returns>True if parsing succeeds, false otherwise</returns> protected override bool TryParseNumber(string input, NumberStyles style, IFormatProvider format, out double result) { return(double.TryParse(input, style, format, out result)); }
public IUInt64PropertyMapping NumberStyles(NumberStyles styles) { column.NumberStyles = styles; return(this); }
protected abstract IModelBinder GetBinder(NumberStyles numberStyles);