Byte.TryParse Methode

Definitie

Naamruimte:: System

Assembly's:: netstandard.dll, System.Runtime.dll

Assembly:: System.Runtime.dll

Assembly:: netstandard.dll

Assembly's:: mscorlib.dll, System.Runtime.dll

Assembly:: mscorlib.dll

Belangrijk

Bepaalde informatie heeft betrekking op een voorlopige productversie die aanzienlijk kan worden gewijzigd voordat deze wordt uitgebracht. Microsoft biedt geen enkele expliciete of impliciete garanties met betrekking tot de informatie die hier wordt verstrekt.

Hiermee wordt geprobeerd de tekenreeksweergave van een getal te converteren naar Byte het equivalent ervan en wordt een waarde geretourneerd die aangeeft of de conversie is geslaagd.

Overloads

Name	Description
TryParse(ReadOnlySpan<Byte>, IFormatProvider, Byte)	Probeert een reeks UTF-8 tekens te parseren in een waarde.
TryParse(ReadOnlySpan<Char>, Byte)	Probeert de spanweergave van een getal te converteren naar het Byte equivalent ervan en retourneert een waarde die aangeeft of de conversie is geslaagd.
TryParse(String, Byte)	Hiermee wordt geprobeerd de tekenreeksweergave van een getal te converteren naar Byte het equivalent ervan en wordt een waarde geretourneerd die aangeeft of de conversie is geslaagd.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Byte)	Probeert een reeks tekens te parseren in een waarde.
TryParse(String, IFormatProvider, Byte)	Probeert een tekenreeks te parseren in een waarde.
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Byte)	Probeert een reeks UTF-8 tekens te parseren in een waarde.
TryParse(ReadOnlySpan<Byte>, Byte)	Hiermee wordt geprobeerd een UTF-8-tekenbereik met de tekenreeksweergave van een getal te converteren naar het 8-bits equivalent van een niet-ondertekend geheel getal.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Byte)	Converteert de spanweergave van een getal in een opgegeven stijl en cultuurspecifieke notatie naar het Byte equivalent ervan. Een retourwaarde geeft aan of de conversie is geslaagd of mislukt.
TryParse(String, NumberStyles, IFormatProvider, Byte)	Converteert de tekenreeksweergave van een getal in een opgegeven stijl en cultuurspecifieke notatie naar het Byte equivalent ervan. Een retourwaarde geeft aan of de conversie is geslaagd of mislukt.

TryParse(ReadOnlySpan<Byte>, IFormatProvider, Byte)

Bron:: Byte.cs

Bron:: Byte.cs

Bron:: Byte.cs

Bron:: Byte.cs

Probeert een reeks UTF-8 tekens te parseren in een waarde.

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

Parameters

utf8Text: ReadOnlySpan<Byte>

Het bereik van UTF-8 tekens om te parseren.

provider: IFormatProvider

Een object dat cultuurspecifieke opmaakinformatie biedt over utf8Text.

result: Byte

Bij retour bevat het resultaat van het parseren utf8Text of een niet-gedefinieerde waarde bij een fout.

Retouren

Boolean

trueindien utf8Text geparseerd; anders. false

Van toepassing op

TryParse(ReadOnlySpan<Char>, Byte)

Bron:: Byte.cs

Bron:: Byte.cs

Bron:: Byte.cs

Bron:: Byte.cs

Bron:: Byte.cs

Probeert de spanweergave van een getal te converteren naar het Byte equivalent ervan en retourneert een waarde die aangeeft of de conversie is geslaagd.

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

Parameters

s: ReadOnlySpan<Char>

Een bereik met de tekens die het getal vertegenwoordigen dat moet worden geconverteerd.

result: Byte

Wanneer deze methode retourneert, bevat deze de Byte waarde die gelijk is aan het getal in s als de conversie is geslaagd of nul als de conversie is mislukt. Deze parameter wordt niet-geïnitialiseerd doorgegeven; elke waarde die oorspronkelijk is opgegeven result , wordt overschreven.

Retouren

Boolean

trueals s deze is geconverteerd; anders. false

Van toepassing op

TryParse(String, Byte)

Bron:: Byte.cs

Bron:: Byte.cs

Bron:: Byte.cs

Bron:: Byte.cs

Bron:: Byte.cs

Hiermee wordt geprobeerd de tekenreeksweergave van een getal te converteren naar Byte het equivalent ervan en wordt een waarde geretourneerd die aangeeft of de conversie is geslaagd.

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

Parameters

s: String

Een tekenreeks die een getal bevat dat moet worden geconverteerd.

result: Byte

Retouren

Boolean

trueals s deze is geconverteerd; anders. false

Voorbeelden

In het volgende voorbeeld wordt de TryParse(String, Byte) methode aangeroepen met een aantal verschillende tekenreekswaarden.

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.

Opmerkingen

De conversie mislukt en de methode retourneert als de false parameter niet de juiste indeling heeft, of als deze snulleen getal kleiner dan String.Empty of groter is dan MinValue.MaxValue

De Byte.TryParse(String, Byte) methode is vergelijkbaar met de Byte.Parse(String) methode, behalve dat er TryParse(String, Byte) geen uitzondering wordt gegenereerd als de conversie mislukt.

De s parameter moet de tekenreeksweergave van een getal zijn in de volgende vorm:

[ws][sign]digits[ws]

Elementen in vierkante haken ([ en ]) zijn optioneel. In de volgende tabel wordt elk element beschreven.

Element	Beschrijving
Ws	Optionele witruimte.
ondertekenen	Een optioneel positief teken, zoals opgegeven door de NumberFormatInfo.PositiveSign eigenschap van de huidige cultuur.
Cijfers	Een reeks decimalen tussen 0 en 9.

De s parameter wordt geïnterpreteerd met behulp van de Integer stijl. Naast de decimale cijfers van de bytewaarde zijn alleen voorloop- en volgspaties met een voorloopteken toegestaan. (Als het teken aanwezig is, moet het een positief teken zijn of de methode een OverflowException.) Als u de stijlelementen expliciet wilt definiëren in combinatie met de cultuurspecifieke opmaakinformatie die aanwezig kan zijn s, gebruikt u de Byte.Parse(String, NumberStyles, IFormatProvider) methode.

De s parameter wordt geparseerd met behulp van de opmaakgegevens in een NumberFormatInfo object voor de huidige cultuur. Zie NumberFormatInfo.CurrentInfo voor meer informatie.

Deze overbelasting van de Byte.TryParse(String, Byte) methode interpreteert alle cijfers in de s parameter als decimale cijfers. Als u de tekenreeksweergave van een hexadecimaal getal wilt parseren, roept u de Byte.TryParse(String, NumberStyles, IFormatProvider, Byte) overbelasting aan.

Zie ook

Van toepassing op

TryParse(ReadOnlySpan<Char>, IFormatProvider, Byte)

Bron:: Byte.cs

Bron:: Byte.cs

Bron:: Byte.cs

Bron:: Byte.cs

Bron:: Byte.cs

Probeert een reeks tekens te parseren in een waarde.

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

Parameters

s: ReadOnlySpan<Char>

De reeks tekens die moeten worden geparseerd.

provider: IFormatProvider

Een object dat cultuurspecifieke opmaakinformatie biedt over s.

result: Byte

Wanneer deze methode wordt geretourneerd, bevat het resultaat van het parseren sof een niet-gedefinieerde waarde bij een fout.

Retouren

Boolean

trueindien s geparseerd; anders. false

Van toepassing op

TryParse(String, IFormatProvider, Byte)

Bron:: Byte.cs

Bron:: Byte.cs

Bron:: Byte.cs

Bron:: Byte.cs

Bron:: Byte.cs

Probeert een tekenreeks te parseren in een waarde.

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

Parameters

s: String

De tekenreeks die moet worden geparseerd.

provider: IFormatProvider

Een object dat cultuurspecifieke opmaakinformatie biedt over s.

result: Byte

Wanneer deze methode wordt geretourneerd, bevat dit het resultaat van het parseren s of van een niet-gedefinieerde waarde bij een fout.

Retouren

Boolean

trueindien s geparseerd; anders. false

Van toepassing op

TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Byte)

Bron:: Byte.cs

Bron:: Byte.cs

Bron:: Byte.cs

Bron:: Byte.cs

Probeert een reeks UTF-8 tekens te parseren in een waarde.

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

Parameters

utf8Text: ReadOnlySpan<Byte>

Het bereik van UTF-8 tekens om te parseren.

style: NumberStyles

Een bitsgewijze combinatie van getalstijlen die aanwezig kunnen zijn in utf8Text.

provider: IFormatProvider

Een object dat cultuurspecifieke opmaakinformatie biedt over utf8Text.

result: Byte

Bij retour bevat het resultaat van het parseren utf8Text of een niet-gedefinieerde waarde bij een fout.

Retouren

Boolean

trueindien utf8Text geparseerd; anders. false

Van toepassing op

TryParse(ReadOnlySpan<Byte>, Byte)

Bron:: Byte.cs

Bron:: Byte.cs

Bron:: Byte.cs

Bron:: Byte.cs

Hiermee wordt geprobeerd een UTF-8-tekenbereik met de tekenreeksweergave van een getal te converteren naar het 8-bits equivalent van een niet-ondertekend geheel getal.

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

Parameters

utf8Text: ReadOnlySpan<Byte>

Een bereik met de UTF-8 tekens die het getal vertegenwoordigen dat moet worden geconverteerd.

result: Byte

Wanneer deze methode wordt geretourneerd, bevat deze de 8-bits waarde voor een geheel getal dat gelijk is aan het getal dat utf8Text is opgenomen als de conversie is geslaagd of nul als de conversie is mislukt. Deze parameter wordt niet-geïnitialiseerd doorgegeven; elke waarde die oorspronkelijk is opgegeven in het resultaat, wordt overschreven.

Retouren

Boolean

trueals utf8Text deze is geconverteerd; anders. false

Van toepassing op

TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Byte)

Bron:: Byte.cs

Bron:: Byte.cs

Bron:: Byte.cs

Bron:: Byte.cs

Bron:: Byte.cs

Converteert de spanweergave van een getal in een opgegeven stijl en cultuurspecifieke notatie naar het Byte equivalent ervan. Een retourwaarde geeft aan of de conversie is geslaagd of mislukt.

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

Parameters

s: ReadOnlySpan<Char>

Een bereik met de tekens die het getal vertegenwoordigen dat moet worden geconverteerd. De periode wordt geïnterpreteerd met behulp van de Integer stijl.

style: NumberStyles

Een bitsgewijze combinatie van opsommingswaarden die de stijlelementen aangeeft die aanwezig kunnen zijn in s. Een typische waarde die moet worden opgegeven, is Integer.

provider: IFormatProvider

Een object dat cultuurspecifieke opmaakinformatie over slevert. Als provider dat het is null, wordt de huidige threadcultuur gebruikt.

result: Byte

Wanneer deze methode wordt geretourneerd, bevat deze de 8-bits waarde voor een geheel getal dat gelijk is aan het getal dat s is opgenomen als de conversie is geslaagd of nul als de conversie is mislukt. De conversie mislukt als de s parameter de juiste indeling heeft null of Emptyeen getal kleiner is dan Byte.MinValue of groter is dan Byte.MaxValue. Deze parameter wordt niet-geïnitialiseerd doorgegeven; elke waarde die oorspronkelijk is opgegeven result , wordt overschreven.

Retouren

Boolean

trueals s deze is geconverteerd; anders. false

Van toepassing op

TryParse(String, NumberStyles, IFormatProvider, Byte)

Bron:: Byte.cs

Bron:: Byte.cs

Bron:: Byte.cs

Bron:: Byte.cs

Bron:: Byte.cs

Converteert de tekenreeksweergave van een getal in een opgegeven stijl en cultuurspecifieke notatie naar het Byte equivalent ervan. Een retourwaarde geeft aan of de conversie is geslaagd of mislukt.

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

Parameters

s: String

Een tekenreeks die een getal bevat dat moet worden geconverteerd. De tekenreeks wordt geïnterpreteerd met behulp van de stijl die is opgegeven door style.

style: NumberStyles

Een bitsgewijze combinatie van opsommingswaarden die de stijlelementen aangeeft die aanwezig kunnen zijn in s. Een typische waarde die moet worden opgegeven, is Integer.

provider: IFormatProvider

Een object dat cultuurspecifieke opmaakinformatie over slevert. Als provider dat het is null, wordt de huidige threadcultuur gebruikt.

result: Byte

Retouren

Boolean

trueals s deze is geconverteerd; anders. false

Uitzonderingen

ArgumentException

style is geen NumberStyles waarde.

– of –

style is geen combinatie van AllowHexSpecifier en HexNumber waarden.

Voorbeelden

In het volgende voorbeeld wordt de TryParse(String, NumberStyles, IFormatProvider, Byte) methode aangeroepen met een aantal verschillende tekenreekswaarden.

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.

Opmerkingen

De TryParse methode lijkt op de Parse methode, behalve dat de TryParse methode geen uitzondering genereert als de conversie mislukt.

De s parameter wordt geparseerd met behulp van de opmaakgegevens in een NumberFormatInfo object dat door de provider parameter wordt geleverd.

De stijlparameter definieert de stijlelementen (zoals witruimte of het positieve teken) die zijn toegestaan in de s parameter om de parseringsbewerking te laten slagen. Dit moet een combinatie zijn van bitvlagmen uit de NumberStyles opsomming. Afhankelijk van de waarde van style, kan de s parameter de volgende elementen bevatten:

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

Of, als de style parameter het volgende bevat AllowHexSpecifier:

[ws]hexdigits[ws]

Elementen in vierkante haken ([ en ] ) zijn optioneel. In de volgende tabel wordt elk element beschreven.

Element	Beschrijving
Ws	Optionele witruimte. Witruimte kan worden weergegeven aan het begin van `s` de `style`NumberStyles.AllowLeadingWhite vlag, of aan het einde van de s als de stijl de NumberStyles.AllowTrailingWhite vlag bevat.
$	Een cultuurspecifiek valutasymbool. De positie in de tekenreeks wordt gedefinieerd door de NumberFormatInfo.CurrencyPositivePattern eigenschap van het NumberFormatInfo object dat wordt geretourneerd door de GetFormat methode van de `provider` parameter. Het valutasymbool kan worden weergegeven `s` als `style` deze de NumberStyles.AllowCurrencySymbol vlag bevat.
ondertekenen	Een optioneel positief teken. (De parseringsbewerking mislukt als een negatief teken aanwezig is in `s`.) Het teken kan aan het begin van `s` de `style`NumberStyles.AllowLeadingSign vlag worden weergegeven, of aan het einde van `s` de `style`NumberStyles.AllowTrailingSign vlag.
Cijfers	Een reeks cijfers van 0 tot en met 9.
.	Een cultuurspecifiek decimaalteken. Het decimaalteken van de cultuur die is opgegeven door `provider` , kan worden weergegeven `s` als `style` de NumberStyles.AllowDecimalPoint vlag wordt opgenomen.
fractional_digits	Een of meer exemplaren van het cijfer 0. Fractionele cijfers kunnen alleen worden weergegeven als `sstyle` de NumberStyles.AllowDecimalPoint vlag wordt opgenomen.
e	Het e- of E-teken, dat aangeeft dat de waarde wordt weergegeven in exponentiële notatie. De `s` parameter kan een getal in exponentiële notatie vertegenwoordigen als `style` deze de NumberStyles.AllowExponent vlag bevat.
hexdigits	Een reeks hexadecimale cijfers van 0 tot en met f of 0 tot en met F.

Note

Alle nultekens (U+0000) s worden genegeerd door de parseringsbewerking, ongeacht de waarde van het style argument.

Een tekenreeks met alleen decimale cijfers (die overeenkomt met de NumberStyles.None stijl) wordt altijd geparseerd. De meeste resterende NumberStyles leden bepalen elementen die mogelijk wel aanwezig zijn in deze invoertekenreeks, maar die niet aanwezig zijn. De volgende tabel geeft aan hoe afzonderlijke NumberStyles leden van invloed zijn op de elementen die aanwezig kunnen zijn in s.

Niet-samengestelde getalstijlwaarden	Elementen die naast cijfers zijn toegestaan
NumberStyles.None	Alleen decimale cijfers.
NumberStyles.AllowDecimalPoint	De elementen . en fractional_digits . Fractional_digits mag echter slechts uit één of meer cijfers bestaan of de methode retourneert`false`.
NumberStyles.AllowExponent	De `s` parameter kan ook exponentiële notatie gebruiken. Als `s` een getal in exponentiële notatie vertegenwoordigt, moet het een geheel getal in het gegevenstype Byte vertegenwoordigen zonder een niet-nul, fractioneel onderdeel.
NumberStyles.AllowLeadingWhite	Het ws-element aan het begin van `s`.
NumberStyles.AllowTrailingWhite	Het ws-element aan het einde van `s`.
NumberStyles.AllowLeadingSign	Een positief teken kan vóór cijfers worden weergegeven.
NumberStyles.AllowTrailingSign	Een positief teken kan na cijfers worden weergegeven.
NumberStyles.AllowParentheses	Hoewel deze vlag wordt ondersteund, retourneert `false` de methode of er haakjes aanwezig zijn in `s`.
NumberStyles.AllowThousands	Hoewel het groepsscheidingsteken kan worden weergegeven `s`, kan het worden voorafgegaan door slechts een of meer 0 cijfers.
NumberStyles.AllowCurrencySymbol	Het $ element.

Als de NumberStyles.AllowHexSpecifier vlag wordt gebruikt, s moet een hexadecimale waarde zonder voorvoegsel zijn. 'F3' parseert bijvoorbeeld wel, maar '0xF3' niet. De enige andere vlaggen die aanwezig kunnen zijn, style zijn NumberStyles.AllowLeadingWhite en NumberStyles.AllowTrailingWhite. (De NumberStyles opsomming heeft een samengestelde getalstijl, NumberStyles.HexNumberdie beide witruimtevlagmen bevat.)

De provider parameter is een IFormatProvider implementatie, zoals een CultureInfo object of een NumberFormatInfo object, waarvan GetFormat de methode een NumberFormatInfo object retourneert. Het NumberFormatInfo object biedt cultuurspecifieke informatie over de indeling van s.

Zie ook

Van toepassing op

Feedback

Is deze pagina nuttig?