UInt16.Parse Metoda

Definice

Obor názvů:

System

Sestavení:

netstandard.dll, System.Runtime.dll

Převede řetězcové vyjádření čísla na 16bitové celé číslo bez znaménka.

Přetížení

Name	Description
Parse(String, NumberStyles, IFormatProvider)	Převede řetězcovou reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho 16bitový celočíselnou ekvivalent.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Převede reprezentaci rozsahu čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho 16bitový celočíselné ekvivalent.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	Parsuje rozsah znaků UTF-8 do hodnoty.
Parse(String, IFormatProvider)	Převede řetězcovou reprezentaci čísla v zadaném formátu specifickém pro jazykovou verzi na 16bitové celé číslo bez znaménka.
Parse(String, NumberStyles)	Převede řetězcovou reprezentaci čísla v zadaném stylu na 16bitové celočíselné ekvivalenty bez znaménka. Tato metoda není kompatibilní se specifikací CLS. Alternativou kompatibilní se specifikací CLS je Parse(String, NumberStyles).
Parse(ReadOnlySpan<Char>, IFormatProvider)	Parsuje rozsah znaků do hodnoty.
Parse(ReadOnlySpan<Byte>, IFormatProvider)	Parsuje rozsah znaků UTF-8 do hodnoty.
Parse(String)	Převede řetězcové vyjádření čísla na 16bitové celé číslo bez znaménka.

Parse(String, NumberStyles, IFormatProvider)

Zdroj:

UInt16.cs

Důležité

Toto rozhraní API neodpovídá specifikaci CLS.

Alternativa odpovídající specifikaci CLS

System.Int32.Parse(String)

Převede řetězcovou reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho 16bitový celočíselnou ekvivalent.

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

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

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

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

Parametry

s

String

Řetězec, který představuje číslo, které se má převést. Řetězec se interpretuje pomocí stylu určeného parametrem style .

style

NumberStyles

Bitová kombinace hodnot výčtu, které označují prvky stylu, které mohou být přítomny v s. Typická hodnota, kterou je třeba zadat, je Integer.

provider

IFormatProvider

Objekt, který poskytuje informace o sformátování specifické pro jazykovou verzi .

Návraty

UInt16

16bitové celé číslo bez znaménka odpovídající číslu zadanému v s.

Implementuje

Parse(String, NumberStyles, IFormatProvider)

Výjimky

ArgumentNullException

s je null.

ArgumentException

style není NumberStyles hodnota.

-nebo-

style není kombinací AllowHexSpecifier a HexNumber hodnot.

FormatException

s není ve formátu kompatibilním s style.

OverflowException

s představuje číslo, které je menší než UInt16.MinValue nebo větší než UInt16.MaxValue.

-nebo-

s obsahuje nenulové desetinné číslice.

Příklady

Následující příklad používá metodu Parse(String, NumberStyles, IFormatProvider) k převodu různých řetězcových reprezentací čísel na 16bitové celočíselné hodnoty bez znaménka.

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.

Poznámky

Parametr style definuje prvky stylu (například prázdné znaky nebo symbol kladného nebo záporného znaménka), které jsou v parametru s povolené, aby operace analýzy byla úspěšná. Musí se jednat o kombinaci bitových příznaků z výčtu NumberStyles .

V závislosti na hodnotě styleparametru s může obsahovat následující prvky:

[ws][$][znaménko]digits[.fractional_digits][E[sign]exponential_digits][ws]

Prvky v hranatých závorkách ([ a ]) jsou volitelné. Pokud style tento parametr obsahuje NumberStyles.AllowHexSpecifier, s může obsahovat následující prvky:

[ws]hexdigits[ws]

Následující tabulka popisuje jednotlivé prvky.

Element	Popis
Ws	Volitelné prázdné znaky. Prázdné znaky se můžou objevit na začátku s , pokud style příznak obsahuje NumberStyles.AllowLeadingWhite , a může se zobrazit na konci s , pokud style příznak NumberStyles.AllowTrailingWhite obsahuje.
$	Symbol měny specifický pro jazykovou verzi. Jeho pozice v řetězci je definována CurrencyPositivePattern vlastností objektu NumberFormatInfo , který je vrácen GetFormat metodou parametru provider . Symbol měny se může zobrazit, s pokud style obsahuje NumberStyles.AllowCurrencySymbol příznak.
znaménko	Volitelné znaménko. (Metoda vyvolá OverflowException hodnotu if s včetně záporného znaménka a představuje nenulové číslo.) Znaménko se může zobrazit na začátku s , pokud style příznak obsahuje NumberStyles.AllowLeadingSign , a může se zobrazit na konci příznaku s , pokud style příznak NumberStyles.AllowTrailingSign obsahuje. Závorky lze použít s k označení záporné hodnoty, pokud style obsahuje NumberStyles.AllowParentheses příznak.
Číslic	Posloupnost číslic od 0 do 9.
.	Symbol desetinné čárky specifické pro jazykovou verzi. Symbol desetinné čárky aktuální jazykové verze se může zobrazit, s pokud style příznak obsahuje NumberStyles.AllowDecimalPoint .
Fractional_digits	Jeden nebo více výskytů číslice 0-9, pokud style obsahuje NumberStyles.AllowExponent příznak, nebo jeden nebo více výskytů číslice 0, pokud ne. Desetinná číslice se můžou zobrazovat s jenom v případě, že style příznak obsahuje NumberStyles.AllowDecimalPoint .
E	Znak "e" nebo "E", který označuje, že hodnota je reprezentována exponenciálním (vědeckým) zápisem. Parametr s může představovat číslo v exponenciálním zápisustyle, pokud NumberStyles.AllowExponent obsahuje příznak.
exponential_digits	Posloupnost číslic od 0 do 9. Parametr s může představovat číslo v exponenciálním zápisustyle, pokud NumberStyles.AllowExponent obsahuje příznak.
hexdigits	Posloupnost šestnáctkových číslic od 0 do f nebo 0 až F.

Poznámka

Všechny ukončující nulové znaky (U+0000) jsou s ignorovány operací analýzy bez ohledu na hodnotu argumentu style .

Řetězec s desetinnými číslicemi (který odpovídá NumberStyles.None stylu) se vždy úspěšně parsuje. Většina zbývajících NumberStyles členů ovládacích prvků, které mohou být přítomny, ale nemusí být přítomny v tomto vstupním řetězci. Následující tabulka uvádí, jak jednotlivé NumberStyles členy ovlivňují prvky, které mohou být přítomny v s.

Neseparované NumberStyles hodnoty	Prvky povolené s kromě číslic
NumberStyles.None	Pouze desítkové číslice.
NumberStyles.AllowDecimalPoint	Desetinná čárka (.) a fractional_digits elementy. Pokud však styl neobsahuje NumberStyles.AllowExponent příznak, fractional_digits se musí skládat pouze z jednoho nebo více 0 číslic; jinak OverflowException je vyvolán znak.
NumberStyles.AllowExponent	Znak "e" nebo "E", který označuje exponenciální notaci spolu s exponential_digits.
NumberStyles.AllowLeadingWhite	Element ws na začátku s.
NumberStyles.AllowTrailingWhite	Prvek ws na konci .s
NumberStyles.AllowLeadingSign	Znaménko před číslicemi.
NumberStyles.AllowTrailingSign	Znaménko za číslicemi.
NumberStyles.AllowParentheses	Závorky před a za číslicemi označují zápornou hodnotu.
NumberStyles.AllowThousands	Element oddělovače skupin (,).
NumberStyles.AllowCurrencySymbol	Prvek měny ($)

NumberStyles.AllowHexSpecifier Pokud se příznak použije, s musí být šestnáctková hodnota. Platné šestnáctkové číslice jsou 0 až 9, f a A až F. Předpona, například 0x, není podporovaná a způsobí selhání operace analýzy. Jediné ostatní příznaky, které lze kombinovat s NumberStyles.AllowHexSpecifier jsou NumberStyles.AllowLeadingWhite a NumberStyles.AllowTrailingWhite. (Výčet NumberStyles obsahuje složený styl čísla, NumberStyles.HexNumberkterý obsahuje oba příznaky prázdných znaků.)

Poznámka

s Pokud je parametr řetězcovou reprezentací šestnáctkového čísla, nemůže mu předcházet žádná dekorace (například 0x nebo&h), která ji odlišuje jako šestnáctkové číslo. To způsobí, že operace analýzy vyvolá výjimku.

Parametr provider je IFormatProvider implementace, jejíž GetFormat metoda vrací NumberFormatInfo objekt, který poskytuje informace specifické pro jazykovou verzi o formátu s. Existují tři způsoby použití parametru provider k zadání vlastních informací o formátování do operace analýzy:

• Můžete předat skutečný NumberFormatInfo objekt, který poskytuje informace o formátování. (Její implementace GetFormat jednoduše vrátí sama sebe.)

• Můžete předat CultureInfo objekt, který určuje jazykovou verzi, jejíž formátování se má použít. Jeho NumberFormat vlastnost poskytuje informace o formátování.

• Můžete předat vlastní IFormatProvider implementaci. Jeho GetFormat metoda musí vytvořit instanci a vrátit NumberFormatInfo objekt, který poskytuje informace o formátování.

Pokud provider ano null, NumberFormatInfo použije se objekt pro aktuální jazykovou verzi.

Viz také

• ToString()
• TryParse
• Analýza číselných řetězců v .NET

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Zdroj:

UInt16.cs

Důležité

Toto rozhraní API neodpovídá specifikaci CLS.

Převede reprezentaci rozsahu čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho 16bitový celočíselné ekvivalent.

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

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

Parametry

s

ReadOnlySpan<Char>

Rozsah obsahující znaky, které představují číslo k převodu. Rozsah se interpretuje pomocí stylu určeného parametrem style .

style

NumberStyles

Bitová kombinace hodnot výčtu, které označují prvky stylu, které mohou být přítomny v s. Typická hodnota, kterou je třeba zadat, je Integer.

provider

IFormatProvider

Objekt, který poskytuje informace o sformátování specifické pro jazykovou verzi .

Návraty

UInt16

16bitové celé číslo bez znaménka odpovídající číslu zadanému v s.

Implementuje

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Zdroj:

UInt16.cs

Parsuje rozsah znaků UTF-8 do hodnoty.

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

Parametry

utf8Text

ReadOnlySpan<Byte>

Rozsah znaků UTF-8 pro analýzu.

style

NumberStyles

Bitová kombinace stylů čísel, které mohou být přítomny v utf8Text.

provider

IFormatProvider

Objekt, který poskytuje informace o utf8Textformátování specifické pro jazykovou verzi .

Návraty

UInt16

Výsledek analýzy utf8Text.

Implementuje

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Parse(String, IFormatProvider)

Zdroj:

UInt16.cs

Důležité

Toto rozhraní API neodpovídá specifikaci CLS.

Alternativa odpovídající specifikaci CLS

System.Int32.Parse(String)

Převede řetězcovou reprezentaci čísla v zadaném formátu specifickém pro jazykovou verzi na 16bitové celé číslo bez znaménka.

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

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

static member Parse : string * IFormatProvider -> uint16

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

Parametry

s

String

Řetězec, který představuje číslo, které se má převést.

provider

IFormatProvider

Objekt, který poskytuje informace o sformátování specifické pro jazykovou verzi .

Návraty

UInt16

16bitové celé číslo bez znaménka odpovídající číslu zadanému v s.

Implementuje

Parse(String, IFormatProvider)

Výjimky

ArgumentNullException

s je null.

FormatException

s není ve správném formátu.

OverflowException

s představuje číslo menší než UInt16.MinValue nebo větší než UInt16.MaxValue.

Příklady

Následující příklad vytvoří instanci vlastní jazykové verze, která jako kladné znaménko používá dvě znaménka plus (++). Potom volá metodu Parse(String, IFormatProvider) k analýze pole řetězců pomocí CultureInfo objektů, které představují tuto vlastní jazykovou verzi i invariantní jazykovou verzi.

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.

Poznámky

Parametr s obsahuje číslo formuláře:

[ws][znaménko]digits[ws]

Položky v hranatých závorkách ([ a ]) jsou volitelné. Následující tabulka popisuje jednotlivé prvky.

Element	Popis
Ws	Volitelné prázdné znaky.
podepsat	Volitelné znaménko nebo záporné znaménko, pokud s představuje hodnotu nula.
číslice	Posloupnost číslic v rozsahu od 0 do 9

Parametr s se interpretuje pomocí NumberStyles.Integer stylu. Kromě desetinných číslic bajtové hodnoty jsou povoleny pouze počáteční a koncové mezery spolu s počátečním znakem. (Pokud je přítomno záporné znaménko, s musí představovat hodnotu nuly nebo metoda vyvolá OverflowExceptionhodnotu .) Chcete-li explicitně definovat prvky stylu spolu s informacemi o formátování specifické pro jazykovou verzi, které mohou být přítomny v s, použijte metodu Parse(String, NumberStyles, IFormatProvider) .

Parametr provider je IFormatProvider implementace, jejíž GetFormat metoda vrací NumberFormatInfo objekt, který poskytuje informace specifické pro jazykovou verzi o formátu s. Existují tři způsoby použití parametru provider k zadání vlastních informací o formátování do operace analýzy:

• Můžete předat skutečný NumberFormatInfo objekt, který poskytuje informace o formátování. (Její implementace GetFormat jednoduše vrátí sama sebe.)

• Můžete předat CultureInfo objekt, který určuje jazykovou verzi, jejíž formátování se má použít. Jeho NumberFormat vlastnost poskytuje informace o formátování.

• Můžete předat vlastní IFormatProvider implementaci. Jeho GetFormat metoda musí vytvořit instanci a vrátit NumberFormatInfo objekt, který poskytuje informace o formátování.

Pokud provider ano null, NumberFormatInfo použije se aktuální jazyková verze.

Viz také

• ToString()
• TryParse
• Analýza číselných řetězců v .NET

Parse(String, NumberStyles)

Zdroj:

UInt16.cs

Důležité

Toto rozhraní API neodpovídá specifikaci CLS.

Převede řetězcovou reprezentaci čísla v zadaném stylu na 16bitové celočíselné ekvivalenty bez znaménka.

Tato metoda není kompatibilní se specifikací CLS. Alternativou kompatibilní se specifikací CLS je Parse(String, NumberStyles).

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

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

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

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

Parametry

s

String

Řetězec, který představuje číslo, které se má převést. Řetězec se interpretuje pomocí stylu určeného parametrem style .

style

NumberStyles

Bitová kombinace hodnot výčtu, které určují povolený formát s. Typická hodnota, kterou je třeba zadat, je Integer.

Návraty

UInt16

16bitové celé číslo bez znaménka odpovídající číslu zadanému v s.

Výjimky

ArgumentNullException

s je null.

ArgumentException

style není NumberStyles hodnota.

-nebo-

style není kombinací AllowHexSpecifier a HexNumber hodnot.

FormatException

s není ve formátu kompatibilním s style.

OverflowException

s představuje číslo menší než UInt16.MinValue nebo větší než UInt16.MaxValue.

-nebo-

s obsahuje nenulové desetinné číslice.

Příklady

Následující příklad se pokusí analyzovat každý prvek v řetězcové matici pomocí počtu NumberStyles hodnot.

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

Poznámky

Parametr style definuje prvky stylu (například prázdné znaky, symbol kladného nebo záporného znaménka, symbol oddělovače skupin nebo symbol desetinné čárky), které jsou v parametru s povolené pro úspěšnou operaci analýzy. style musí být kombinací bitových příznaků z výčtu NumberStyles . Parametr style tuto metodu přetíží, pokud s obsahuje řetězcovou reprezentaci šestnáctkové hodnoty, když číselný systém (desítkový nebo šestnáctkový) reprezentovaný s je znám pouze za běhu, nebo pokud chcete zakázat prázdné znaky nebo symbol znaku .s

V závislosti na hodnotě styleparametru s může obsahovat následující prvky:

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

Prvky v hranatých závorkách ([ a ]) jsou volitelné. Pokud style obsahuje NumberStyles.AllowHexSpecifierparametr, s může obsahovat následující prvky:

[ws]hexdigits[ws]

Následující tabulka popisuje jednotlivé prvky.

Element	Popis
Ws	Volitelné prázdné znaky. Prázdné znaky se můžou zobrazit na začátku s , pokud style příznak obsahuje NumberStyles.AllowLeadingWhite , a může se zobrazit na konci s , pokud style příznak NumberStyles.AllowTrailingWhite obsahuje.
$	Symbol měny specifický pro jazykovou verzi. Jeho pozice v řetězci je definována vlastnostmi NumberFormatInfo.CurrencyNegativePatternNumberFormatInfo.CurrencyPositivePattern aktuální jazykové verze. Symbol měny aktuální jazykové verze se může zobrazit v s případě, že style obsahuje NumberStyles.AllowCurrencySymbol příznak.
znaménko	Volitelné znaménko. Znaménko se může zobrazit na začátku s , pokud style příznak obsahuje NumberStyles.AllowLeadingSign , a může se zobrazit na konci s , pokud style příznak NumberStyles.AllowTrailingSign obsahuje. Závorky lze použít s k označení záporné hodnoty, pokud style obsahuje NumberStyles.AllowParentheses příznak. Symbol záporného znaménka však lze použít pouze s nulou; jinak metoda vyvolá .OverflowException
Číslic Fractional_digits exponential_digits	Posloupnost číslic od 0 do 9. Pro fractional_digits je platná pouze číslice 0.
,	Symbol oddělovače skupin specifických pro jazykovou verzi. Oddělovač skupin aktuální jazykové verze se může zobrazit, s pokud style příznak NumberStyles.AllowThousands obsahuje.
.	Symbol desetinné čárky specifické pro jazykovou verzi. Symbol desetinné čárky aktuální jazykové verze se může zobrazit, s pokud style příznak obsahuje NumberStyles.AllowDecimalPoint . Pouze číslice 0 se může zobrazit jako desetinná číslice pro úspěšnou operaci analýzy; pokud fractional_digits obsahuje jakoukoli jinou FormatException číslici, vyvolá se znak.
E	Znak "e" nebo "E", který označuje, že hodnota je reprezentována exponenciálním (vědeckým) zápisem. Parametr s může představovat číslo v exponenciálním zápisustyle, pokud NumberStyles.AllowExponent obsahuje příznak.
hexdigits	Posloupnost šestnáctkových číslic od 0 do f nebo 0 až F.

Poznámka

Všechny ukončující nulové znaky (U+0000) jsou s ignorovány operací analýzy bez ohledu na hodnotu argumentu style .

Řetězec s číslicemi (který odpovídá NumberStyles.None stylu) se vždy úspěšně parsuje, pokud je v rozsahu UInt16 typu. Většina zbývajících NumberStyles členů ovládacích prvků, které mohou být přítomny, ale nemusí být přítomny ve vstupním řetězci. Následující tabulka uvádí, jak jednotlivé NumberStyles členy ovlivňují prvky, které mohou být přítomny v s.

NumberStyles hodnota	Prvky povolené s kromě číslic
None	Pouze prvek číslic .
AllowDecimalPoint	Prvky desetinné čárky (.) a desetinné čárky .
AllowExponent	Znak "e" nebo "E", který označuje exponenciální notaci spolu s exponential_digits.
AllowLeadingWhite	Prvek ws na začátku .s
AllowTrailingWhite	Prvek ws na konci .s
AllowLeadingSign	Prvek znaménka na začátku znaku s.
AllowTrailingSign	Prvek znaménka na konci znaku s.
AllowParentheses	Prvek znaménka ve formě závorek ohraničující číselnou hodnotu.
AllowThousands	Element oddělovače skupin (,).
AllowCurrencySymbol	Prvek měny ($).
Currency	Všechny prvky. s Nelze však reprezentovat šestnáctkové číslo nebo číslo v exponenciálním zápisu.
Float	Prvek ws na začátku nebo s, na začátku sznaku a desetinné čárky (.) symbol. Parametr s může také použít exponenciální zápis.
Number	Prvky ws, signoddělovač skupin (,) a desetinná čárka (.).
Any	Všechny prvky. s Nelze však reprezentovat šestnáctkové číslo.

Na rozdíl od ostatních NumberStyles hodnot, které umožňují, ale nevyžadují, přítomnost určitých prvků stylu v s, NumberStyles.AllowHexSpecifier hodnota stylu znamená, že jednotlivé číselné znaky jsou s vždy interpretovány jako šestnáctkové znaky. Platné šestnáctkové znaky jsou 0-9, A-F a a-f. Předpona, například 0x, není podporovaná a způsobí selhání operace analýzy. Jedinými dalšími příznaky, které lze kombinovat s parametrem style , jsou NumberStyles.AllowLeadingWhite a NumberStyles.AllowTrailingWhite. (Výčet NumberStyles obsahuje složený styl čísla, NumberStyles.HexNumberkterý obsahuje oba příznaky prázdných znaků.)

Poznámka

Pokud s je řetězcová reprezentace šestnáctkového čísla, nemůže jí předcházet žádná dekorace (například 0x nebo &h), která ji odlišuje jako šestnáctkové číslo. To způsobí selhání převodu.

Parametr s je analyzován pomocí informací o formátování v objektu NumberFormatInfo , který je inicializován pro aktuální systémovou jazykovou verzi. Chcete-li určit jazykovou verzi, jejíž informace formátování se používají pro operaci analýzy, zavolejte Parse(String, NumberStyles, IFormatProvider) přetížení.

Viz také

• ToString()
• TryParse
• Analýza číselných řetězců v .NET

Parse(ReadOnlySpan<Char>, IFormatProvider)

Zdroj:

UInt16.cs

Parsuje rozsah znaků do hodnoty.

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

Parametry

s

ReadOnlySpan<Char>

Rozsah znaků, které se mají analyzovat.

provider

IFormatProvider

Objekt, který poskytuje informace o sformátování specifické pro jazykovou verzi .

Návraty

UInt16

Výsledek analýzy s.

Implementuje

Parse(ReadOnlySpan<Char>, IFormatProvider)

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Zdroj:

UInt16.cs

Parsuje rozsah znaků UTF-8 do hodnoty.

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

Parametry

utf8Text

ReadOnlySpan<Byte>

Rozsah znaků UTF-8 pro analýzu.

provider

IFormatProvider

Objekt, který poskytuje informace o utf8Textformátování specifické pro jazykovou verzi .

Návraty

UInt16

Výsledek analýzy utf8Text.

Implementuje

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Parse(String)

Zdroj:

UInt16.cs

Důležité

Toto rozhraní API neodpovídá specifikaci CLS.

Alternativa odpovídající specifikaci CLS

System.Int32.Parse(String)

Převede řetězcové vyjádření čísla na 16bitové celé číslo bez znaménka.

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

public static ushort Parse(string s);

static member Parse : string -> uint16

Public Shared Function Parse (s As String) As UShort

Parametry

s

String

Řetězec, který představuje číslo, které se má převést.

Návraty

UInt16

16bitové celé číslo bez znaménka odpovídající číslu obsaženému v s.

Výjimky

ArgumentNullException

s je null.

FormatException

s není ve správném formátu.

OverflowException

s představuje číslo menší než UInt16.MinValue nebo větší než UInt16.MaxValue.

Příklady

Následující příklad volá metodu Parse(String) , která převede každý prvek v řetězcovém poli na 16bitové celé číslo bez znaménka.

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

Poznámky

Parametr s by měl být řetězcovou reprezentací čísla v následujícím formátu.

[ws][znaménko]digits[ws]

Prvky v hranatých závorkách ([ a ]) jsou volitelné. Následující tabulka popisuje jednotlivé prvky.

Element	Popis
Ws	Volitelné prázdné znaky.
znaménko	Volitelné znaménko. Platné znaky znaménka jsou určeny vlastnostmi NumberFormatInfo.NegativeSignNumberFormatInfo.PositiveSign aktuální jazykové verze. Symbol záporného znaménka však lze použít pouze s nulou; jinak metoda vyvolá .OverflowException
Číslic	Posloupnost číslic v rozsahu od 0 do 9 Všechny počáteční nuly se ignorují.

Poznámka

Řetězec určený s parametrem je interpretován pomocí NumberStyles.Integer stylu. Nesmí obsahovat žádné oddělovače skupin ani oddělovač desetinných míst a nesmí obsahovat desetinnou část.

Parametr s je analyzován pomocí informací o formátování v objektu System.Globalization.NumberFormatInfo , který je inicializován pro aktuální systémovou jazykovou verzi. Další informace najdete na webu NumberFormatInfo.CurrentInfo. K analýze řetězce pomocí formátování informací o konkrétní jazykové verzi použijte metodu Parse(String, IFormatProvider) .

Viz také

• ToString()
• TryParse
• Analýza číselných řetězců v .NET