Single.Parse 方法

定義

命名空間:

System

組件:

System.Runtime.dll

將數位的字串表示轉換為其對等的單精度浮點數。

多載

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)

來源:

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 和舊版： 代表小於 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.

備註

在 .NET Core 3.0 和更新版本中，太大而無法表示的值會四捨五入為 IEEE 754 規格所需的 PositiveInfinity 或 NegativeInfinity。 在舊版中，包括 .NET Framework，剖析的值太大而無法表示導致失敗。

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 值。 不過，由於精確度遺失，值可能不相等。

如果 s 超出 Single 數據類型的範圍，此方法會在 .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)

來源:

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)

來源:

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)

來源:

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中可以存在的樣式專案。 要指定的一般值會與 AllowThousands結合 Float。

傳回

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.

備註

在 .NET Core 3.0 和更新版本中，太大而無法表示的值會四捨五入為 IEEE 754 規格所需的 PositiveInfinity 或 NegativeInfinity。 在舊版中，包括 .NET Framework，剖析的值太大而無法表示導致失敗。

style 參數會定義在剖析作業 s 參數中允許的樣式專案（例如空格符、千位分隔符和貨幣符號）。 它必須是來自 NumberStyles 列舉的位旗標組合。 不支援下列 NumberStyles 成員：

• AllowHexSpecifier

• HexNumber

s 參數可以包含目前文化特性的 PositiveInfinitySymbolNegativeInfinitySymbolNaNSymbol。 視 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 結尾。 括弧可用於 s，如果 style 包含 NumberStyles.AllowParentheses 旗標，則表示負值。

整數數位 指定數位整數部分的一系列數位，範圍從 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 ws 專案。
AllowTrailingWhite	s結尾的 ws 專案。
AllowLeadingSign	s開頭的 符號 專案。
AllowTrailingSign	s結尾處的 符號 專案。
AllowParentheses	以括弧括住數值的括弧形式，符號 專案。
AllowThousands	千位分隔符 （，） 元素。
AllowCurrencySymbol	currency （$） 元素。
Currency	所有元素。 不過，s 不能代表十六進位數或指數表示法的數位。
Float	s開頭或結尾的 ws 專案，符號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 值。 不過，由於精確度遺失，值可能不相等。

如果 s 超出 Single 數據類型的範圍，此方法會在 .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()
• TryParse
• .NET 中剖析數值字串

Parse(String, IFormatProvider)

來源:

Single.cs

將指定之特定文化特性格式之數位的字串表示轉換為其對等的單精度浮點數。

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

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 和舊版： 代表小於 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

備註

在 .NET Core 3.0 和更新版本中，太大而無法表示的值會四捨五入為 IEEE 754 規格所需的 PositiveInfinity 或 NegativeInfinity。 在舊版中，包括 .NET Framework，剖析的值太大而無法表示導致失敗。

此多載通常用來將各種格式的文字轉換成 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 超出 Single 數據類型的範圍，此方法會在 .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。

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

另請參閱

• ToString()
• TryParse
• .NET 中剖析數值字串

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

來源:

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)

來源:

Single.cs

將字元範圍，其中包含指定樣式和特定文化特性格式之數位的字串表示，轉換為其單精度浮點數對等專案。

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中可以存在的樣式專案。 要指定的一般值會與 AllowThousands結合 Float。

provider

IFormatProvider

物件，提供與 s相關的特定文化特性格式資訊。

傳回

Single

單精度浮點數，相當於 s中指定的數值或符號。

實作

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

例外狀況

FormatException

s 不代表數值。

ArgumentException

style 不是 NumberStyles 值。

-或-

style 是 AllowHexSpecifier 值。

備註

在 .NET Core 3.0 和更新版本中，太大而無法表示的值會四捨五入為 IEEE 754 規格所需的 PositiveInfinity 或 NegativeInfinity。 在舊版中，包括 .NET Framework，剖析的值太大而無法表示導致失敗。

如果 s 超出 Single 數據類型的範圍，則如果 s 小於 Single.MinValue，則方法會傳回 Single.NegativeInfinity;如果 s 大於 Single.MaxValue，則 Single.PositiveInfinity。

Parse(String, NumberStyles, IFormatProvider)

來源:

Single.cs

將指定樣式和特定文化特性格式之數位的字串表示轉換為其單精度浮點數對等專案。

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);

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中可以存在的樣式專案。 要指定的一般值會與 AllowThousands結合 Float。

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和自定義文化特性的格式慣例來剖析。 自定義文化特性會將其群組分隔符符號定義為底線 （“_”），並將其群組大小定義為兩個。

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.

備註

在 .NET Core 3.0 和更新版本中，太大而無法表示的值會四捨五入為 IEEE 754 規格所需的 PositiveInfinity 或 NegativeInfinity。 在舊版中，包括 .NET Framework，剖析的值太大而無法表示導致失敗。

style 參數會定義在剖析作業 s 參數中允許的樣式專案（例如空格符、千位分隔符和貨幣符號）。 它必須是來自 NumberStyles 列舉的位旗標組合。 不支援下列 NumberStyles 成員：

• AllowHexSpecifier

• HexNumber

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 結尾。 括弧可用於 s，如果 style 包含 NumberStyles.AllowParentheses 旗標，則表示負值。
整數數位	一系列數位，範圍從 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.None 樣式），如果字串位於 Single 類型的範圍，則一律會成功剖析。 其餘 System.Globalization.NumberStyles 成員控件元素，這些元素可能存在，但不需要出現在輸入字串中。 下表指出個別 NumberStyles 旗標如何影響 s中可能出現的專案。

NumberStyles 值	除了數位以外，s 中允許的專案
None	整數數位 元素。
AllowDecimalPoint	小數點（.）和 小數位數 元素。
AllowExponent	表示指數表示法的 「e」 或 「E」 字元。 此旗標本身支援以 E數位 格式的值;需要額外的旗標，才能成功剖析具有正負號和小數點符號等元素的字串。
AllowLeadingWhite	s開頭的 ws ws 專案。
AllowTrailingWhite	s結尾的 ws 專案。
AllowLeadingSign	s開頭的 符號 專案。
AllowTrailingSign	s結尾處的 符號 專案。
AllowParentheses	以括弧括住數值的括弧形式，符號 專案。
AllowThousands	千位分隔符 （，） 元素。
AllowCurrencySymbol	currency （$） 元素。
Currency	所有元素。 不過，s 不能代表十六進位數或指數表示法的數位。
Float	s開頭或結尾的 ws 專案，符號s開頭，以及小數點 （.） 符號。 s 參數也可以使用指數表示法。
Number	ws、sign、千位分隔符 （、） 和小數點 （.） 元素。
Any	所有元素。 不過，s 不能代表十六進位數。

provider 參數是 IFormatProvider 實作。 其 GetFormat 方法會傳回 NumberFormatInfo 物件，提供 value格式的文化特性特定資訊。 一般而言，provider 可以是下列任一項：

• CultureInfo 物件，表示提供數值格式資訊的文化特性。 其 GetFormat 方法會傳回提供數值格式資訊的 NumberFormatInfo 物件。

• 提供格式資訊的 NumberFormatInfo 物件。 （其實作 GetFormat 只傳回自己。

• 實作 IFormatProvider 的自定義物件，並使用 GetFormat 方法來具現化及傳回提供格式資訊的 NumberFormatInfo 物件。

如果 provider 是 null，則會使用目前文化特性的 NumberFormatInfo 物件。

如果 s 超出 Single 數據類型的範圍，此方法會在 .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 中剖析數值字串