Byte.TryParse Metod

Källa:

Byte.cs

Källa:

Byte.cs

Källa:

Byte.cs

Källa:

Byte.cs

public:
 static bool TryParse(ReadOnlySpan<System::Byte> utf8Text, IFormatProvider ^ provider, [Runtime::InteropServices::Out] System::Byte % result) = IUtf8SpanParsable<System::Byte>::TryParse;

public static bool TryParse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider, out byte result);

static member TryParse : ReadOnlySpan<byte> * IFormatProvider * byte -> bool

Public Shared Function TryParse (utf8Text As ReadOnlySpan(Of Byte), provider As IFormatProvider, ByRef result As Byte) As Boolean

Parametrar

Returer

trueom utf8Text har parsats, annars . false

Källa:

Byte.cs

Källa:

Byte.cs

Källa:

Byte.cs

Källa:

Byte.cs

Källa:

Byte.cs

public:
 static bool TryParse(ReadOnlySpan<char> s, [Runtime::InteropServices::Out] System::Byte % result);

public static bool TryParse(ReadOnlySpan<char> s, out byte result);

static member TryParse : ReadOnlySpan<char> * byte -> bool

Public Shared Function TryParse (s As ReadOnlySpan(Of Char), ByRef result As Byte) As Boolean

Parametrar

Returer

true om s har konverterats, annars false.

Källa:

Byte.cs

Källa:

Byte.cs

Källa:

Byte.cs

Källa:

Byte.cs

Källa:

Byte.cs

public:
 static bool TryParse(System::String ^ s, [Runtime::InteropServices::Out] System::Byte % result);

public static bool TryParse(string s, out byte result);

public static bool TryParse(string? s, out byte result);

static member TryParse : string * byte -> bool

Public Shared Function TryParse (s As String, ByRef result As Byte) As Boolean

Parametrar

Returer

true om s har konverterats, annars false.

Exempel

I följande exempel anropas TryParse(String, Byte) metoden med ett antal olika strängvärden.

using System;

public class ByteConversion
{
   public static void Main()
   {
      string[] byteStrings = { null, string.Empty, "1024",
                               "100.1", "100", "+100", "-100",
                               "000000000000000100", "00,100",
                               "   20   ", "FF", "0x1F" };

      foreach (var byteString in byteStrings)
      {
          CallTryParse(byteString);
      }
   }

   private static void CallTryParse(string stringToConvert)
   {
      byte byteValue;
      bool success = Byte.TryParse(stringToConvert, out byteValue);
      if (success)
      {
         Console.WriteLine("Converted '{0}' to {1}",
                        stringToConvert, byteValue);
      }
      else
      {
         Console.WriteLine("Attempted conversion of '{0}' failed.",
                           stringToConvert);
      }
   }
}
// The example displays the following output to the console:
//       Attempted conversion of '' failed.
//       Attempted conversion of '' failed.
//       Attempted conversion of '1024' failed.
//       Attempted conversion of '100.1' failed.
//       Converted '100' to 100
//       Converted '+100' to 100
//       Attempted conversion of '-100' failed.
//       Converted '000000000000000100' to 100
//       Attempted conversion of '00,100' failed.
//       Converted '   20   ' to 20
//       Attempted conversion of 'FF' failed.
//       Attempted conversion of '0x1F' failed.

open System

let callTryParse (stringToConvert: string) =
    match Byte.TryParse stringToConvert with
    | true, byteValue ->
        printfn $"Converted '{stringToConvert}' to {byteValue}"
    | _ ->
        printfn $"Attempted conversion of '{stringToConvert}' failed."

let byteStrings = 
    [ null; String.Empty; "1024"
      "100.1"; "100"; "+100"; "-100"
      "000000000000000100"; "00,100"
      "   20   "; "FF"; "0x1F" ]

for byteString in byteStrings do
    callTryParse byteString

// The example displays the following output to the console:
//       Attempted conversion of '' failed.
//       Attempted conversion of '' failed.
//       Attempted conversion of '1024' failed.
//       Attempted conversion of '100.1' failed.
//       Converted '100' to 100
//       Converted '+100' to 100
//       Attempted conversion of '-100' failed.
//       Converted '000000000000000100' to 100
//       Attempted conversion of '00,100' failed.
//       Converted '   20   ' to 20
//       Attempted conversion of 'FF' failed.
//       Attempted conversion of '0x1F' failed.

Module ByteConversion
   Public Sub Main()
      Dim byteStrings() As String = { Nothing, String.Empty, "1024", 
                                    "100.1", "100", "+100", "-100",
                                    "000000000000000100", "00,100",
                                    "   20   ", "FF", "0x1F"}

      For Each byteString As String In byteStrings
        CallTryParse(byteString)
      Next
   End Sub
   
   Private Sub CallTryParse(stringToConvert As String)  
      Dim byteValue As Byte
      Dim success As Boolean = Byte.TryParse(stringToConvert, byteValue)
      If success Then
         Console.WriteLine("Converted '{0}' to {1}", _
                        stringToConvert, byteValue)
      Else
         Console.WriteLine("Attempted conversion of '{0}' failed.", _
                           stringToConvert)
      End If                        
   End Sub
End Module
' The example displays the following output to the console:
'       Attempted conversion of '' failed.
'       Attempted conversion of '' failed.
'       Attempted conversion of '1024' failed.
'       Attempted conversion of '100.1' failed.
'       Converted '100' to 100
'       Converted '+100' to 100
'       Attempted conversion of '-100' failed.
'       Converted '000000000000000100' to 100
'       Attempted conversion of '00,100' failed.
'       Converted '   20   ' to 20
'       Attempted conversion of 'FF' failed.
'       Attempted conversion of '0x1F' failed.

Kommentarer

Konverteringen misslyckas och metoden returnerar false om parametern s inte har rätt format, om den är null eller String.Empty, eller om den representerar ett tal som är mindre än MinValue eller större än MaxValue.

Metoden Byte.TryParse(String, Byte) liknar Byte.Parse(String) metoden, förutom att TryParse(String, Byte) den inte utlöser ett undantag om konverteringen misslyckas.

Parametern s ska vara strängrepresentationen av ett tal i följande formulär:

[ws][sign]digits[ws]

Element inom hakparenteser ([ och ]) är valfria. I följande tabell beskrivs varje element.

Element	Description
Ws	Valfritt blanksteg.
signera	Ett valfritt positivt tecken enligt egenskapen för NumberFormatInfo.PositiveSign den aktuella kulturen.
Siffror	En sekvens med decimaltal som sträcker sig från 0 till 9.

Parametern s tolkas med formatet Integer . Förutom bytevärdets decimalsiffror tillåts endast inledande och avslutande blanksteg tillsammans med ett inledande tecken. (Om tecknet finns måste det vara ett positivt tecken eller så genererar metoden . OverflowException) Om du vill definiera formatelementen explicit tillsammans med den kulturspecifika formateringsinformation som kan finnas i sanvänder du Byte.Parse(String, NumberStyles, IFormatProvider) metoden .

Parametern s parsas med formateringsinformationen i ett NumberFormatInfo objekt för den aktuella kulturen. Mer information finns i NumberFormatInfo.CurrentInfo.

Den här överlagringen Byte.TryParse(String, Byte) av metoden tolkar alla siffror i parametern s som decimalsiffror. Om du vill parsa strängrepresentationen av ett hexadecimalt nummer anropar du överlagringen Byte.TryParse(String, NumberStyles, IFormatProvider, Byte) .

Se även

• Exempel: Formateringsverktyget för .NET Core WinForms (C#)
• Exempel: Formateringsverktyget för .NET Core WinForms (Visual Basic)

Källa:

Byte.cs

Källa:

Byte.cs

Källa:

Byte.cs

Källa:

Byte.cs

Källa:

Byte.cs

public:
 static bool TryParse(ReadOnlySpan<char> s, IFormatProvider ^ provider, [Runtime::InteropServices::Out] System::Byte % result) = ISpanParsable<System::Byte>::TryParse;

public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, out byte result);

static member TryParse : ReadOnlySpan<char> * IFormatProvider * byte -> bool

Public Shared Function TryParse (s As ReadOnlySpan(Of Char), provider As IFormatProvider, ByRef result As Byte) As Boolean

Parametrar

Returer

trueom s har parsats, annars . false

Källa:

Byte.cs

Källa:

Byte.cs

Källa:

Byte.cs

Källa:

Byte.cs

Källa:

Byte.cs

public:
 static bool TryParse(System::String ^ s, IFormatProvider ^ provider, [Runtime::InteropServices::Out] System::Byte % result) = IParsable<System::Byte>::TryParse;

public static bool TryParse(string? s, IFormatProvider? provider, out byte result);

static member TryParse : string * IFormatProvider * byte -> bool

Public Shared Function TryParse (s As String, provider As IFormatProvider, ByRef result As Byte) As Boolean

Parametrar

Returer

trueom s har parsats, annars . false

Källa:

Byte.cs

Källa:

Byte.cs

Källa:

Byte.cs

Källa:

Byte.cs

public:
 static bool TryParse(ReadOnlySpan<System::Byte> utf8Text, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] System::Byte % result) = System::Numerics::INumberBase<System::Byte>::TryParse;

public static bool TryParse(ReadOnlySpan<byte> utf8Text, System.Globalization.NumberStyles style, IFormatProvider? provider, out byte result);

static member TryParse : ReadOnlySpan<byte> * System.Globalization.NumberStyles * IFormatProvider * byte -> bool

Public Shared Function TryParse (utf8Text As ReadOnlySpan(Of Byte), style As NumberStyles, provider As IFormatProvider, ByRef result As Byte) As Boolean

Parametrar

Returer

trueom utf8Text har parsats, annars . false

Källa:

Byte.cs

Källa:

Byte.cs

Källa:

Byte.cs

Källa:

Byte.cs

public:
 static bool TryParse(ReadOnlySpan<System::Byte> utf8Text, [Runtime::InteropServices::Out] System::Byte % result);

public static bool TryParse(ReadOnlySpan<byte> utf8Text, out byte result);

static member TryParse : ReadOnlySpan<byte> * byte -> bool

Public Shared Function TryParse (utf8Text As ReadOnlySpan(Of Byte), ByRef result As Byte) As Boolean

Parametrar

Returer

true om utf8Text har konverterats, annars false.

Källa:

Byte.cs

Källa:

Byte.cs

Källa:

Byte.cs

Källa:

Byte.cs

Källa:

Byte.cs

public:
 static bool TryParse(ReadOnlySpan<char> s, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] System::Byte % result) = System::Numerics::INumberBase<System::Byte>::TryParse;

public:
 static bool TryParse(ReadOnlySpan<char> s, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] System::Byte % result);

public static bool TryParse(ReadOnlySpan<char> s, System.Globalization.NumberStyles style, IFormatProvider? provider, out byte result);

public static bool TryParse(ReadOnlySpan<char> s, System.Globalization.NumberStyles style, IFormatProvider provider, out byte result);

static member TryParse : ReadOnlySpan<char> * System.Globalization.NumberStyles * IFormatProvider * byte -> bool

Public Shared Function TryParse (s As ReadOnlySpan(Of Char), style As NumberStyles, provider As IFormatProvider, ByRef result As Byte) As Boolean

Parametrar

Returer

true om s har konverterats, annars false.

Källa:

Byte.cs

Källa:

Byte.cs

Källa:

Byte.cs

Källa:

Byte.cs

Källa:

Byte.cs

public:
 static bool TryParse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] System::Byte % result);

public:
 static bool TryParse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] System::Byte % result) = System::Numerics::INumberBase<System::Byte>::TryParse;

public static bool TryParse(string s, System.Globalization.NumberStyles style, IFormatProvider provider, out byte result);

public static bool TryParse(string? s, System.Globalization.NumberStyles style, IFormatProvider? provider, out byte result);

static member TryParse : string * System.Globalization.NumberStyles * IFormatProvider * byte -> bool

Public Shared Function TryParse (s As String, style As NumberStyles, provider As IFormatProvider, ByRef result As Byte) As Boolean

Parametrar

Returer

true om s har konverterats, annars false.

Undantag

Exempel

I följande exempel anropas TryParse(String, NumberStyles, IFormatProvider, Byte) metoden med ett antal olika strängvärden.

using System;
using System.Globalization;

public class ByteConversion2
{
   public static void Main()
   {
      string byteString;
      NumberStyles styles;

      byteString = "1024";
      styles = NumberStyles.Integer;
      CallTryParse(byteString, styles);

      byteString = "100.1";
      styles = NumberStyles.Integer | NumberStyles.AllowDecimalPoint;
      CallTryParse(byteString, styles);

      byteString = "100.0";
      CallTryParse(byteString, styles);

      byteString = "+100";
      styles = NumberStyles.Integer | NumberStyles.AllowLeadingSign
               | NumberStyles.AllowTrailingSign;
      CallTryParse(byteString, styles);

      byteString = "-100";
      CallTryParse(byteString, styles);

      byteString = "000000000000000100";
      CallTryParse(byteString, styles);

      byteString = "00,100";
      styles = NumberStyles.Integer | NumberStyles.AllowThousands;
      CallTryParse(byteString, styles);

      byteString = "2E+3   ";
      styles = NumberStyles.Integer | NumberStyles.AllowExponent;
      CallTryParse(byteString, styles);

      byteString = "FF";
      styles = NumberStyles.HexNumber;
      CallTryParse(byteString, styles);

      byteString = "0x1F";
      CallTryParse(byteString, styles);
   }

   private static void CallTryParse(string stringToConvert, NumberStyles styles)
   {
      Byte byteValue;
      bool result = Byte.TryParse(stringToConvert, styles,
                                  null as IFormatProvider, out byteValue);
      if (result)
         Console.WriteLine("Converted '{0}' to {1}",
                        stringToConvert, byteValue);
      else
         Console.WriteLine("Attempted conversion of '{0}' failed.",
                           stringToConvert.ToString());
   }
}
// The example displays the following output to the console:
//       Attempted conversion of '1024' failed.
//       Attempted conversion of '100.1' failed.
//       Converted '100.0' to 100
//       Converted '+100' to 100
//       Attempted conversion of '-100' failed.
//       Converted '000000000000000100' to 100
//       Converted '00,100' to 100
//       Attempted conversion of '2E+3   ' failed.
//       Converted 'FF' to 255
//       Attempted conversion of '0x1F' failed.

open System
open System.Globalization

let callTryParse (stringToConvert: string) (styles: NumberStyles) =
    match Byte.TryParse(stringToConvert, styles, null) with
    | true, byteValue ->
        printfn $"Converted '{stringToConvert}' to {byteValue}"
    | _ ->
        printfn $"Attempted conversion of '{stringToConvert}' failed."
                        
[<EntryPoint>]
let main _ =
    let byteString = "1024"
    let styles = NumberStyles.Integer
    callTryParse byteString styles

    let byteString = "100.1"
    let styles = NumberStyles.Integer ||| NumberStyles.AllowDecimalPoint
    callTryParse byteString styles

    let byteString = "100.0"
    callTryParse byteString styles

    let byteString = "+100"
    let styles = NumberStyles.Integer ||| NumberStyles.AllowLeadingSign ||| NumberStyles.AllowTrailingSign
    callTryParse byteString styles

    let byteString = "-100"
    callTryParse byteString styles

    let byteString = "000000000000000100"
    callTryParse byteString styles

    let byteString = "00,100"
    let styles = NumberStyles.Integer ||| NumberStyles.AllowThousands
    callTryParse byteString styles

    let byteString = "2E+3   "
    let styles = NumberStyles.Integer ||| NumberStyles.AllowExponent
    callTryParse byteString styles

    let byteString = "FF"
    let styles = NumberStyles.HexNumber
    callTryParse byteString styles

    let byteString = "0x1F"
    callTryParse byteString styles

    0

// The example displays the following output to the console:
//       Attempted conversion of '1024' failed.
//       Attempted conversion of '100.1' failed.
//       Converted '100.0' to 100
//       Converted '+100' to 100
//       Attempted conversion of '-100' failed.
//       Converted '000000000000000100' to 100
//       Converted '00,100' to 100
//       Attempted conversion of '2E+3   ' failed.
//       Converted 'FF' to 255
//       Attempted conversion of '0x1F' failed.

Imports System.Globalization

Module ByteConversion2
   Public Sub Main()
      Dim byteString As String 
      Dim styles As NumberStyles
      
      byteString = "1024"
      styles = NumberStyles.Integer
      CallTryParse(byteString, styles)
      
      byteString = "100.1"
      styles = NumberStyles.Integer Or NumberStyles.AllowDecimalPoint
      CallTryParse(byteString, styles)
      
      byteString = "100.0"
      CallTryParse(byteString, styles)
      
      byteString = "+100"
      styles = NumberStyles.Integer Or NumberStyles.AllowLeadingSign _
               Or NumberStyles.AllowTrailingSign
      CallTryParse(byteString, styles)
      
      byteString = "-100"
      CallTryParse(byteString, styles)
      
      byteString = "000000000000000100"
      CallTryParse(byteString, styles)
      
      byteString = "00,100"      
      styles = NumberStyles.Integer Or NumberStyles.AllowThousands
      CallTryParse(byteString, styles)
      
      byteString = "2E+3   "
      styles = NumberStyles.Integer Or NumberStyles.AllowExponent
      CallTryParse(byteString, styles)
      
      byteString = "FF"
      styles = NumberStyles.HexNumber
      CallTryParse(byteString, styles)
      
      byteString = "0x1F"
      CallTryParse(byteString, styles)
   End Sub
   
   Private Sub CallTryParse(stringToConvert As String, styles As NumberStyles)  
      Dim byteValue As Byte
      Dim result As Boolean = Byte.TryParse(stringToConvert, styles, Nothing, _
                                            byteValue)
      If result Then
         Console.WriteLine("Converted '{0}' to {1}", _
                        stringToConvert, byteValue)
      Else
         If stringToConvert Is Nothing Then stringToConvert = ""
         Console.WriteLine("Attempted conversion of '{0}' failed.", _
                           stringToConvert.ToString())
      End If                        
   End Sub
End Module
' The example displays the following output to the console:
'       Attempted conversion of '1024' failed.
'       Attempted conversion of '100.1' failed.
'       Converted '100.0' to 100
'       Converted '+100' to 100
'       Attempted conversion of '-100' failed.
'       Converted '000000000000000100' to 100
'       Converted '00,100' to 100
'       Attempted conversion of '2E+3   ' failed.
'       Converted 'FF' to 255
'       Attempted conversion of '0x1F' failed.

Kommentarer

Metoden TryParse liknar Parse metoden, förutom att TryParse metoden inte utlöser ett undantag om konverteringen misslyckas.

Parametern s parsas med hjälp av formateringsinformationen i ett NumberFormatInfo objekt som tillhandahålls av parametern provider .

Formatparametern definierar formatelementen (till exempel tomt utrymme eller det positiva tecknet) som tillåts i parametern s för att parsningsåtgärden ska lyckas. Det måste vara en kombination av bitflaggor från NumberStyles uppräkningen. Beroende på värdet för stylekan parametern s innehålla följande element:

[ws][$][sign]digits[.fractional_digits][e[sign]digits][ws]

Eller om parametern style innehåller AllowHexSpecifier:

[ws]hexdigits[ws]

Element inom hakparenteser ( [ och ] ) är valfria. I följande tabell beskrivs varje element.

Element	Description
Ws	Valfritt blanksteg. Tomt utrymme kan visas i början av s om style innehåller NumberStyles.AllowLeadingWhite flaggan, eller i slutet av s om formatmallen NumberStyles.AllowTrailingWhite innehåller flaggan.
$	En kulturspecifik valutasymbol. Dess position i strängen definieras av NumberFormatInfo.CurrencyPositivePattern egenskapen för objektet NumberFormatInfo som returneras av GetFormat parametermetoden provider . Valutasymbolen kan visas i s om style den NumberStyles.AllowCurrencySymbol innehåller flaggan.
signera	Ett valfritt positivt tecken. (Parsningsåtgärden misslyckas om ett negativt tecken finns i s.) Tecknet kan visas i början av s om style innehåller NumberStyles.AllowLeadingSign flaggan, eller i slutet av s om style innehåller NumberStyles.AllowTrailingSign flaggan.
Siffror	En sekvens med siffror från 0 till 9.
.	Ett kulturspecifikt decimaltecken. Decimaltecknet för kulturen som anges av provider kan visas i s om style den NumberStyles.AllowDecimalPoint innehåller flaggan.
fractional_digits	En eller flera förekomster av siffran 0. Bråksiffror kan bara visas i s om style den NumberStyles.AllowDecimalPoint innehåller flaggan.
e	Tecknet e eller E, vilket anger att värdet representeras i exponentiell notation. Parametern s kan representera ett tal i exponentiell notation om style den NumberStyles.AllowExponent innehåller flaggan.
hexdigits	En sekvens med hexadecimala siffror från 0 till f eller 0 till och med F.

En sträng med endast decimalsiffror (vilket motsvarar NumberStyles.None formatet) parsar alltid korrekt. De flesta av de återstående NumberStyles medlemmarna styr element som kan vara men som inte måste finnas i den här indatasträngen. Följande tabell visar hur enskilda NumberStyles medlemmar påverkar de element som kan finnas i s.

Icke-sammansatta NumberStyles-värden	Element som tillåts i s utöver siffror
NumberStyles.None	Endast decimalsiffror.
NumberStyles.AllowDecimalPoint	Elementen . och fractional_digits . Men fractional_digits får bara bestå av en eller flera 0 siffror eller så returnerar falsemetoden .
NumberStyles.AllowExponent	Parametern s kan också använda exponentiell notation. Om s representerar ett tal i exponentiell notation måste det representera ett heltal inom datatypens Byte intervall utan en bråkkomponent som inte är noll.
NumberStyles.AllowLeadingWhite	WS-elementet i början av s.
NumberStyles.AllowTrailingWhite	WS-elementet i slutet av s.
NumberStyles.AllowLeadingSign	Ett positivt tecken kan visas före siffror.
NumberStyles.AllowTrailingSign	Ett positivt tecken kan visas efter siffror.
NumberStyles.AllowParentheses	Även om den här flaggan stöds returnerar false metoden om parenteser finns i s.
NumberStyles.AllowThousands	Även om gruppavgränsarsymbolen kan visas i skan den föregås av endast en eller flera 0 siffror.
NumberStyles.AllowCurrencySymbol	Elementet $ .

NumberStyles.AllowHexSpecifier Om flaggan används s måste vara ett hexadecimalt värde utan prefix. Till exempel parsar "F3" korrekt, men "0xF3" gör det inte. De enda andra flaggorna som kan finnas i style är NumberStyles.AllowLeadingWhite och NumberStyles.AllowTrailingWhite. (Uppräkningen NumberStyles har ett sammansatt talformat, NumberStyles.HexNumber, som innehåller båda blankstegsflaggorna.)

Parametern provider är en IFormatProvider implementering, till exempel ett CultureInfo objekt eller ett NumberFormatInfo objekt, vars GetFormat metod returnerar ett NumberFormatInfo objekt. Objektet NumberFormatInfo innehåller kulturspecifik information om formatet sför .

Se även

• ToString()
• MaxValue
• MinValue
• NumberStyles
• NumberFormatInfo
• IFormatProvider
• Parsing Numeriska strängar i .NET