Single.Parse 方法

参考

定义

命名空间:: System

程序集:: System.Runtime.dll

程序集:: mscorlib.dll

程序集:: netstandard.dll

重要

一些信息与预发行产品相关，相应产品在发行之前可能会进行重大修改。对于此处提供的信息，Microsoft 不作任何明示或暗示的担保。

将数字的字符串表示形式转换为其等效的单精度浮点数。

重载

Parse(String)	将数字的字符串表示形式转换为其等效的单精度浮点数。
Parse(ReadOnlySpan<Byte>, IFormatProvider)	将 UTF-8 字符的范围分析为值。
Parse(ReadOnlySpan<Char>, IFormatProvider)	将字符的范围分析为值。
Parse(String, NumberStyles)	将指定样式中的数字的字符串表示形式转换为其等效的单精度浮点数。
Parse(String, IFormatProvider)	将指定区域性特定格式的数字的字符串表示形式转换为其等效的单精度浮点数。
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	将 UTF-8 字符的范围分析为值。
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	将包含指定样式和区域性特定格式的数字的字符串表示形式的字符范围转换为其等效的单精度浮点数。
Parse(String, NumberStyles, IFormatProvider)	将指定样式和区域性特定格式的数字的字符串表示形式转换为其等效的单精度浮点数。

注解

在 .NET Core 3.0 及更高版本中，无法表示的值舍入为 IEEE 754 规范所需的 PositiveInfinity 或 NegativeInfinity。在早期版本中（包括 .NET Framework）中，分析的值太大而无法表示导致失败。

Parse(String)

Source:: Single.cs

Source:: Single.cs

Source:: Single.cs

将数字的字符串表示形式转换为其等效的单精度浮点数。

public:
 static float Parse(System::String ^ s);

public static float Parse (string s);

static member Parse : string -> single

Public Shared Function Parse (s As String) As Single

参数

s: String

包含要转换的数字的字符串。

Single

与 s中指定的数值或符号等效的单精度浮点数。

例外

ArgumentNullException

s null。

FormatException

s 不以有效格式表示数字。

OverflowException

仅 .NET Framework 和 .NET Core 2.2 及更低版本：s 表示的数字小于 Single.MinValue 或大于 Single.MaxValue。

示例

以下示例使用 Parse(String) 方法将字符串数组转换为等效 Single 值。

using System;

public class Example
{
   public static void Main()
   {
      string[] values = { "100", "(100)", "-123,456,789", "123.45e+6", 
                          "+500", "5e2", "3.1416", "600.", "-.123", 
                          "-Infinity", "-1E-16", Double.MaxValue.ToString(), 
                          Single.MinValue.ToString(), String.Empty };
      foreach (string value in values)
      {
         try {   
            float number = Single.Parse(value);
            Console.WriteLine("{0} -> {1}", value, number);
         }
         catch (FormatException) {
            Console.WriteLine("'{0}' is not in a valid format.", value);
         }
         catch (OverflowException) {
            Console.WriteLine("{0} is outside the range of a Single.", value);
         }
      }                                  
   }
}
// The example displays the following output:
//       100 -> 100
//       '(100)' is not in a valid format.
//       -123,456,789 -> -1.234568E+08
//       123.45e+6 -> 1.2345E+08
//       +500 -> 500
//       5e2 -> 500
//       3.1416 -> 3.1416
//       600. -> 600
//       -.123 -> -0.123
//       -Infinity -> -Infinity
//       -1E-16 -> -1E-16
//       1.79769313486232E+308 is outside the range of a Single.
//       -3.402823E+38 -> -3.402823E+38
//       '' is not in a valid format.

open System

let values = 
    [| "100"; "(100)"; "-123,456,789"; "123.45e+6" 
       "+500"; "5e2"; "3.1416"; "600."; "-.123" 
       "-Infinity"; "-1E-16"; string Double.MaxValue
       string Single.MinValue; String.Empty |]

for value in values do
    try
        let number = Single.Parse value
        printfn $"{value} -> {number}"
    with
    | :? FormatException ->
        printfn $"'{value}' is not in a valid format."
    | :? OverflowException ->
        printfn $"{value} is outside the range of a Single."
// The example displays the following output:
//       100 -> 100
//       '(100)' is not in a valid format.
//       -123,456,789 -> -1.234568E+08
//       123.45e+6 -> 1.2345E+08
//       +500 -> 500
//       5e2 -> 500
//       3.1416 -> 3.1416
//       600. -> 600
//       -.123 -> -0.123
//       -Infinity -> -Infinity
//       -1E-16 -> -1E-16
//       1.79769313486232E+308 is outside the range of a Single.
//       -3.402823E+38 -> -3.402823E+38
//       '' is not in a valid format.

Module Example
   Public Sub Main()
      Dim values() As String = { "100", "(100)", "-123,456,789", "123.45e+6", _
                                 "+500", "5e2", "3.1416", "600.", "-.123", _
                                 "-Infinity", "-1E-16", Double.MaxValue.ToString(), _
                                 Single.MinValue.ToString(), String.Empty }
      For Each value As String In values
         Try   
            Dim number As Single = Single.Parse(value)
            Console.WriteLine("{0} -> {1}", value, number)
         Catch e As FormatException
            Console.WriteLine("'{0}' is not in a valid format.", value)
         Catch e As OverflowException
            Console.WriteLine("{0} is outside the range of a Single.", value)
         End Try
      Next                                  
   End Sub
End Module
' The example displays the following output:
'       100 -> 100
'       '(100)' is not in a valid format.
'       -123,456,789 -> -1.234568E+08
'       123.45e+6 -> 1.2345E+08
'       +500 -> 500
'       5e2 -> 500
'       3.1416 -> 3.1416
'       600. -> 600
'       -.123 -> -0.123
'       -Infinity -> -Infinity
'       -1E-16 -> -1E-16
'       1.79769313486232E+308 is outside the range of a Single.
'       -3.402823E+38 -> -3.402823E+38
'       '' is not in a valid format.

注解

s 参数可以包含当前区域性的 PositiveInfinitySymbol、NegativeInfinitySymbol、NaNSymbol或格式字符串：

[ws][符号][整型数字[，]]整型数字[.[小数位数]][e[符号]指数数字][ws]

方括号（[ 和 ]）中的元素是可选的。下表描述了每个元素。

元素	描述
ws	一系列空白字符。
签名	负号符号或正符号。有效符号字符由当前区域性的 NumberFormatInfo.NegativeSign 和 NumberFormatInfo.PositiveSign 属性决定。只能使用前导符号。
整型数字	一系列数字，范围从 0 到 9，用于指定数字的整部分。整型数字的运行可以按组分隔符进行分区。例如，在某些区域性中，逗号（，）分隔成千个组。如果字符串包含小数位数元素，则整型数字元素可能不存在。
、	区域性特定的千位分隔符符号。
。	区域性特定的小数点符号。
小数位数	一系列数字，范围从 0 到 9，指定数字的小数部分。
E	“e”或“E”字符，指示该值以指数（科学）表示法表示。
指数位数	一系列数字，范围从 0 到 9，用于指定指数。

s 参数使用 NumberStyles.Float 和 NumberStyles.AllowThousands 标志的组合进行解释。这意味着允许空格和数千个分隔符，但货币符号不是。若要显式定义可以存在于 s中的元素（如货币符号、千位分隔符和空格），请使用 Parse(String, NumberStyles) 方法重载。

s 参数通过使用为当前系统区域性初始化的 NumberFormatInfo 对象中的格式设置信息进行分析。有关详细信息，请参阅 CurrentInfo。若要使用特定区域性的格式设置信息分析字符串，请使用 Parse(String, IFormatProvider) 或 Parse(String, NumberStyles, IFormatProvider) 方法。

通常，如果将 Parse 方法传递给通过调用 ToString 方法创建的字符串，则返回原始 Single 值。但是，由于精度损失，值可能不相等。

如果 sSingle 数据类型的范围不足，该方法会在 .NET Framework 和 .NET Core 2.2 及更低版本上引发 OverflowException。在 .NET Core 3.0 及更高版本中，如果 s 小于 Single.MinValue，则返回 Single.NegativeInfinity;如果 s 大于 Single.MaxValue，则返回 Single.PositiveInfinity。

如果在分析操作期间 s 参数中遇到分隔符，并且适用的货币或数字小数和组分隔符相同，则分析操作假定分隔符是小数分隔符，而不是组分隔符。有关分隔符的详细信息，请参阅 CurrencyDecimalSeparator、NumberDecimalSeparator、CurrencyGroupSeparator和 NumberGroupSeparator。

另请参阅

ToString()
分析 .NET 中的数值字符串

适用于

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Source:: Single.cs

Source:: Single.cs

将 UTF-8 字符的范围分析为值。

public:
 static float Parse(ReadOnlySpan<System::Byte> utf8Text, IFormatProvider ^ provider) = IUtf8SpanParsable<float>::Parse;

public static float Parse (ReadOnlySpan<byte> utf8Text, IFormatProvider? provider);

static member Parse : ReadOnlySpan<byte> * IFormatProvider -> single

Public Shared Function Parse (utf8Text As ReadOnlySpan(Of Byte), provider As IFormatProvider) As Single

参数

utf8Text: ReadOnlySpan<Byte>

要分析的 UTF-8 字符的范围。

provider: IFormatProvider

一个对象，提供有关 utf8Text的区域性特定格式设置信息。

Single

分析 utf8Text的结果。

实现

Parse(ReadOnlySpan<Byte>, IFormatProvider)

适用于

Parse(ReadOnlySpan<Char>, IFormatProvider)

Source:: Single.cs

Source:: Single.cs

Source:: Single.cs

将字符的范围分析为值。

public:
 static float Parse(ReadOnlySpan<char> s, IFormatProvider ^ provider) = ISpanParsable<float>::Parse;

public static float Parse (ReadOnlySpan<char> s, IFormatProvider? provider);

static member Parse : ReadOnlySpan<char> * IFormatProvider -> single

Public Shared Function Parse (s As ReadOnlySpan(Of Char), provider As IFormatProvider) As Single

参数

s: ReadOnlySpan<Char>

要分析的字符范围。

provider: IFormatProvider

一个对象，提供有关 s的区域性特定格式设置信息。

Single

分析 s的结果。

实现

Parse(ReadOnlySpan<Char>, IFormatProvider)

适用于

Parse(String, NumberStyles)

Source:: Single.cs

Source:: Single.cs

Source:: Single.cs

将指定样式中的数字的字符串表示形式转换为其等效的单精度浮点数。

public:
 static float Parse(System::String ^ s, System::Globalization::NumberStyles style);

public static float Parse (string s, System.Globalization.NumberStyles style);

static member Parse : string * System.Globalization.NumberStyles -> single

Public Shared Function Parse (s As String, style As NumberStyles) As Single

参数

s: String

包含要转换的数字的字符串。

style: NumberStyles

枚举值的按位组合，指示 s中可以存在的样式元素。要指定的典型值 Float 与 AllowThousands结合使用。

Single

与 s中指定的数值或符号等效的单精度浮点数。

例外

ArgumentNullException

s null。

FormatException

s 不是有效格式的数字。

OverflowException

仅 .NET Framework 和 .NET Core 2.2 及更低版本：s 表示小于 Single.MinValue 或大于 Single.MaxValue的数字。

ArgumentException

style 不是 NumberStyles 值。

-或-

style 包括 AllowHexSpecifier 值。

示例

以下示例使用 Parse(String, NumberStyles) 方法分析 Single 值的字符串表示形式。该示例使用 en-US 区域性的格式设置信息。

using System;
using System.Globalization;
using System.Threading;

public class ParseString
{
   public static void Main()
   {
      // Set current thread culture to en-US.
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
      
      string value;
      NumberStyles styles;
      
      // Parse a string in exponential notation with only the AllowExponent flag. 
      value = "-1.063E-02";
      styles = NumberStyles.AllowExponent;
      ShowNumericValue(value, styles);
      
      // Parse a string in exponential notation
      // with the AllowExponent and Number flags.
      styles = NumberStyles.AllowExponent | NumberStyles.Number;
      ShowNumericValue(value, styles);

      // Parse a currency value with leading and trailing white space, and
      // white space after the U.S. currency symbol.
      value = " $ 6,164.3299  ";
      styles = NumberStyles.Number | NumberStyles.AllowCurrencySymbol;
      ShowNumericValue(value, styles);
      
      // Parse negative value with thousands separator and decimal.
      value = "(4,320.64)";
      styles = NumberStyles.AllowParentheses | NumberStyles.AllowTrailingSign |
               NumberStyles.Float; 
      ShowNumericValue(value, styles);
      
      styles = NumberStyles.AllowParentheses | NumberStyles.AllowTrailingSign |
               NumberStyles.Float | NumberStyles.AllowThousands;
      ShowNumericValue(value, styles);
   }

   private static void ShowNumericValue(string value, NumberStyles styles)
   {
      Single number;
      try
      {
         number = Single.Parse(value, styles);
         Console.WriteLine("Converted '{0}' using {1} to {2}.", 
                           value, styles.ToString(), number);
      }
      catch (FormatException)
      {
         Console.WriteLine("Unable to parse '{0}' with styles {1}.", 
                           value, styles.ToString());
      }
      Console.WriteLine();                           
   }   
}
// The example displays the following output to the console:
//    Unable to parse '-1.063E-02' with styles AllowExponent.
//    
//    Converted '-1.063E-02' using AllowTrailingSign, AllowThousands, Float to -0.01063.
//    
//    Converted ' $ 6,164.3299  ' using Number, AllowCurrencySymbol to 6164.3299.
//    
//    Unable to parse '(4,320.64)' with styles AllowTrailingSign, AllowParentheses, Float.
//    
//    Converted '(4,320.64)' using AllowTrailingSign, AllowParentheses, AllowThousands, Float to -4320.64.

open System
open System.Globalization
open System.Threading

let showNumericValue value (styles: NumberStyles) =
    try
        let number = Single.Parse(value, styles)
        printfn $"Converted '{value}' using {styles} to {number}."
    with :? FormatException ->
        printfn $"Unable to parse '{value}' with styles {styles}."
    printfn ""

[<EntryPoint>]
let main _ =
    // Set current thread culture to en-US.
    Thread.CurrentThread.CurrentCulture <- CultureInfo.CreateSpecificCulture "en-US"
    
    // Parse a string in exponential notation with only the AllowExponent flag. 
    let value = "-1.063E-02"
    let styles = NumberStyles.AllowExponent
    showNumericValue value styles
    
    // Parse a string in exponential notation
    // with the AllowExponent and Number flags.
    let styles = NumberStyles.AllowExponent ||| NumberStyles.Number
    showNumericValue value styles

    // Parse a currency value with leading and trailing white space, and
    // white space after the U.S. currency symbol.
    let value = " $ 6,164.3299  "
    let styles = NumberStyles.Number ||| NumberStyles.AllowCurrencySymbol
    showNumericValue value styles
    
    // Parse negative value with thousands separator and decimal.
    let value = "(4,320.64)"
    let styles = NumberStyles.AllowParentheses ||| NumberStyles.AllowTrailingSign ||| NumberStyles.Float 
    showNumericValue value styles
    
    let styles = NumberStyles.AllowParentheses ||| NumberStyles.AllowTrailingSign ||| NumberStyles.Float ||| NumberStyles.AllowThousands
    showNumericValue value styles
    0
// The example displays the following output to the console:
//    Unable to parse '-1.063E-02' with styles AllowExponent.
//    
//    Converted '-1.063E-02' using AllowTrailingSign, AllowThousands, Float to -0.01063.
//    
//    Converted ' $ 6,164.3299  ' using Number, AllowCurrencySymbol to 6164.3299.
//    
//    Unable to parse '(4,320.64)' with styles AllowTrailingSign, AllowParentheses, Float.
//    
//    Converted '(4,320.64)' using AllowTrailingSign, AllowParentheses, AllowThousands, Float to -4320.64.

Imports System.Globalization
Imports System.Threading

Module ParseStrings
   Public Sub Main()
      ' Set current thread culture to en-US.
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US")
            
      Dim value As String
      Dim styles As NumberStyles
      
      ' Parse a string in exponential notation with only the AllowExponent flag. 
      value = "-1.063E-02"
      styles = NumberStyles.AllowExponent
      ShowNumericValue(value, styles) 
      
      ' Parse a string in exponential notation
      ' with the AllowExponent and Number flags.
      styles = NumberStyles.AllowExponent Or NumberStyles.Number
      ShowNumericValue(value, styles)

      ' Parse a currency value with leading and trailing white space, and
      ' white space after the U.S. currency symbol.
      value = " $ 6,164.3299  "
      styles = NumberStyles.Number Or NumberStyles.AllowCurrencySymbol
      ShowNumericValue(value, styles)
      
      ' Parse negative value with thousands separator and decimal.
      value = "(4,320.64)"
      styles = NumberStyles.AllowParentheses Or NumberStyles.AllowTrailingSign _
               Or NumberStyles.Float 
      ShowNumericValue(value, styles)
      
      styles = NumberStyles.AllowParentheses Or NumberStyles.AllowTrailingSign _
               Or NumberStyles.Float Or NumberStyles.AllowThousands
      ShowNumericValue(value, styles)
   End Sub
   
   Private Sub ShowNumericValue(value As String, styles As NumberStyles)
      Dim number As Single
      Try
         number = Single.Parse(value, styles)
         Console.WriteLine("Converted '{0}' using {1} to {2}.", _
                           value, styles.ToString(), number)
      Catch e As FormatException
         Console.WriteLine("Unable to parse '{0}' with styles {1}.", _
                           value, styles.ToString())
      End Try
      Console.WriteLine()                           
   End Sub
End Module
' The example displays the following output to the console:
'    Unable to parse '-1.063E-02' with styles AllowExponent.
'    
'    Converted '-1.063E-02' using AllowTrailingSign, AllowThousands, Float to -0.01063.
'    
'    Converted ' $ 6,164.3299  ' using Number, AllowCurrencySymbol to 6164.3299.
'    
'    Unable to parse '(4,320.64)' with styles AllowTrailingSign, AllowParentheses, Float.
'    
'    Converted '(4,320.64)' using AllowTrailingSign, AllowParentheses, AllowThousands, Float to -4320.64.

注解

style 参数定义允许在分析操作成功 s 参数中允许的样式元素（如空格、千位分隔符和货币符号）。它必须是 NumberStyles 枚举中的位标志的组合。不支持以下 NumberStyles 成员：

s 参数可以包含当前区域性的 PositiveInfinitySymbol NegativeInfinitySymbol NaNSymbol。根据 style的值，还可以采用以下形式：

[ws][$][符号][整型数字[，]]整型数字[.[分数位数]][E[符号]指数数字][ws]

方括号（[ 和 ]）中的元素是可选的。下表描述了每个元素。

ws 一系列空格字符。如果 style 包含 NumberStyles.AllowLeadingWhite 标志，则空格可能出现在 s 的开头，如果 style 包含 NumberStyles.AllowTrailingWhite 标志，则它将显示在 s 末尾。

$ 特定于区域性的货币符号。字符串中的位置由当前区域性的 NumberFormatInfo.CurrencyNegativePattern 和 NumberFormatInfo.CurrencyPositivePattern 属性定义。如果 style 包含 NumberStyles.AllowCurrencySymbol 标志，则当前区域性的货币符号可以出现在 s 中。

符号负号符号（-）或正符号（+）。如果 style 包含 NumberStyles.AllowLeadingSign 标志，则符号可以在 s 开头显示，如果 style 包含 NumberStyles.AllowTrailingSign 标志，则它将显示在 s 末尾。如果 style 包含 NumberStyles.AllowParentheses 标志，则可以在 s 中使用括号来指示负值。

整型数字 一系列数字，范围从 0 到 9，指定数字的整型部分。如果字符串包含 小数位数 元素，则 整型数字 元素可能不存在。

，特定于区域性的组分隔符。如果 style 包含 NumberStyles.AllowThousands 标志，则当前区域性的组分隔符可以出现在 s 中

. 区域性特定的小数点符号。如果 style 包含 NumberStyles.AllowDecimalPoint 标志，则当前区域性的小数点符号可以出现在 s 中。

小数位数 从 0 到 9 的一系列数字，用于指定数字的小数部分。如果 style 包含 NumberStyles.AllowDecimalPoint 标志，则可以在 s 中显示小数位数。

E“e”或“E”字符，指示该值以指数（科学）表示法表示。如果 style 包含 NumberStyles.AllowExponent 标志，value 参数可以表示指数表示法中的数字。

指数数字 一系列数字，范围从 0 到 9，指定指数。

注意

无论 style 参数的值如何，分析操作都会忽略 s 中任何终止的 NUL （U+0000）字符。

仅包含数字（对应于 NumberStyles.None 样式）的字符串在 Single 类型范围内时始终成功分析。其余 System.Globalization.NumberStyles 成员控制可能存在的元素，但不需要在输入字符串中存在。下表指示单个 NumberStyles 标志如何影响 s中可能存在的元素。

NumberStyles 值	除数字外，`s` 允许的元素
None	仅整型数字元素。
AllowDecimalPoint	小数点（.）和小数位数元素。
AllowExponent	指示指数表示法的“e”或“E”字符。此标志本身支持数字形式的值，E位;需要其他标志才能成功分析包含正数或负号和小数点符号等元素的字符串。
AllowLeadingWhite	`s`开头的 ws 元素。
AllowTrailingWhite	`s`末尾的 ws 元素。
AllowLeadingSign	`s`开头的符号元素。
AllowTrailingSign	`s`末尾的符号元素。
AllowParentheses	符号元素，以括住数值的括号形式。
AllowThousands	千位分隔符（，）元素。
AllowCurrencySymbol	currency （$）元素。
Currency	所有元素。但是，`s` 不能表示十六进制数或指数表示法中的数字。
Float	ws 元素位于 `s`的开头或末尾，符号`s`开头，以及小数点（.）符号。 `s` 参数也可以使用指数表示法。
Number	`ws`、`sign`、千位分隔符（、）和小数点（.）元素。
Any	所有元素。但是，`s` 不能表示十六进制数。

s 的一些示例包括“100”、“-123,456,789”、“123.45e+6”、“+500”、“5e2”、“3.1416”、“600.”、“-.123”和“-Infinity”。

s 参数是使用为当前系统区域性初始化的 NumberFormatInfo 对象中的格式信息进行分析的。若要指定其格式设置信息用于分析操作的区域性，请调用 Parse(String, NumberStyles, IFormatProvider) 重载。

通常，如果将 Parse 方法传递给通过调用 ToString 方法创建的字符串，则返回原始 Single 值。但是，由于精度损失，值可能不相等。

另请参阅

ToString()
TryParse
分析 .NET 中的数值字符串

适用于

Parse(String, IFormatProvider)

Source:: Single.cs

Source:: Single.cs

Source:: Single.cs

将指定区域性特定格式的数字的字符串表示形式转换为其等效的单精度浮点数。

public:
 static float Parse(System::String ^ s, IFormatProvider ^ provider);

public:
 static float Parse(System::String ^ s, IFormatProvider ^ provider) = IParsable<float>::Parse;

public static float Parse (string s, IFormatProvider provider);

public static float Parse (string s, IFormatProvider? provider);

static member Parse : string * IFormatProvider -> single

Public Shared Function Parse (s As String, provider As IFormatProvider) As Single

参数

s: String

包含要转换的数字的字符串。

provider: IFormatProvider

一个对象，提供有关 s的区域性特定格式设置信息。

Single

与 s中指定的数值或符号等效的单精度浮点数。

实现

Parse(String, IFormatProvider)

例外

ArgumentNullException

s null。

FormatException

s 不以有效格式表示数字。

OverflowException

仅 .NET Framework 和 .NET Core 2.2 及更低版本：s 表示的数字小于 Single.MinValue 或大于 Single.MaxValue。

示例

以下示例是 Web 窗体的按钮单击事件处理程序。它使用 HttpRequest.UserLanguages 属性返回的数组来确定用户的区域设置。然后，它会实例化与该区域设置对应的 CultureInfo 对象。然后，将属于该 CultureInfo 对象的 NumberFormatInfo 对象传递给 Parse(String, IFormatProvider) 方法，将用户的输入转换为 Single 值。

protected void OkToSingle_Click(object sender, EventArgs e)
{
    string locale;
    float number;
    CultureInfo culture;

    // Return if string is empty
    if (String.IsNullOrEmpty(this.inputNumber.Text))
        return;

    // Get locale of web request to determine possible format of number
    if (Request.UserLanguages.Length == 0)
        return;
    locale = Request.UserLanguages[0];
    if (String.IsNullOrEmpty(locale))
        return;

    // Instantiate CultureInfo object for the user's locale
    culture = new CultureInfo(locale);

    // Convert user input from a string to a number
    try
    {
        number = Single.Parse(this.inputNumber.Text, culture.NumberFormat);
    }
    catch (FormatException)
    {
        return;
    }
    catch (Exception)
    {
        return;
    }
    // Output number to label on web form
    this.outputNumber.Text = "Number is " + number.ToString();
}

Protected Sub OkToSingle_Click(ByVal sender As Object, ByVal e As System.EventArgs) Handles OkToSingle.Click
   Dim locale As String
   Dim culture As CultureInfo
   Dim number As Single

   ' Return if string is empty
   If String.IsNullOrEmpty(Me.inputNumber.Text) Then Exit Sub

   ' Get locale of web request to determine possible format of number
   If Request.UserLanguages.Length = 0 Then Exit Sub
   locale = Request.UserLanguages(0)
   If String.IsNullOrEmpty(locale) Then Exit Sub

   ' Instantiate CultureInfo object for the user's locale
   culture = New CultureInfo(locale)

   ' Convert user input from a string to a number
   Try
      number = Single.Parse(Me.inputNumber.Text, culture.NumberFormat)
   Catch ex As FormatException
      Exit Sub
   Catch ex As OverflowException
      Exit Sub
   End Try

   ' Output number to label on web form
   Me.outputNumber.Text = "Number is " & number.ToString()
End Sub

注解

此重载通常用于将可通过多种方式格式化的文本转换为 Single 值。例如，它可用于将用户输入的文本转换为 HTML 文本框，并将其转换为数值。

s 参数使用 NumberStyles.Float 和 NumberStyles.AllowThousands 标志的组合进行解释。 s 参数可以包含由 provider指定的区域性的 NumberFormatInfo.PositiveInfinitySymbol、NumberFormatInfo.NegativeInfinitySymbol或 NumberFormatInfo.NaNSymbol，也可以包含格式的字符串：

[ws][符号]整型数字[.[分数数字][E[符号]指数数字][ws]

可选元素采用方括号（[ 和 ]）框架。包含术语“digits”的元素由一系列介于 0 到 9 的数字字符组成。

元素	描述
ws	一系列空白字符。
签名	负号符号（-）或正符号（+）。
整型数字	一系列数字，范围从 0 到 9，用于指定数字的整部分。整型数字的运行可以按组分隔符进行分区。例如，在某些区域性中，逗号（，）分隔成千个组。如果字符串包含小数位数元素，则整型数字元素可能不存在。
.	区域性特定的小数点符号。
小数位数	一系列数字，范围从 0 到 9，指定数字的小数部分。
E	“e”或“E”字符，指示该值以指数（科学）表示法表示。
指数位数	一系列数字，范围从 0 到 9，用于指定指数。

有关数字格式的详细信息，请参阅格式设置类型主题。

provider 参数是一个 IFormatProvider 实现，其 GetFormat 方法返回提供区域性特定格式信息的 NumberFormatInfo 对象。调用 Parse(String, IFormatProvider) 方法时，它将调用 provider 参数的 GetFormat 方法，并传递表示 NumberFormatInfo 类型的 Type 对象。然后，GetFormat 方法返回 NumberFormatInfo 对象，该对象提供有关 s 参数的格式的信息。可通过三种方法使用 provider 参数向分析操作提供自定义格式设置信息：

可以传递表示提供格式信息的区域性的 CultureInfo 对象。其 GetFormat 方法返回为该区域性提供数值格式信息的 NumberFormatInfo 对象。
可以传递提供数字格式信息的实际 NumberFormatInfo 对象。（它的 GetFormat 实现只是返回自己。
可以传递实现 IFormatProvider的自定义对象。其 GetFormat 方法实例化并返回提供格式信息的 NumberFormatInfo 对象。

如果 providernull 或无法获取 NumberFormatInfo，则使用当前系统区域性的格式设置信息。

s 的一些示例包括“100”、“-123,456,789”、“123.45e+6”、“+500”、“5e2”、“3.1416”、“600.”、“-.123”和“-Infinity”。

另请参阅

ToString()
TryParse
分析 .NET 中的数值字符串

适用于

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Source:: Single.cs

Source:: Single.cs

将 UTF-8 字符的范围分析为值。

public static float Parse (ReadOnlySpan<byte> utf8Text, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.AllowThousands | System.Globalization.NumberStyles.Float, IFormatProvider? provider = default);

static member Parse : ReadOnlySpan<byte> * System.Globalization.NumberStyles * IFormatProvider -> single

Public Shared Function Parse (utf8Text As ReadOnlySpan(Of Byte), Optional style As NumberStyles = System.Globalization.NumberStyles.AllowThousands | System.Globalization.NumberStyles.Float, Optional provider As IFormatProvider = Nothing) As Single

参数

utf8Text: ReadOnlySpan<Byte>

要分析的 UTF-8 字符的范围。

style: NumberStyles

utf8Text中可以存在的数字样式的按位组合。

provider: IFormatProvider

一个对象，提供有关 utf8Text的区域性特定格式设置信息。

Single

分析 utf8Text的结果。

实现

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

适用于

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Source:: Single.cs

Source:: Single.cs

Source:: Single.cs

将包含指定样式和区域性特定格式的数字的字符串表示形式的字符范围转换为其等效的单精度浮点数。

public static float Parse (ReadOnlySpan<char> s, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.AllowThousands | System.Globalization.NumberStyles.Float, IFormatProvider? provider = default);

public static float Parse (ReadOnlySpan<char> s, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.AllowThousands | System.Globalization.NumberStyles.Float, IFormatProvider provider = default);

static member Parse : ReadOnlySpan<char> * System.Globalization.NumberStyles * IFormatProvider -> single

Public Shared Function Parse (s As ReadOnlySpan(Of Char), Optional style As NumberStyles = System.Globalization.NumberStyles.AllowThousands | System.Globalization.NumberStyles.Float, Optional provider As IFormatProvider = Nothing) As Single

参数

s: ReadOnlySpan<Char>

包含要转换的数字的字符范围。

style: NumberStyles

枚举值的按位组合，指示 s中可以存在的样式元素。要指定的典型值 Float 与 AllowThousands结合使用。

provider: IFormatProvider

一个对象，提供有关 s的区域性特定格式设置信息。

Single

与 s中指定的数值或符号等效的单精度浮点数。

实现

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

例外

FormatException

s 不表示数值。

ArgumentException

style 不是 NumberStyles 值。

-或-

style 是 AllowHexSpecifier 值。

注解

如果 s 超出 Single 数据类型的范围，则如果 s 小于 Single.MinValue，则该方法返回 Single.NegativeInfinity;如果 s 大于 Single.MaxValue，则返回 Single.PositiveInfinity。

适用于

Parse(String, NumberStyles, IFormatProvider)

Source:: Single.cs

Source:: Single.cs

Source:: Single.cs

将指定样式和区域性特定格式的数字的字符串表示形式转换为其等效的单精度浮点数。

public:
 static float Parse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider);

public:
 static float Parse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider) = System::Numerics::INumberBase<float>::Parse;

public static float Parse (string s, System.Globalization.NumberStyles style, IFormatProvider provider);

public static float Parse (string s, System.Globalization.NumberStyles style, IFormatProvider? provider);

static member Parse : string * System.Globalization.NumberStyles * IFormatProvider -> single

Public Shared Function Parse (s As String, style As NumberStyles, provider As IFormatProvider) As Single

参数

s: String

包含要转换的数字的字符串。

style: NumberStyles

枚举值的按位组合，指示 s中可以存在的样式元素。要指定的典型值 Float 与 AllowThousands结合使用。

provider: IFormatProvider

一个对象，提供有关 s的区域性特定格式设置信息。

Single

与 s中指定的数值或符号等效的单精度浮点数。

实现

Parse(String, NumberStyles, IFormatProvider)

例外

ArgumentNullException

s null。

FormatException

s 不表示数值。

ArgumentException

style 不是 NumberStyles 值。

-或-

style 是 AllowHexSpecifier 值。

OverflowException

仅 .NET Framework 和 .NET Core 2.2 及更低版本：s 表示小于 Single.MinValue 或大于 Single.MaxValue的数字。

示例

下面的代码示例使用 Parse(String, NumberStyles, IFormatProvider) 方法分析 Single 值的字符串表示形式。数组中的每个字符串都使用 en-US、nl-NL和自定义区域性的格式约定进行分析。自定义区域性将其组分隔符定义为下划线（“_”），其组大小定义为 2。

using System;
using System.Globalization;

public class Example
{
    public static void Main()
    {
      // Define an array of string values.
      string[] values = { " 987.654E-2", " 987,654E-2",  "(98765,43210)",
                          "9,876,543.210", "9.876.543,210",  "98_76_54_32,19" };
      // Create a custom culture based on the invariant culture.
      CultureInfo ci = new CultureInfo("");
      ci.NumberFormat.NumberGroupSizes = new int[] { 2 };
      ci.NumberFormat.NumberGroupSeparator = "_";

      // Define an array of format providers.
      CultureInfo[] providers = { new CultureInfo("en-US"),
                                  new CultureInfo("nl-NL"), ci };

      // Define an array of styles.
      NumberStyles[] styles = { NumberStyles.Currency, NumberStyles.Float };

      // Iterate the array of format providers.
      foreach (CultureInfo provider in providers)
      {
         Console.WriteLine("Parsing using the {0} culture:",
                           provider.Name == String.Empty ? "Invariant" : provider.Name);
         // Parse each element in the array of string values.
         foreach (string value in values)
         {
            foreach (NumberStyles style in styles)
            {
               try {
                  float number = Single.Parse(value, style, provider);
                  Console.WriteLine("   {0} ({1}) -> {2}",
                                    value, style, number);
               }
               catch (FormatException) {
                  Console.WriteLine("   '{0}' is invalid using {1}.", value, style);
               }
               catch (OverflowException) {
                  Console.WriteLine("   '{0}' is out of the range of a Single.", value);
               }
            }
         }
         Console.WriteLine();
      }
   }
}
// The example displays the following output:
// Parsing using the en-US culture:
//    ' 987.654E-2' is invalid using Currency.
//     987.654E-2 (Float) -> 9.87654
//    ' 987,654E-2' is invalid using Currency.
//    ' 987,654E-2' is invalid using Float.
//    (98765,43210) (Currency) -> -9.876543E+09
//    '(98765,43210)' is invalid using Float.
//    9,876,543.210 (Currency) -> 9876543
//    '9,876,543.210' is invalid using Float.
//    '9.876.543,210' is invalid using Currency.
//    '9.876.543,210' is invalid using Float.
//    '98_76_54_32,19' is invalid using Currency.
//    '98_76_54_32,19' is invalid using Float.
//
// Parsing using the nl-NL culture:
//    ' 987.654E-2' is invalid using Currency.
//    ' 987.654E-2' is invalid using Float.
//    ' 987,654E-2' is invalid using Currency.
//     987,654E-2 (Float) -> 9.87654
//    (98765,43210) (Currency) -> -98765.43
//    '(98765,43210)' is invalid using Float.
//    '9,876,543.210' is invalid using Currency.
//    '9,876,543.210' is invalid using Float.
//    9.876.543,210 (Currency) -> 9876543
//    '9.876.543,210' is invalid using Float.
//    '98_76_54_32,19' is invalid using Currency.
//    '98_76_54_32,19' is invalid using Float.
//
// Parsing using the Invariant culture:
//    ' 987.654E-2' is invalid using Currency.
//     987.654E-2 (Float) -> 9.87654
//    ' 987,654E-2' is invalid using Currency.
//    ' 987,654E-2' is invalid using Float.
//    (98765,43210) (Currency) -> -9.876543E+09
//    '(98765,43210)' is invalid using Float.
//    9,876,543.210 (Currency) -> 9876543
//    '9,876,543.210' is invalid using Float.
//    '9.876.543,210' is invalid using Currency.
//    '9.876.543,210' is invalid using Float.
//    98_76_54_32,19 (Currency) -> 9.876543E+09
//    '98_76_54_32,19' is invalid using Float.

open System
open System.Globalization

// Define a list of string values.
let values = 
    [ " 987.654E-2"; " 987,654E-2"; "(98765,43210)"
      "9,876,543.210"; "9.876.543,210"; "98_76_54_32,19" ]
// Create a custom culture based on the invariant culture.
let ci = CultureInfo ""
ci.NumberFormat.NumberGroupSizes <- [| 2 |]
ci.NumberFormat.NumberGroupSeparator <- "_"

// Define a list of format providers.
let providers = 
    [ CultureInfo "en-US"
      CultureInfo "nl-NL"
      ci ]

// Define a list of styles.
let styles = [ NumberStyles.Currency; NumberStyles.Float ]

// Iterate the list of format providers.
for provider in providers do
    printfn $"""Parsing using the {if provider.Name = String.Empty then "Invariant" else provider.Name} culture:"""
    // Parse each element in the array of string values.
    for value in values do
        for style in styles do
            try
                let number = Single.Parse(value, style, provider)
                printfn $"   {value} ({style}) -> {number}"
            with
            | :? FormatException ->
                printfn $"   '{value}' is invalid using {style}."
            | :? OverflowException ->
                printfn $"   '{value}' is out of the range of a Single."
    printfn ""

// The example displays the following output:
// Parsing using the en-US culture:
//    ' 987.654E-2' is invalid using Currency.
//     987.654E-2 (Float) -> 9.87654
//    ' 987,654E-2' is invalid using Currency.
//    ' 987,654E-2' is invalid using Float.
//    (98765,43210) (Currency) -> -9.876543E+09
//    '(98765,43210)' is invalid using Float.
//    9,876,543.210 (Currency) -> 9876543
//    '9,876,543.210' is invalid using Float.
//    '9.876.543,210' is invalid using Currency.
//    '9.876.543,210' is invalid using Float.
//    '98_76_54_32,19' is invalid using Currency.
//    '98_76_54_32,19' is invalid using Float.
//
// Parsing using the nl-NL culture:
//    ' 987.654E-2' is invalid using Currency.
//    ' 987.654E-2' is invalid using Float.
//    ' 987,654E-2' is invalid using Currency.
//     987,654E-2 (Float) -> 9.87654
//    (98765,43210) (Currency) -> -98765.43
//    '(98765,43210)' is invalid using Float.
//    '9,876,543.210' is invalid using Currency.
//    '9,876,543.210' is invalid using Float.
//    9.876.543,210 (Currency) -> 9876543
//    '9.876.543,210' is invalid using Float.
//    '98_76_54_32,19' is invalid using Currency.
//    '98_76_54_32,19' is invalid using Float.
//
// Parsing using the Invariant culture:
//    ' 987.654E-2' is invalid using Currency.
//     987.654E-2 (Float) -> 9.87654
//    ' 987,654E-2' is invalid using Currency.
//    ' 987,654E-2' is invalid using Float.
//    (98765,43210) (Currency) -> -9.876543E+09
//    '(98765,43210)' is invalid using Float.
//    9,876,543.210 (Currency) -> 9876543
//    '9,876,543.210' is invalid using Float.
//    '9.876.543,210' is invalid using Currency.
//    '9.876.543,210' is invalid using Float.
//    98_76_54_32,19 (Currency) -> 9.876543E+09
//    '98_76_54_32,19' is invalid using Float.

Imports System.Globalization

Module Example
    Public Sub Main()
      ' Define an array of string values.
      Dim values() As String = { " 987.654E-2", " 987,654E-2", _
                                 "(98765,43210)", "9,876,543.210",  _
                                 "9.876.543,210",  "98_76_54_32,19" }
      ' Create a custom culture based on the invariant culture.
      Dim ci As New CultureInfo("")
      ci.NumberFormat.NumberGroupSizes = New Integer() { 2 }
      ci.NumberFormat.NumberGroupSeparator = "_"
      
      ' Define an array of format providers.
      Dim providers() As CultureInfo = { New CultureInfo("en-US"), _
                                             New CultureInfo("nl-NL"), ci }       
      
      ' Define an array of styles.
      Dim styles() As NumberStyles = { NumberStyles.Currency, NumberStyles.Float }
      
      ' Iterate the array of format providers.
      For Each provider As CultureInfo In providers
         Console.WriteLine("Parsing using the {0} culture:", _
                           If(provider.Name = String.Empty, "Invariant", provider.Name))
         ' Parse each element in the array of string values.
         For Each value As String In values
            For Each style As NumberStyles In styles
               Try
                  Dim number As Single = Single.Parse(value, style, provider)            
                  Console.WriteLine("   {0} ({1}) -> {2}", _
                                    value, style, number)
               Catch e As FormatException
                  Console.WriteLine("   '{0}' is invalid using {1}.", value, style)            
               Catch e As OverflowException
                  Console.WriteLine("   '{0}' is out of the range of a Single.", value)
               End Try 
            Next            
         Next         
         Console.WriteLine()
      Next
   End Sub   
End Module 
' The example displays the following output:
'       Parsing using the en-US culture:
'          ' 987.654E-2' is invalid using Currency.
'           987.654E-2 (Float) -> 9.87654
'          ' 987,654E-2' is invalid using Currency.
'          ' 987,654E-2' is invalid using Float.
'          (98765,43210) (Currency) -> -9.876543E+09
'          '(98765,43210)' is invalid using Float.
'          9,876,543.210 (Currency) -> 9876543
'          '9,876,543.210' is invalid using Float.
'          '9.876.543,210' is invalid using Currency.
'          '9.876.543,210' is invalid using Float.
'          '98_76_54_32,19' is invalid using Currency.
'          '98_76_54_32,19' is invalid using Float.
'       
'       Parsing using the nl-NL culture:
'          ' 987.654E-2' is invalid using Currency.
'          ' 987.654E-2' is invalid using Float.
'          ' 987,654E-2' is invalid using Currency.
'           987,654E-2 (Float) -> 9.87654
'          (98765,43210) (Currency) -> -98765.43
'          '(98765,43210)' is invalid using Float.
'          '9,876,543.210' is invalid using Currency.
'          '9,876,543.210' is invalid using Float.
'          9.876.543,210 (Currency) -> 9876543
'          '9.876.543,210' is invalid using Float.
'          '98_76_54_32,19' is invalid using Currency.
'          '98_76_54_32,19' is invalid using Float.
'       
'       Parsing using the Invariant culture:
'          ' 987.654E-2' is invalid using Currency.
'           987.654E-2 (Float) -> 9.87654
'          ' 987,654E-2' is invalid using Currency.
'          ' 987,654E-2' is invalid using Float.
'          (98765,43210) (Currency) -> -9.876543E+09
'          '(98765,43210)' is invalid using Float.
'          9,876,543.210 (Currency) -> 9876543
'          '9,876,543.210' is invalid using Float.
'          '9.876.543,210' is invalid using Currency.
'          '9.876.543,210' is invalid using Float.
'          98_76_54_32,19 (Currency) -> 9.876543E+09
'          '98_76_54_32,19' is invalid using Float.

注解

s 参数可以包含由 provider指定的区域性的 NumberFormatInfo.PositiveInfinitySymbol、NumberFormatInfo.NegativeInfinitySymbol或 NumberFormatInfo.NaNSymbol。根据 style的值，还可以采用以下形式：

[ws][$][符号][整型数字，]整型数字[.[小数位数]][E[符号]指数数字][ws]

方括号（[ 和 ]）中框架的元素是可选的。下表描述了每个元素。

元素	描述
ws	一系列空白字符。如果 `style` 包含 NumberStyles.AllowLeadingWhite 标志，则空格可能出现在 `s` 的开头，如果 `style` 包含 NumberStyles.AllowTrailingWhite 标志，则它将显示在 `s` 末尾。
$	区域性特定的货币符号。字符串中的位置由当前区域性的 NumberFormatInfo.CurrencyNegativePattern 和 NumberFormatInfo.CurrencyPositivePattern 属性定义。如果 `style` 包含 NumberStyles.AllowCurrencySymbol 标志，则当前区域性的货币符号可以出现在 `s` 中。
签名	负号符号（-）或正符号（+）。如果 `style` 包含 NumberStyles.AllowLeadingSign 标志，则符号可以在 `s` 开头显示，如果 `style` 包含 NumberStyles.AllowTrailingSign 标志，则它将显示在 `s` 末尾。如果 `style` 包含 NumberStyles.AllowParentheses 标志，则可以在 `s` 中使用括号来指示负值。
整型数字	一系列数字，范围从 0 到 9，用于指定数字的整部分。如果字符串包含小数位数元素，则整型数字元素可能不存在。
,	区域性特定的组分隔符。如果 `style` 包含 NumberStyles.AllowThousands 标志，则当前区域性的组分隔符可以出现在 `s` 中
.	区域性特定的小数点符号。如果 `style` 包含 NumberStyles.AllowDecimalPoint 标志，则当前区域性的小数点符号可以出现在 `s` 中。
小数位数	一系列数字，范围从 0 到 9，指定数字的小数部分。如果 `style` 包含 NumberStyles.AllowDecimalPoint 标志，则可以在 `s` 中显示小数位数。
E	“e”或“E”字符，指示该值以指数（科学）表示法表示。如果 `style` 包含 NumberStyles.AllowExponent 标志，`s` 参数可以表示指数表示法中的数字。
指数位数	一系列数字，范围从 0 到 9，用于指定指数。

注意

无论 style 参数的值如何，分析操作都会忽略 s 中任何终止的 NUL （U+0000）字符。

NumberStyles 值	除数字外，`s` 允许的元素
None	仅整型数字元素。
AllowDecimalPoint	小数点（.）和小数位数元素。
AllowExponent	指示指数表示法的“e”或“E”字符。此标志本身支持数字形式的值，E位;需要其他标志才能成功分析包含正数或负号和小数点符号等元素的字符串。
AllowLeadingWhite	`s`开头的 ws 元素。
AllowTrailingWhite	`s`末尾的 ws 元素。
AllowLeadingSign	`s`开头的符号元素。
AllowTrailingSign	`s`末尾的符号元素。
AllowParentheses	符号元素，以括住数值的括号形式。
AllowThousands	千位分隔符（，）元素。
AllowCurrencySymbol	currency （$）元素。
Currency	所有元素。但是，`s` 不能表示十六进制数或指数表示法中的数字。
Float	ws 元素位于 `s`的开头或末尾，符号`s`开头，以及小数点（.）符号。 `s` 参数也可以使用指数表示法。
Number	`ws`、`sign`、千位分隔符（、）和小数点（.）元素。
Any	所有元素。但是，`s` 不能表示十六进制数。

provider 参数是 IFormatProvider 实现。其 GetFormat 方法返回一个 NumberFormatInfo 对象，该对象提供有关 value格式的区域性特定信息。通常，provider 可以是以下任一项：

表示提供数字格式信息的区域性的 CultureInfo 对象。其 GetFormat 方法返回提供数字格式信息的 NumberFormatInfo 对象。
提供格式信息的 NumberFormatInfo 对象。（它的 GetFormat 实现只是返回自己。
实现 IFormatProvider 并使用 GetFormat 方法实例化和返回提供格式信息的 NumberFormatInfo 对象的自定义对象。

如果 providernull，则使用当前区域性的 NumberFormatInfo 对象。

另请参阅

ToString()
分析 .NET 中的数值字符串

适用于

反馈

此页面是否有帮助？