UInt16.Parse 方法

定义

命名空间:: System

程序集:: mscorlib.dll, System.Runtime.dll

程序集:: netstandard.dll, System.Runtime.dll

程序集:: System.Runtime.dll

程序集:: mscorlib.dll

程序集:: netstandard.dll

重要

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

将数字的字符串表示形式转换为其等效的 16 位无符号整数。

重载

名称	说明
Parse(String, NumberStyles, IFormatProvider)	将指定样式和区域性特定格式的数字的字符串表示形式转换为其等效的 16 位无符号整数。
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	将指定样式和区域性特定格式的数字的跨度表示形式转换为其等效的 16 位无符号整数。
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	将 UTF-8 字符的范围分析为值。
Parse(String, IFormatProvider)	将指定区域性特定格式的数字的字符串表示形式转换为其等效的 16 位无符号整数。
Parse(String, NumberStyles)	将指定样式中的数字的字符串表示形式转换为其等效的 16 位无符号整数。此方法不符合 CLS。符合 CLS 的替代方法是 Parse(String, NumberStyles)。
Parse(ReadOnlySpan<Char>, IFormatProvider)	将字符的范围分析为值。
Parse(ReadOnlySpan<Byte>, IFormatProvider)	将 UTF-8 字符的范围分析为值。
Parse(String)	将数字的字符串表示形式转换为其等效的 16 位无符号整数。

Parse(String, NumberStyles, IFormatProvider)

Source:: UInt16.cs

Source:: UInt16.cs

Source:: UInt16.cs

Source:: UInt16.cs

Source:: UInt16.cs

重要

此 API 不符合 CLS。

符合 CLS 的替代方案: System.Int32.Parse(String)

将指定样式和区域性特定格式的数字的字符串表示形式转换为其等效的 16 位无符号整数。

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

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

[System.CLSCompliant(false)]
public static ushort Parse(string s, System.Globalization.NumberStyles style, IFormatProvider provider);

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

[System.CLSCompliant(false)]
public static ushort Parse(string s, System.Globalization.NumberStyles style, IFormatProvider? provider);

[<System.CLSCompliant(false)>]
static member Parse : string * System.Globalization.NumberStyles * IFormatProvider -> uint16

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

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

参数

s: String

一个表示要转换的数字的字符串。该字符串通过使用参数指定的 style 样式进行解释。

style: NumberStyles

枚举值的按位组合，指示可以存在的 s样式元素。要指定 Integer的典型值为。

provider: IFormatProvider

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

UInt16

一个等效于指定 s数字的 16 位无符号整数。

实现

Parse(String, NumberStyles, IFormatProvider)

属性: CLSCompliantAttribute

例外

ArgumentNullException

s 是 null。

ArgumentException

style 不是值 NumberStyles 。

-或-

style不是值的组合AllowHexSpecifier HexNumber。

FormatException

s 格式不符合 style。

OverflowException

s 表示小于 UInt16.MinValue 或大于 UInt16.MaxValue 的数字。

-或-

s 包括非零的小数位数。

示例

下面的示例使用 Parse(String, NumberStyles, IFormatProvider) 该方法将数字的各种字符串表示形式转换为 16 位无符号整数值。

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] cultureNames = { "en-US", "fr-FR" };
      NumberStyles[] styles= { NumberStyles.Integer, 
                               NumberStyles.Integer | NumberStyles.AllowDecimalPoint };
      string[] values = { "1702", "+1702.0", "+1702,0", "-1032.00",
                          "-1032,00", "1045.1", "1045,1" };
      
      // Parse strings using each culture
      foreach (string cultureName in cultureNames)
      {
         CultureInfo ci = new CultureInfo(cultureName);
         Console.WriteLine("Parsing strings using the {0} culture", 
                           ci.DisplayName);
         // Use each style.
         foreach (NumberStyles style in styles)
         {
            Console.WriteLine("   Style: {0}", style.ToString());
            // Parse each numeric string.
            foreach (string value in values)
            {
               try {
                  Console.WriteLine("      Converted '{0}' to {1}.", value, 
                                    UInt16.Parse(value, style, ci));
               }                                    
               catch (FormatException) {
                  Console.WriteLine("      Unable to parse '{0}'.", value);   
               }
               catch (OverflowException) {
                  Console.WriteLine("      '{0}' is out of range of the UInt16 type.", 
                                    value);
               }
            }
         }
      }   
   }
}
// The example displays the following output:
//       Parsing strings using the English (United States) culture
//          Style: Integer
//             Converted '1702' to 1702.
//             Unable to parse '+1702.0'.
//             Unable to parse '+1702,0'.
//             Unable to parse '-1032.00'.
//             Unable to parse '-1032,00'.
//             Unable to parse '1045.1'.
//             Unable to parse '1045,1'.
//          Style: Integer, AllowDecimalPoint
//             Converted '1702' to 1702.
//             Converted '+1702.0' to 1702.
//             Unable to parse '+1702,0'.
//             '-1032.00' is out of range of the UInt16 type.
//             Unable to parse '-1032,00'.
//             '1045.1' is out of range of the UInt16 type.
//             Unable to parse '1045,1'.
//       Parsing strings using the French (France) culture
//          Style: Integer
//             Converted '1702' to 1702.
//             Unable to parse '+1702.0'.
//             Unable to parse '+1702,0'.
//             Unable to parse '-1032.00'.
//             Unable to parse '-1032,00'.
//             Unable to parse '1045.1'.
//             Unable to parse '1045,1'.
//          Style: Integer, AllowDecimalPoint
//             Converted '1702' to 1702.
//             Unable to parse '+1702.0'.
//             Converted '+1702,0' to 1702.
//             Unable to parse '-1032.00'.
//             '-1032,00' is out of range of the UInt16 type.
//             Unable to parse '1045.1'.
//             '1045,1' is out of range of the UInt16 type.

open System
open System.Globalization

let cultureNames = [| "en-US"; "fr-FR" |]
let styles = 
    [| NumberStyles.Integer; NumberStyles.Integer ||| NumberStyles.AllowDecimalPoint |]
let values =
    [| "1702"; "+1702.0"; "+1702,0"; "-1032.00"; "-1032,00"; "1045.1"; "1045,1" |]

// Parse strings using each culture
for cultureName in cultureNames do
    let ci = CultureInfo cultureName
    printfn $"Parsing strings using the {ci.DisplayName} culture"
    // Use each style.
    for style in styles do
        printfn $"   Style: {style}"
        // Parse each numeric string.
        for value in values do
            try
                printfn $"      Converted '{value}' to {UInt16.Parse(value, style, ci)}."
            with
            | :? FormatException ->
                printfn $"      Unable to parse '{value}'."
            | :? OverflowException ->
                printfn $"      '{value}' is out of range of the UInt16 type."
// The example displays the following output:
//       Parsing strings using the English (United States) culture
//          Style: Integer
//             Converted '1702' to 1702.
//             Unable to parse '+1702.0'.
//             Unable to parse '+1702,0'.
//             Unable to parse '-1032.00'.
//             Unable to parse '-1032,00'.
//             Unable to parse '1045.1'.
//             Unable to parse '1045,1'.
//          Style: Integer, AllowDecimalPoint
//             Converted '1702' to 1702.
//             Converted '+1702.0' to 1702.
//             Unable to parse '+1702,0'.
//             '-1032.00' is out of range of the UInt16 type.
//             Unable to parse '-1032,00'.
//             '1045.1' is out of range of the UInt16 type.
//             Unable to parse '1045,1'.
//       Parsing strings using the French (France) culture
//          Style: Integer
//             Converted '1702' to 1702.
//             Unable to parse '+1702.0'.
//             Unable to parse '+1702,0'.
//             Unable to parse '-1032.00'.
//             Unable to parse '-1032,00'.
//             Unable to parse '1045.1'.
//             Unable to parse '1045,1'.
//          Style: Integer, AllowDecimalPoint
//             Converted '1702' to 1702.
//             Unable to parse '+1702.0'.
//             Converted '+1702,0' to 1702.
//             Unable to parse '-1032.00'.
//             '-1032,00' is out of range of the UInt16 type.
//             Unable to parse '1045.1'.
//             '1045,1' is out of range of the UInt16 type.

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim cultureNames() As String = { "en-US", "fr-FR" }
      Dim styles() As NumberStyles = { NumberStyles.Integer, _
                                       NumberStyles.Integer Or NumberStyles.AllowDecimalPoint }
      Dim values() As String = { "1702", "+1702.0", "+1702,0", "-1032.00", _
                                 "-1032,00", "1045.1", "1045,1" }
      
      ' Parse strings using each culture
      For Each cultureName As String In cultureNames
         Dim ci As New CultureInfo(cultureName)
         Console.WriteLine("Parsing strings using the {0} culture", ci.DisplayName)
         ' Use each style.
         For Each style As NumberStyles In styles
            Console.WriteLine("   Style: {0}", style.ToString())
            ' Parse each numeric string.
            For Each value As String In values
               Try
                  Console.WriteLine("      Converted '{0}' to {1}.", value, _
                                    UInt16.Parse(value, style, ci))
               Catch e As FormatException
                  Console.WriteLine("      Unable to parse '{0}'.", value)   
               Catch e As OverflowException
                  Console.WriteLine("      '{0}' is out of range of the UInt16 type.", _
                                    value)         
               End Try
            Next
         Next
      Next                                    
   End Sub
End Module
' The example displays the following output:
'       Parsing strings using the English (United States) culture
'          Style: Integer
'             Converted '1702' to 1702.
'             Unable to parse '+1702.0'.
'             Unable to parse '+1702,0'.
'             Unable to parse '-1032.00'.
'             Unable to parse '-1032,00'.
'             Unable to parse '1045.1'.
'             Unable to parse '1045,1'.
'          Style: Integer, AllowDecimalPoint
'             Converted '1702' to 1702.
'             Converted '+1702.0' to 1702.
'             Unable to parse '+1702,0'.
'             '-1032.00' is out of range of the UInt16 type.
'             Unable to parse '-1032,00'.
'             '1045.1' is out of range of the UInt16 type.
'             Unable to parse '1045,1'.
'       Parsing strings using the French (France) culture
'          Style: Integer
'             Converted '1702' to 1702.
'             Unable to parse '+1702.0'.
'             Unable to parse '+1702,0'.
'             Unable to parse '-1032.00'.
'             Unable to parse '-1032,00'.
'             Unable to parse '1045.1'.
'             Unable to parse '1045,1'.
'          Style: Integer, AllowDecimalPoint
'             Converted '1702' to 1702.
'             Unable to parse '+1702.0'.
'             Converted '+1702,0' to 1702.
'             Unable to parse '-1032.00'.
'             '-1032,00' is out of range of the UInt16 type.
'             Unable to parse '1045.1'.
'             '1045,1' is out of range of the UInt16 type.

注解

该 style 参数定义允许在 s 参数中成功执行分析操作的样式元素（如空格或正符号或负号符号）。它必须是枚举中的 NumberStyles 位标志的组合。

参数可能包含以下元素，style具体取决于其值s：

[ws][$][sign]digits[.fractional_digits][E[sign]exponential_digits][ws]

方括号（[ 和 ]）中的元素是可选的。如果 style 包含 NumberStyles.AllowHexSpecifier，则 s 参数可能包含以下元素：

[ws]hexdigits[ws]

下表描述了每个元素。

元素	描述
ws	可选空格。如果`style`包含标志，则空白可以出现在标志的`s`开头，如果包含NumberStyles.AllowTrailingWhite标志，则它将显示在该标志的`styles`NumberStyles.AllowLeadingWhite末尾。
$	区域性特定的货币符号。字符串中的位置由CurrencyPositivePattern参数方法`provider`返回GetFormat的对象属性NumberFormatInfo定义。如果`s`包含标志，则货币符号可以出现在`style`其中NumberStyles.AllowCurrencySymbol。
签名	可选符号。（如果方法包含负号并表示非零数字，则引发OverflowException`s`该方法。该标志可以出现在标志`style`NumberStyles.AllowLeadingSign的开头`s`，如果包含NumberStyles.AllowTrailingSign标志，则它可能会显示`sstyle`结束。括号可用于 `s` 指示负值（如果 `style` 包含 NumberStyles.AllowParentheses 标志）。
数字	从 0 到 9 的数字序列。
.	区域性特定的小数点符号。如果包含标志，则当前区域性的小数点符号可以出现在`sstyle`其中NumberStyles.AllowDecimalPoint。
fractional_digits	如果包含标志，则 `style` 为 NumberStyles.AllowExponent 0-9 位数字的一个或多个匹配项;如果没有，则为 0 位的一个或多个匹配项。仅当包含`s`标志时`style`，小数位数才会显示NumberStyles.AllowDecimalPoint。
E	“e”或“E”字符，指示该值以指数（科学）表示法表示。如果`s`包含标志，则参数`style`可以表示指数表示法中的NumberStyles.AllowExponent数字。
exponential_digits	从 0 到 9 的数字序列。如果`s`包含标志，则参数`style`可以表示指数表示法中的NumberStyles.AllowExponent数字。
hexdigits	从 0 到 f 或 0 到 F 的十六进制数字序列。

注意

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

仅包含十进制数字（对应于样式）的 NumberStyles.None 字符串始终成功分析。此输入字符串中可能存在但不需要存在的大多数剩余 NumberStyles 成员控制元素。下表指示各个 NumberStyles 成员如何影响可能存在于 s的元素。

非复合 `NumberStyles` 值	除数字外允许 `s` 的元素
NumberStyles.None	仅十进制数字。
NumberStyles.AllowDecimalPoint	小数点（.）和 fractional_digits 元素。但是，如果样式不包含 NumberStyles.AllowExponent 标志， fractional_digits 必须仅包含一个或多个数字;否则将引发一个 OverflowException 。
NumberStyles.AllowExponent	指示指数表示法的“e”或“E”字符以及 exponential_digits。
NumberStyles.AllowLeadingWhite	开头的 `s`ws 元素。
NumberStyles.AllowTrailingWhite	末尾的 `s` 元素
NumberStyles.AllowLeadingSign	数字之前的符号。
NumberStyles.AllowTrailingSign	数字后的符号。
NumberStyles.AllowParentheses	在数字前后用括号来指示负值。
NumberStyles.AllowThousands	组分隔符（，）元素。
NumberStyles.AllowCurrencySymbol	currency （$）元素。

NumberStyles.AllowHexSpecifier如果使用标志，s则必须是十六进制值。有效的十六进制数字为 0 到 9、a 到 f 和 A 到 F。不支持前缀（如“0x”），并导致分析操作失败。唯一可以与 NumberStyles.AllowHexSpecifier 它们组合的其他标志是 NumberStyles.AllowLeadingWhite 和 NumberStyles.AllowTrailingWhite。 NumberStyles（枚举包括复合数字样式，NumberStyles.HexNumber包括两个空格标志。

注意

s如果参数是十六进制数的字符串表示形式，则它不能以任何修饰（如0x或&h）来区分它为十六进制数。这会导致分析操作引发异常。

参数 provider 是一个 IFormatProvider 实现，其 GetFormat 方法返回一个 NumberFormatInfo 对象，该对象提供有关格式的 s区域性特定信息。可通过三种方法使用 provider 参数向分析作提供自定义格式信息：

可以传递提供格式设置信息的实际 NumberFormatInfo 对象。（其实现 GetFormat 只是返回自身。
可以传递一个 CultureInfo 对象，该对象指定要使用其格式的区域性。其 NumberFormat 属性提供格式设置信息。
可以传递自定义 IFormatProvider 实现。其 GetFormat 方法必须实例化并返回 NumberFormatInfo 提供格式信息的对象。

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

另请参阅

适用于

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Source:: UInt16.cs

Source:: UInt16.cs

Source:: UInt16.cs

Source:: UInt16.cs

Source:: UInt16.cs

重要

此 API 不符合 CLS。

将指定样式和区域性特定格式的数字的跨度表示形式转换为其等效的 16 位无符号整数。

public static ushort Parse(ReadOnlySpan<char> s, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Integer, IFormatProvider? provider = default);

[System.CLSCompliant(false)]
public static ushort Parse(ReadOnlySpan<char> s, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Integer, IFormatProvider provider = default);

[System.CLSCompliant(false)]
public static ushort Parse(ReadOnlySpan<char> s, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Integer, IFormatProvider? provider = default);

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

[<System.CLSCompliant(false)>]
static member Parse : ReadOnlySpan<char> * System.Globalization.NumberStyles * IFormatProvider -> uint16

Public Shared Function Parse (s As ReadOnlySpan(Of Char), Optional style As NumberStyles = System.Globalization.NumberStyles.Integer, Optional provider As IFormatProvider = Nothing) As UShort

参数

s: ReadOnlySpan<Char>

一个范围，包含表示要转换的数字的字符。使用参数指定的 style 样式来解释范围。

style: NumberStyles

枚举值的按位组合，指示可以存在的 s样式元素。要指定 Integer的典型值为。

provider: IFormatProvider

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

UInt16

一个等效于指定 s数字的 16 位无符号整数。

实现

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

属性: CLSCompliantAttribute

适用于

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Source:: UInt16.cs

Source:: UInt16.cs

Source:: UInt16.cs

Source:: UInt16.cs

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

public static ushort Parse(ReadOnlySpan<byte> utf8Text, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Integer, IFormatProvider? provider = default);

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

Public Shared Function Parse (utf8Text As ReadOnlySpan(Of Byte), Optional style As NumberStyles = System.Globalization.NumberStyles.Integer, Optional provider As IFormatProvider = Nothing) As UShort

参数

utf8Text: ReadOnlySpan<Byte>

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

style: NumberStyles

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

provider: IFormatProvider

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

UInt16

分析 utf8Text的结果。

实现

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

适用于

Parse(String, IFormatProvider)

Source:: UInt16.cs

Source:: UInt16.cs

Source:: UInt16.cs

Source:: UInt16.cs

Source:: UInt16.cs

重要

此 API 不符合 CLS。

符合 CLS 的替代方案: System.Int32.Parse(String)

将指定区域性特定格式的数字的字符串表示形式转换为其等效的 16 位无符号整数。

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

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

[System.CLSCompliant(false)]
public static ushort Parse(string s, IFormatProvider provider);

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

[System.CLSCompliant(false)]
public static ushort Parse(string s, IFormatProvider? provider);

[<System.CLSCompliant(false)>]
static member Parse : string * IFormatProvider -> uint16

static member Parse : string * IFormatProvider -> uint16

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

参数

s: String

一个表示要转换的数字的字符串。

provider: IFormatProvider

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

UInt16

一个等效于指定 s数字的 16 位无符号整数。

实现

Parse(String, IFormatProvider)

属性: CLSCompliantAttribute

例外

ArgumentNullException

s 是 null。

FormatException

s 格式不正确。

OverflowException

s 表示小于 UInt16.MinValue 或大于 UInt16.MaxValue 的数字。

示例

以下示例实例化使用两个加号（++）作为正符号的自定义区域性。然后，它调用 Parse(String, IFormatProvider) 此方法，以使用 CultureInfo 表示此自定义区域性和固定区域性的对象分析字符串数组。

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      // Define a custom culture that uses "++" as a positive sign. 
      CultureInfo ci = new CultureInfo("");
      ci.NumberFormat.PositiveSign = "++";
      // Create an array of cultures.
      CultureInfo[] cultures = { ci, CultureInfo.InvariantCulture };
      // Create an array of strings to parse.
      string[] values = { "++1403", "-0", "+0", "+16034", 
                          Int16.MinValue.ToString(), "14.0", "18012" };
      // Parse the strings using each culture.
      foreach (CultureInfo culture in cultures)
      {
         Console.WriteLine("Parsing with the '{0}' culture.", culture.Name);
         foreach (string value in values)
         {
            try {
               ushort number = UInt16.Parse(value, culture);
               Console.WriteLine("   Converted '{0}' to {1}.", value, number);
            }
            catch (FormatException) {
               Console.WriteLine("   The format of '{0}' is invalid.", value);
            }
            catch (OverflowException) {
               Console.WriteLine("   '{0}' is outside the range of a UInt16 value.", value);
            }               
         }
      }
   }
}
// The example displays the following output:
//       Parsing with the  culture.
//          Converted '++1403' to 1403.
//          Converted '-0' to 0.
//          The format of '+0' is invalid.
//          The format of '+16034' is invalid.
//          '-32768' is outside the range of a UInt16 value.
//          The format of '14.0' is invalid.
//          Converted '18012' to 18012.
//       Parsing with the '' culture.
//          The format of '++1403' is invalid.
//          Converted '-0' to 0.
//          Converted '+0' to 0.
//          Converted '+16034' to 16034.
//          '-32768' is outside the range of a UInt16 value.
//          The format of '14.0' is invalid.
//          Converted '18012' to 18012.

open System
open System.Globalization

// Define a custom culture that uses "++" as a positive sign. 
let ci = CultureInfo ""
ci.NumberFormat.PositiveSign <- "++"
// Create an array of cultures.
let cultures = [| ci; CultureInfo.InvariantCulture |]
// Create an array of strings to parse.
let values = 
    [| "++1403"; "-0"; "+0"; "+16034" 
       string Int16.MinValue; "14.0"; "18012" |]
// Parse the strings using each culture.
for culture in cultures do
    printfn $"Parsing with the '{culture.Name}' culture."
    for value in values do
        try
            let number = UInt16.Parse(value, culture)
            printfn $"   Converted '{value}' to {number}."
        with
        | :? FormatException ->
            printfn $"   The format of '{value}' is invalid."
        | :? OverflowException ->
            printfn $"   '{value}' is outside the range of a UInt16 value."
// The example displays the following output:
//       Parsing with the  culture.
//          Converted '++1403' to 1403.
//          Converted '-0' to 0.
//          The format of '+0' is invalid.
//          The format of '+16034' is invalid.
//          '-32768' is outside the range of a UInt16 value.
//          The format of '14.0' is invalid.
//          Converted '18012' to 18012.
//       Parsing with the '' culture.
//          The format of '++1403' is invalid.
//          Converted '-0' to 0.
//          Converted '+0' to 0.
//          Converted '+16034' to 16034.
//          '-32768' is outside the range of a UInt16 value.
//          The format of '14.0' is invalid.
//          Converted '18012' to 18012.

Imports System.Globalization

Module Example
   Public Sub Main()
      ' Define a custom culture that uses "++" as a positive sign. 
      Dim ci As CultureInfo = New CultureInfo("")
      ci.NumberFormat.PositiveSign = "++"
      ' Create an array of cultures.
      Dim cultures() As CultureInfo = { ci, CultureInfo.InvariantCulture }
      ' Create an array of strings to parse.
      Dim values() As String = { "++1403", "-0", "+0", "+16034", _
                                 Int16.MinValue.ToString(), "14.0", "18012" }
      ' Parse the strings using each culture.
      For Each culture As CultureInfo In cultures
         Console.WriteLine("Parsing with the '{0}' culture.", culture.Name)
         For Each value As String In values
            Try
               Dim number As UShort = UInt16.Parse(value, culture)
               Console.WriteLine("   Converted '{0}' to {1}.", value, number)
            Catch e As FormatException
               Console.WriteLine("   The format of '{0}' is invalid.", value)
            Catch e As OverflowException
               Console.WriteLine("   '{0}' is outside the range of a UInt16 value.", value)
            End Try               
         Next
      Next
   End Sub
End Module
' The example displays the following output:
'       Parsing with the  culture.
'          Converted '++1403' to 1403.
'          Converted '-0' to 0.
'          The format of '+0' is invalid.
'          The format of '+16034' is invalid.
'          '-32768' is outside the range of a UInt16 value.
'          The format of '14.0' is invalid.
'          Converted '18012' to 18012.
'       Parsing with the '' culture.
'          The format of '++1403' is invalid.
'          Converted '-0' to 0.
'          Converted '+0' to 0.
'          Converted '+16034' to 16034.
'          '-32768' is outside the range of a UInt16 value.
'          The format of '14.0' is invalid.
'          Converted '18012' to 18012.

注解

该 s 参数包含多种形式：

[ws][sign]digits[ws]

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

元素	描述
ws	可选空格。
标志	可选符号，如果 `s` 表示值零，则为负号。
数字	一系列数字，范围从 0 到 9。

使用样式解释 NumberStyles.Integer s 参数。除了字节值的十进制数字外，还允许前导和尾随空格以及前导符号。（如果存在负号， s 则必须表示值为零或方法引发 . OverflowException）若要显式定义样式元素以及可存在于区域性特定的格式信息中 s，请使用该方法 Parse(String, NumberStyles, IFormatProvider) 。

可以传递提供格式设置信息的实际 NumberFormatInfo 对象。（其实现 GetFormat 只是返回自身。
可以传递一个 CultureInfo 对象，该对象指定要使用其格式的区域性。其 NumberFormat 属性提供格式设置信息。
可以传递自定义 IFormatProvider 实现。其 GetFormat 方法必须实例化并返回 NumberFormatInfo 提供格式信息的对象。

null如果是provider，则NumberFormatInfo使用当前区域性。

另请参阅

适用于

Parse(String, NumberStyles)

Source:: UInt16.cs

Source:: UInt16.cs

Source:: UInt16.cs

Source:: UInt16.cs

Source:: UInt16.cs

重要

此 API 不符合 CLS。

将指定样式中的数字的字符串表示形式转换为其等效的 16 位无符号整数。

此方法不符合 CLS。符合 CLS 的替代方法是 Parse(String, NumberStyles)。

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

[System.CLSCompliant(false)]
public static ushort Parse(string s, System.Globalization.NumberStyles style);

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

[<System.CLSCompliant(false)>]
static member Parse : string * System.Globalization.NumberStyles -> uint16

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

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

参数

s: String

一个表示要转换的数字的字符串。该字符串通过使用参数指定的 style 样式进行解释。

style: NumberStyles

指定允许格式 s的枚举值的按位组合。要指定 Integer的典型值为。

UInt16

一个等效于指定 s数字的 16 位无符号整数。

属性: CLSCompliantAttribute

例外

ArgumentNullException

s 是 null。

ArgumentException

style 不是值 NumberStyles 。

-或-

style不是值的组合AllowHexSpecifier HexNumber。

FormatException

s 格式不符合 style。

OverflowException

s 表示小于 UInt16.MinValue 或大于 UInt16.MaxValue 的数字。

-或-

s 包括非零的小数位数。

示例

以下示例尝试使用多个 NumberStyles 值分析字符串数组中的每个元素。

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] values = { " 214 ", "1,064", "(0)", "1241+", " + 214 ", " +214 ", "2153.0", "1e03", "1300.0e-2" };
      NumberStyles whitespace =  NumberStyles.AllowLeadingWhite | NumberStyles.AllowTrailingWhite;
      NumberStyles[] styles = { NumberStyles.None, whitespace, 
                                NumberStyles.AllowLeadingSign | NumberStyles.AllowTrailingSign | whitespace, 
                                NumberStyles.AllowThousands | NumberStyles.AllowCurrencySymbol, 
                                NumberStyles.AllowExponent | NumberStyles.AllowDecimalPoint };

      // Attempt to convert each number using each style combination.
      foreach (string value in values)
      {
         Console.WriteLine("Attempting to convert '{0}':", value);
         foreach (NumberStyles style in styles)
         {
            try {
               ushort number = UInt16.Parse(value, style);
               Console.WriteLine("   {0}: {1}", style, number);
            }   
            catch (FormatException) {
               Console.WriteLine("   {0}: Bad Format", style);
            }
         }
         Console.WriteLine();
      }
   }
}
// The example display the following output:
//    Attempting to convert ' 214 ':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: 214
//       Integer, AllowTrailingSign: 214
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: Bad Format
//    
//    Attempting to convert '1,064':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: Bad Format
//       AllowThousands, AllowCurrencySymbol: 1064
//       AllowDecimalPoint, AllowExponent: Bad Format
//    
//    Attempting to convert '(0)':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: Bad Format
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: Bad Format
//    
//    Attempting to convert '1241+':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: 1241
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: Bad Format
//    
//    Attempting to convert ' + 214 ':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: Bad Format
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: Bad Format
//    
//    Attempting to convert ' +214 ':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: 214
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: Bad Format
//    
//    Attempting to convert '2153.0':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: Bad Format
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: 2153
//    
//    Attempting to convert '1e03':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: Bad Format
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: 1000
//    
//    Attempting to convert '1300.0e-2':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: Bad Format
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: 13

open System
open System.Globalization

let values = [| " 214 "; "1,064"; "(0)"; "1241+"; " + 214 "; " +214 "; "2153.0"; "1e03"; "1300.0e-2" |]
let whitespace =  NumberStyles.AllowLeadingWhite ||| NumberStyles.AllowTrailingWhite
let styles = 
    [| NumberStyles.None; whitespace 
       NumberStyles.AllowLeadingSign ||| NumberStyles.AllowTrailingSign ||| whitespace 
       NumberStyles.AllowThousands ||| NumberStyles.AllowCurrencySymbol
       NumberStyles.AllowExponent ||| NumberStyles.AllowDecimalPoint |]

// Attempt to convert each number using each style combination.
for value in values do
    printfn $"Attempting to convert '{value}':"
    for style in styles do
        try
            let number = UInt16.Parse(value, style)
            printfn $"   {style}: {number}"
        with :? FormatException ->
            printfn $"   {style}: Bad Format"
    printfn ""
// The example display the following output:
//    Attempting to convert ' 214 ':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: 214
//       Integer, AllowTrailingSign: 214
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: Bad Format
//    
//    Attempting to convert '1,064':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: Bad Format
//       AllowThousands, AllowCurrencySymbol: 1064
//       AllowDecimalPoint, AllowExponent: Bad Format
//    
//    Attempting to convert '(0)':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: Bad Format
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: Bad Format
//    
//    Attempting to convert '1241+':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: 1241
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: Bad Format
//    
//    Attempting to convert ' + 214 ':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: Bad Format
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: Bad Format
//    
//    Attempting to convert ' +214 ':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: 214
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: Bad Format
//    
//    Attempting to convert '2153.0':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: Bad Format
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: 2153
//    
//    Attempting to convert '1e03':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: Bad Format
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: 1000
//    
//    Attempting to convert '1300.0e-2':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: Bad Format
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: 13

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim values() As String = { " 214 ", "1,064", "(0)", "1241+", " + 214 ", " +214 ", "2153.0", "1e03", "1300.0e-2" }
      Dim whitespace As NumberStyles =  NumberStyles.AllowLeadingWhite Or NumberStyles.AllowTrailingWhite
      Dim styles() As NumberStyles = { NumberStyles.None, _
                                       whitespace, _
                                       NumberStyles.AllowLeadingSign Or NumberStyles.AllowTrailingSign Or whitespace, _
                                       NumberStyles.AllowThousands Or NumberStyles.AllowCurrencySymbol, _
                                       NumberStyles.AllowExponent Or NumberStyles.AllowDecimalPoint }

      ' Attempt to convert each number using each style combination.
      For Each value As String In values
         Console.WriteLine("Attempting to convert '{0}':", value)
         For Each style As NumberStyles In styles
            Try
               Dim number As UShort = UInt16.Parse(value, style)
               Console.WriteLine("   {0}: {1}", style, number)
            Catch e As FormatException
               Console.WriteLine("   {0}: Bad Format", style)
            End Try         
         Next
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output:
'    Attempting to convert ' 214 ':
'       None: Bad Format
'       AllowLeadingWhite, AllowTrailingWhite: 214
'       Integer, AllowTrailingSign: 214
'       AllowThousands, AllowCurrencySymbol: Bad Format
'       AllowDecimalPoint, AllowExponent: Bad Format
'    
'    Attempting to convert '1,064':
'       None: Bad Format
'       AllowLeadingWhite, AllowTrailingWhite: Bad Format
'       Integer, AllowTrailingSign: Bad Format
'       AllowThousands, AllowCurrencySymbol: 1064
'       AllowDecimalPoint, AllowExponent: Bad Format
'    
'    Attempting to convert '(0)':
'       None: Bad Format
'       AllowLeadingWhite, AllowTrailingWhite: Bad Format
'       Integer, AllowTrailingSign: Bad Format
'       AllowThousands, AllowCurrencySymbol: Bad Format
'       AllowDecimalPoint, AllowExponent: Bad Format
'    
'    Attempting to convert '1241+':
'       None: Bad Format
'       AllowLeadingWhite, AllowTrailingWhite: Bad Format
'       Integer, AllowTrailingSign: 1241
'       AllowThousands, AllowCurrencySymbol: Bad Format
'       AllowDecimalPoint, AllowExponent: Bad Format
'    
'    Attempting to convert ' + 214 ':
'       None: Bad Format
'       AllowLeadingWhite, AllowTrailingWhite: Bad Format
'       Integer, AllowTrailingSign: Bad Format
'       AllowThousands, AllowCurrencySymbol: Bad Format
'       AllowDecimalPoint, AllowExponent: Bad Format
'    
'    Attempting to convert ' +214 ':
'       None: Bad Format
'       AllowLeadingWhite, AllowTrailingWhite: Bad Format
'       Integer, AllowTrailingSign: 214
'       AllowThousands, AllowCurrencySymbol: Bad Format
'       AllowDecimalPoint, AllowExponent: Bad Format
'    
'    Attempting to convert '2153.0':
'       None: Bad Format
'       AllowLeadingWhite, AllowTrailingWhite: Bad Format
'       Integer, AllowTrailingSign: Bad Format
'       AllowThousands, AllowCurrencySymbol: Bad Format
'       AllowDecimalPoint, AllowExponent: 2153
'    
'    Attempting to convert '1e03':
'       None: Bad Format
'       AllowLeadingWhite, AllowTrailingWhite: Bad Format
'       Integer, AllowTrailingSign: Bad Format
'       AllowThousands, AllowCurrencySymbol: Bad Format
'       AllowDecimalPoint, AllowExponent: 1000
'    
'    Attempting to convert '1300.0e-2':
'       None: Bad Format
'       AllowLeadingWhite, AllowTrailingWhite: Bad Format
'       Integer, AllowTrailingSign: Bad Format
'       AllowThousands, AllowCurrencySymbol: Bad Format
'       AllowDecimalPoint, AllowExponent: 13

注解

该 style 参数定义允许在 s 参数中成功执行分析作的样式元素（如空格、正符号或负号符号、组分隔符或小数点符号）。 style 必须是枚举中的 NumberStyles 位标志的组合。当包含十六进制值的字符串表示形式、仅运行时已知的数字系统（十进制或十六进制）style或想要禁止空格或登录符号s时，此参数s使此方法重载非常有用s。

参数可能包含以下元素，style具体取决于其值s：

[ws][$][sign][digits，]digits[.fractional_digits][E[sign]exponential_digits][ws]

方括号（[ 和 ]）中的元素是可选的。如果 style 包含 NumberStyles.AllowHexSpecifier，则 s 参数可能包含以下元素：

[ws]hexdigits[ws]

下表描述了每个元素。

元素	描述
ws	可选空格。如果包含标志，则空白可以出现在标志的`s`开头，如果包含`style`标志，则可以显示在末尾NumberStyles.AllowLeadingWhite`s`。`style`NumberStyles.AllowTrailingWhite
$	区域性特定的货币符号。字符串中的位置由NumberFormatInfo.CurrencyNegativePattern NumberFormatInfo.CurrencyPositivePattern当前区域性的属性定义。如果`s`包含标志，则当前区域性的货币符号可以出现在`style`其中NumberStyles.AllowCurrencySymbol。
签名	可选符号。如果包含标志，则符号可以出现在标志的`s`开头，如果包含`style`标志，则它可能显示在末尾NumberStyles.AllowLeadingSign`s`。`style`NumberStyles.AllowTrailingSign 括号可用于 `s` 指示负值（如果 `style` 包含 NumberStyles.AllowParentheses 标志）。但是，负号符号只能与零一起使用;否则，该方法将引发一个 OverflowException。
数字 fractional_digits exponential_digits	从 0 到 9 的数字序列。对于 fractional_digits，只有数字 0 有效。
、	区域性特定的组分隔符符号。如果`s`包含标志，则当前区域性的组分隔符可以出现在`style`其中NumberStyles.AllowThousands。
.	区域性特定的小数点符号。如果包含标志，则当前区域性的小数点符号可以出现在`sstyle`其中NumberStyles.AllowDecimalPoint。只有数字 0 可以显示为分析作成功的小数位数;如果 fractional_digits 包含任何其他数字，则会引发 a FormatException 。
E	“e”或“E”字符，指示该值以指数（科学）表示法表示。如果`s`包含标志，则参数`style`可以表示指数表示法中的NumberStyles.AllowExponent数字。
hexdigits	从 0 到 f 或 0 到 F 的十六进制数字序列。

注意

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

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

`NumberStyles` 值	除数字外允许 `s` 的元素
None	仅数字元素。
AllowDecimalPoint	小数点（.）和小数位数元素。
AllowExponent	指示指数表示法的“e”或“E”字符以及 exponential_digits。
AllowLeadingWhite	开头的 `s` 元素。
AllowTrailingWhite	末尾的 `s` 元素
AllowLeadingSign	开头的 `s` 元素。
AllowTrailingSign	结尾处的 `s` 元素。
AllowParentheses	括住数值的括号形式的符号元素。
AllowThousands	组分隔符（，）元素。
AllowCurrencySymbol	currency （$）元素。
Currency	所有元素。但是， `s` 不能表示十六进制数或指数表示法中的数字。
Float	开头或末尾的 `s` 元素，在开头的`s`和小数点（.）符号。该 `s` 参数还可以使用指数表示法。
Number	、`wssign`组分隔符（，）和小数点（.）元素。
Any	所有元素。但是， `s` 不能表示十六进制数。

与其他允许但不需要的其他 NumberStyles 值不同，存在特定样式元素 s时， NumberStyles.AllowHexSpecifier 样式值表示始终将各个数值字符 s 解释为十六进制字符。有效的十六进制字符为 0-9、A-F 和 a-f。不支持前缀（如“0x”），并导致分析操作失败。唯一可与参数组合 style 的其他标志是 NumberStyles.AllowLeadingWhite 和 NumberStyles.AllowTrailingWhite。 NumberStyles（枚举包括复合数字样式，NumberStyles.HexNumber包括两个空格标志。

注意

如果是 s 十六进制数的字符串表示形式，则它不能前面有任何修饰（例如 0x 或 &h）将其区分为十六进制数。这会导致转换失败。

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

另请参阅

适用于

Parse(ReadOnlySpan<Char>, IFormatProvider)

Source:: UInt16.cs

Source:: UInt16.cs

Source:: UInt16.cs

Source:: UInt16.cs

Source:: UInt16.cs

将字符的范围分析为值。

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

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

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

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

参数

s: ReadOnlySpan<Char>

要分析的字符范围。

provider: IFormatProvider

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

UInt16

分析 s的结果。

实现

Parse(ReadOnlySpan<Char>, IFormatProvider)

适用于

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Source:: UInt16.cs

Source:: UInt16.cs

Source:: UInt16.cs

Source:: UInt16.cs

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

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

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

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

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

参数

utf8Text: ReadOnlySpan<Byte>

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

provider: IFormatProvider

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

UInt16

分析 utf8Text的结果。

实现

Parse(ReadOnlySpan<Byte>, IFormatProvider)

适用于

Parse(String)

Source:: UInt16.cs

Source:: UInt16.cs

Source:: UInt16.cs

Source:: UInt16.cs

Source:: UInt16.cs

重要

此 API 不符合 CLS。

符合 CLS 的替代方案: System.Int32.Parse(String)

将数字的字符串表示形式转换为其等效的 16 位无符号整数。

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

[System.CLSCompliant(false)]
public static ushort Parse(string s);

public static ushort Parse(string s);

[<System.CLSCompliant(false)>]
static member Parse : string -> uint16

static member Parse : string -> uint16

Public Shared Function Parse (s As String) As UShort

参数

s: String

一个表示要转换的数字的字符串。

UInt16

与中包含的 s数字等效的 16 位无符号整数。

属性: CLSCompliantAttribute

例外

ArgumentNullException

s 是 null。

FormatException

s 格式不正确。

OverflowException

s 表示小于 UInt16.MinValue 或大于 UInt16.MaxValue 的数字。

示例

以下示例调用 Parse(String) 该方法将字符串数组中的每个元素转换为无符号 16 位整数。

using System;

public class Example
{
   public static void Main()
   {
      string[] values = { "-0", "17", "-12", "185", "66012", "+0", 
                          "", null, "16.1", "28.0", "1,034" };
      foreach (string value in values)
      {
         try {
            ushort number = UInt16.Parse(value);
            Console.WriteLine("'{0}' --> {1}", value, number);
         }
         catch (FormatException) {
            Console.WriteLine("'{0}' --> Bad Format", value);
         }
         catch (OverflowException) {   
            Console.WriteLine("'{0}' --> OverflowException", value);
         }
         catch (ArgumentNullException) {
            Console.WriteLine("'{0}' --> Null", value);
         }
      }                                 
   }
}
// The example displays the following output:
//       '-0' --> 0
//       '17' --> 17
//       '-12' --> OverflowException
//       '185' --> 185
//       '66012' --> OverflowException
//       '+0' --> 0
//       '' --> Bad Format
//       '' --> Null
//       '16.1' --> Bad Format
//       '28.0' --> Bad Format
//       '1,034' --> Bad Format

open System

let values = 
    [| "-0"; "17"; "-12"; "185"; "66012"; "+0" 
       ""; null; "16.1"; "28.0"; "1,034" |]
for value in values do
    try
        let number = UInt16.Parse value
        printfn $"'{value}' --> {number}"
    with
    | :? FormatException ->
        printfn $"'{value}' --> Bad Format"
    | :? OverflowException ->
        printfn $"'{value}' --> OverflowException"
    | :? ArgumentNullException ->
        printfn $"'{value}' --> Null"
// The example displays the following output:
//       '-0' --> 0
//       '17' --> 17
//       '-12' --> OverflowException
//       '185' --> 185
//       '66012' --> OverflowException
//       '+0' --> 0
//       '' --> Bad Format
//       '' --> Null
//       '16.1' --> Bad Format
//       '28.0' --> Bad Format
//       '1,034' --> Bad Format

Module Example
   Public Sub Main()
      Dim values() As String = { "-0", "17", "-12", "185", "66012", _ 
                                 "+0", "", Nothing, "16.1", "28.0", _
                                 "1,034" }
      For Each value As String In values
         Try
            Dim number As UShort = UInt16.Parse(value)
            Console.WriteLine("'{0}' --> {1}", value, number)
         Catch e As FormatException
            Console.WriteLine("'{0}' --> Bad Format", value)
         Catch e As OverflowException   
            Console.WriteLine("'{0}' --> OverflowException", value)
         Catch e As ArgumentNullException
            Console.WriteLine("'{0}' --> Null", value)
         End Try
      Next                                 
   End Sub
End Module
' The example displays the following output:
'       '-0' --> 0
'       '17' --> 17
'       '-12' --> OverflowException
'       '185' --> 185
'       '66012' --> OverflowException
'       '+0' --> 0
'       '' --> Bad Format
'       '' --> Null
'       '16.1' --> Bad Format
'       '28.0' --> Bad Format
'       '1,034' --> Bad Format

注解

该 s 参数应为以下格式的数字的字符串表示形式。

[ws][sign]digits[ws]

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

元素	描述
ws	可选空格。
签名	可选符号。有效符号字符由NumberFormatInfo.NegativeSign NumberFormatInfo.PositiveSign当前区域性的属性确定。但是，负号符号只能与零一起使用;否则，该方法将引发一个 OverflowException。
数字	一系列数字，范围从 0 到 9。将忽略任何前导零。

注意

参数指定的 s 字符串通过使用 NumberStyles.Integer 样式进行解释。它不能包含任何组分隔符或小数分隔符，并且不能包含小数部分。

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

另请参阅

适用于

反馈

此页面是否有帮助？