Byte.Parse Method

Reference

Definition

Namespace:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Important

Some information relates to prerelease product that may be substantially modified before it’s released. Microsoft makes no warranties, express or implied, with respect to the information provided here.

Converts the string representation of a number to its Byte equivalent.

Overloads

Parse(String, NumberStyles, IFormatProvider)	Converts the string representation of a number in a specified style and culture-specific format to its Byte equivalent.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Converts the span representation of a number in a specified style and culture-specific format to its Byte equivalent.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	Parses a span of UTF-8 characters into a value.
Parse(String, IFormatProvider)	Converts the string representation of a number in a specified culture-specific format to its Byte equivalent.
Parse(String, NumberStyles)	Converts the string representation of a number in a specified style to its Byte equivalent.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Parses a span of characters into a value.
Parse(ReadOnlySpan<Byte>, IFormatProvider)	Parses a span of UTF-8 characters into a value.
Parse(String)	Converts the string representation of a number to its Byte equivalent.

Parse(String, NumberStyles, IFormatProvider)

Source:: Byte.cs

Source:: Byte.cs

Source:: Byte.cs

Converts the string representation of a number in a specified style and culture-specific format to its Byte equivalent.

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

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

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

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

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

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

Parameters

s: String

A string that contains a number to convert. The string is interpreted using the style specified by style.

style: NumberStyles

A bitwise combination of enumeration values that indicates the style elements that can be present in s. A typical value to specify is Integer.

provider: IFormatProvider

An object that supplies culture-specific information about the format of s. If provider is null, the thread current culture is used.

Returns

Byte

A byte value that is equivalent to the number contained in s.

Implements

Parse(String, NumberStyles, IFormatProvider)

Exceptions

ArgumentNullException

s is null.

FormatException

s is not of the correct format.

OverflowException

s represents a number less than Byte.MinValue or greater than Byte.MaxValue.

-or-

s includes non-zero, fractional digits.

ArgumentException

style is not a NumberStyles value.

-or-

style is not a combination of AllowHexSpecifier and HexNumber values.

Examples

The following code example parses string representations of Byte values with this overload of the Byte.Parse(String, NumberStyles, IFormatProvider) method.

NumberStyles style;
CultureInfo^ culture;
String^ value;
Byte number;

// Parse number with decimals.
// NumberStyles.Float includes NumberStyles.AllowDecimalPoint.
style = NumberStyles::Float;     
culture = CultureInfo::CreateSpecificCulture("fr-FR");
value = "12,000";

number = Byte::Parse(value, style, culture);
Console::WriteLine("Converted '{0}' to {1}.", value, number);

culture = CultureInfo::CreateSpecificCulture("en-GB");
try
{
   number = Byte::Parse(value, style, culture);
   Console::WriteLine("Converted '{0}' to {1}.", value, number);
}
catch (FormatException^) {
   Console::WriteLine("Unable to parse '{0}'.", value); }   

value = "12.000";
number = Byte::Parse(value, style, culture);
Console::WriteLine("Converted '{0}' to {1}.", value, number);
// The example displays the following output to the console:
//       Converted '12,000' to 12.
//       Unable to parse '12,000'.
//       Converted '12.000' to 12.

NumberStyles style;
CultureInfo culture;
string value;
byte number;

// Parse number with decimals.
// NumberStyles.Float includes NumberStyles.AllowDecimalPoint.
style = NumberStyles.Float;
culture = CultureInfo.CreateSpecificCulture("fr-FR");
value = "12,000";

number = Byte.Parse(value, style, culture);
Console.WriteLine("Converted '{0}' to {1}.", value, number);

culture = CultureInfo.CreateSpecificCulture("en-GB");
try
{
   number = Byte.Parse(value, style, culture);
   Console.WriteLine("Converted '{0}' to {1}.", value, number);
}
catch (FormatException) {
   Console.WriteLine("Unable to parse '{0}'.", value); }

value = "12.000";
number = Byte.Parse(value, style, culture);
Console.WriteLine("Converted '{0}' to {1}.", value, number);
// The example displays the following output to the console:
//       Converted '12,000' to 12.
//       Unable to parse '12,000'.
//       Converted '12.000' to 12.

// Parse number with decimals.
// NumberStyles.Float includes NumberStyles.AllowDecimalPoint.
let style = NumberStyles.Float
let culture = CultureInfo.CreateSpecificCulture "fr-FR"
let value = "12,000"

let number = Byte.Parse(value, style, culture)
printfn $"Converted '{value}' to {number}."

let culture = CultureInfo.CreateSpecificCulture "en-GB"
try
    let number = Byte.Parse(value, style, culture)
    printfn $"Converted '{value}' to {number}."
with :? FormatException ->
    printfn $"Unable to parse '{value}'."

let value = "12.000"
let number = Byte.Parse(value, style, culture)
printfn $"Converted '{value}' to {number}."

// The example displays the following output to the console:
//       Converted '12,000' to 12.
//       Unable to parse '12,000'.
//       Converted '12.000' to 12.

Dim style As NumberStyles
Dim culture As CultureInfo
Dim value As String
Dim number As Byte

' Parse number with decimals.
' NumberStyles.Float includes NumberStyles.AllowDecimalPoint.
style = NumberStyles.Float       
culture = CultureInfo.CreateSpecificCulture("fr-FR")
value = "12,000"

number = Byte.Parse(value, style, culture)
Console.WriteLine("Converted '{0}' to {1}.", value, number)

culture = CultureInfo.CreateSpecificCulture("en-GB")
Try
   number = Byte.Parse(value, style, culture)
   Console.WriteLine("Converted '{0}' to {1}.", value, number)
Catch e As FormatException
   Console.WriteLine("Unable to parse '{0}'.", value)   
End Try      

value = "12.000"
number = Byte.Parse(value, style, culture)
Console.WriteLine("Converted '{0}' to {1}.", value, number)
' The example displays the following output to the console:
'       Converted '12,000' to 12.
'       Unable to parse '12,000'.
'       Converted '12.000' to 12.

Remarks

The style parameter defines the style elements (such as white space or the positive sign) that are allowed in the s parameter for the parse operation to succeed. It must be a combination of bit flags from the NumberStyles enumeration. Depending on the value of style, the s parameter may include the following elements:

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

Or, if the style parameter includes AllowHexSpecifier:

[ws]hexdigits[ws]

Elements in square brackets ([ and ]) are optional. The following table describes each element.

Element	Description
ws	Optional white space. White space can appear at the beginning of `s` if `style` includes the NumberStyles.AllowLeadingWhite flag, or at the end of `s` if `style` includes the NumberStyles.AllowTrailingWhite flag.
$	A culture-specific currency symbol. Its position in the string is defined by the NumberFormatInfo.CurrencyPositivePattern property of the NumberFormatInfo object returned by the GetFormat method of the `provider` parameter. The currency symbol can appear in `s` if `style` includes the NumberStyles.AllowCurrencySymbol flag.
sign	An optional positive sign. (The method throws an OverflowException if a negative sign is present in `s`.) The sign can appear at the beginning of `s` if `style` includes the NumberStyles.AllowLeadingSign flag, or at the end of `s` if `style` includes the NumberStyles.AllowTrailingSign flag.
digits	A sequence of digits from 0 through 9.
.	A culture-specific decimal point symbol. The decimal point symbol of the culture specified by `provider` can appear in `s` if `style` includes the NumberStyles.AllowDecimalPoint flag.
fractional_digits	One or more occurrences of the digit 0. Fractional digits can appear in `s` only if `style` includes the NumberStyles.AllowDecimalPoint flag.
e	The e or E character, which indicates that the value is represented in exponential notation. The s parameter can represent a number in exponential notation if `style` includes the NumberStyles.AllowExponent flag.
hexdigits	A sequence of hexadecimal digits from 0 through f, or 0 through F.

Note

Any terminating NUL (U+0000) characters in s are ignored by the parsing operation, regardless of the value of the style argument.

A string with decimal digits only (which corresponds to the NumberStyles.None style) always parses successfully. Most of the remaining NumberStyles members control elements that may be but are not required to be present in this input string. The following table indicates how individual NumberStyles members affect the elements that may be present in s.

Non-composite NumberStyles values	Elements permitted in s in addition to digits
NumberStyles.None	Decimal digits only.
NumberStyles.AllowDecimalPoint	The . and fractional_digits elements. However, fractional_digits must consist of only one or more 0 digits or an OverflowException is thrown.
NumberStyles.AllowExponent	The `s` parameter can also use exponential notation.
NumberStyles.AllowLeadingWhite	The ws element at the beginning of `s`.
NumberStyles.AllowTrailingWhite	The ws element at the end of `s`.
NumberStyles.AllowLeadingSign	A positive sign can appear before digits.
NumberStyles.AllowTrailingSign	A positive sign can appear after digits.
NumberStyles.AllowParentheses	Although this flag is supported, the use of parentheses in `s` results in an OverflowException.
NumberStyles.AllowThousands	Although the group separator symbol can appear in `s`, it can be preceded by only one or more 0 digits.
NumberStyles.AllowCurrencySymbol	The $ element.

If the NumberStyles.AllowHexSpecifier flag is used, s must be a hexadecimal value without a prefix. For example, "F3" parses successfully, but "0xF3" does not. The only other flags that can be present in style are NumberStyles.AllowLeadingWhite and NumberStyles.AllowTrailingWhite. (The NumberStyles enumeration has a composite number style, NumberStyles.HexNumber, that includes both white space flags.)

The provider parameter is an IFormatProvider implementation, such as a NumberFormatInfo or CultureInfo object. The provider parameter supplies culture-specific information used in parsing. If provider is null, the thread current culture is used.

Applies to

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Source:: Byte.cs

Source:: Byte.cs

Source:: Byte.cs

Converts the span representation of a number in a specified style and culture-specific format to its Byte equivalent.

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

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

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

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

Parameters

s: ReadOnlySpan<Char>

A span containing the characters representing the value to convert.

style: NumberStyles

A bitwise combination of enumeration values that indicates the style elements that can be present in s. A typical value to specify is Integer.

provider: IFormatProvider

An object that supplies culture-specific information about the format of s. If provider is null, the thread current culture is used.

Returns

Byte

A byte value that is equivalent to the number contained in s.

Implements

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Applies to

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Source:: Byte.cs

Source:: Byte.cs

Parses a span of UTF-8 characters into a value.

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

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

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

Parameters

utf8Text: ReadOnlySpan<Byte>

The span of UTF-8 characters to parse.

style: NumberStyles

A bitwise combination of number styles that can be present in utf8Text.

provider: IFormatProvider

An object that provides culture-specific formatting information about utf8Text.

Returns

Byte

The result of parsing utf8Text.

Implements

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Applies to

Parse(String, IFormatProvider)

Source:: Byte.cs

Source:: Byte.cs

Source:: Byte.cs

Converts the string representation of a number in a specified culture-specific format to its Byte equivalent.

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

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

public static byte Parse (string s, IFormatProvider provider);

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

static member Parse : string * IFormatProvider -> byte

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

Parameters

s: String

A string that contains a number to convert. The string is interpreted using the Integer style.

provider: IFormatProvider

An object that supplies culture-specific parsing information about s. If provider is null, the thread current culture is used.

Returns

Byte

A byte value that is equivalent to the number contained in s.

Implements

Parse(String, IFormatProvider)

Exceptions

ArgumentNullException

s is null.

FormatException

s is not of the correct format.

OverflowException

s represents a number less than Byte.MinValue or greater than Byte.MaxValue.

Examples

The following example parses string representations of Byte values with the Parse method.

String^ stringToConvert; 
Byte byteValue;

stringToConvert = " 214 ";
try {
   byteValue = Byte::Parse(stringToConvert, CultureInfo::InvariantCulture);
   Console::WriteLine("Converted '{0}' to {1}.", stringToConvert, byteValue);
}
catch (FormatException^) {
   Console::WriteLine("Unable to parse '{0}'.", stringToConvert); }
catch (OverflowException^) {
   Console::WriteLine("'{0}' is greater than {1} or less than {2}.", 
                     stringToConvert, Byte::MaxValue, Byte::MinValue); }

stringToConvert = " + 214 ";
try {
   byteValue = Byte::Parse(stringToConvert, CultureInfo::InvariantCulture);
   Console::WriteLine("Converted '{0}' to {1}.", stringToConvert, byteValue);
}
catch (FormatException^) {
   Console::WriteLine("Unable to parse '{0}'.", stringToConvert); }
catch (OverflowException^) {
   Console::WriteLine("'{0}' is greater than {1} or less than {2}.", 
                     stringToConvert, Byte::MaxValue, Byte::MinValue); }

stringToConvert = " +214 ";
try {
   byteValue = Byte::Parse(stringToConvert, CultureInfo::InvariantCulture);
   Console::WriteLine("Converted '{0}' to {1}.", stringToConvert, byteValue);
}
catch (FormatException^) {
   Console::WriteLine("Unable to parse '{0}'.", stringToConvert); }
catch (OverflowException^) {
   Console::WriteLine("'{0}' is greater than {1} or less than {2}.", 
                     stringToConvert, Byte::MaxValue, Byte::MinValue); }
// The example displays the following output to the console:
//       Converted ' 214 ' to 214.
//       Unable to parse ' + 214 '.
//       Converted ' +214 ' to 214.

string stringToConvert;
byte byteValue;

stringToConvert = " 214 ";
try {
   byteValue = Byte.Parse(stringToConvert, CultureInfo.InvariantCulture);
   Console.WriteLine("Converted '{0}' to {1}.", stringToConvert, byteValue);
}
catch (FormatException) {
   Console.WriteLine("Unable to parse '{0}'.", stringToConvert); }
catch (OverflowException) {
   Console.WriteLine("'{0}' is greater than {1} or less than {2}.",
                     stringToConvert, Byte.MaxValue, Byte.MinValue); }

stringToConvert = " + 214 ";
try {
   byteValue = Byte.Parse(stringToConvert, CultureInfo.InvariantCulture);
   Console.WriteLine("Converted '{0}' to {1}.", stringToConvert, byteValue);
}
catch (FormatException) {
   Console.WriteLine("Unable to parse '{0}'.", stringToConvert); }
catch (OverflowException) {
   Console.WriteLine("'{0}' is greater than {1} or less than {2}.",
                     stringToConvert, Byte.MaxValue, Byte.MinValue); }

stringToConvert = " +214 ";
try {
   byteValue = Byte.Parse(stringToConvert, CultureInfo.InvariantCulture);
   Console.WriteLine("Converted '{0}' to {1}.", stringToConvert, byteValue);
}
catch (FormatException) {
   Console.WriteLine("Unable to parse '{0}'.", stringToConvert); }
catch (OverflowException) {
   Console.WriteLine("'{0}' is greater than {1} or less than {2}.",
                     stringToConvert, Byte.MaxValue, Byte.MinValue); }
// The example displays the following output to the console:
//       Converted ' 214 ' to 214.
//       Unable to parse ' + 214 '.
//       Converted ' +214 ' to 214.

let stringToConvert = " 214 "
try
    let byteValue = Byte.Parse(stringToConvert, CultureInfo.InvariantCulture)
    printfn $"Converted '{stringToConvert}' to {byteValue}." 
with
| :? FormatException ->
    printfn $"Unable to parse '{stringToConvert}'."
| :? OverflowException ->
    printfn $"'{stringToConvert}' is greater than {Byte.MaxValue} or less than {Byte.MinValue}." 

let stringToConvert = " + 214 "
try
    let byteValue = Byte.Parse(stringToConvert, CultureInfo.InvariantCulture)
    printfn $"Converted '{stringToConvert}' to {byteValue}." 
with
| :? FormatException ->
    printfn $"Unable to parse '{stringToConvert}'."
| :? OverflowException ->
    printfn $"'{stringToConvert}' is greater than {Byte.MaxValue} or less than {Byte.MinValue}." 

let stringToConvert = " +214 "
try
    let byteValue = Byte.Parse(stringToConvert, CultureInfo.InvariantCulture)
    printfn $"Converted '{stringToConvert}' to {byteValue}." 
with
| :? FormatException ->
    printfn $"Unable to parse '{stringToConvert}'."
| :? OverflowException ->
    printfn $"'{stringToConvert}' is greater than {Byte.MaxValue} or less than {Byte.MinValue}." 

// The example displays the following output to the console:
//       Converted ' 214 ' to 214.
//       Unable to parse ' + 214 '.
//       Converted ' +214 ' to 214.

Dim stringToConvert As String 
Dim byteValue As Byte

stringToConvert = " 214 "
Try
   byteValue = Byte.Parse(stringToConvert, CultureInfo.InvariantCulture)
   Console.WriteLine("Converted '{0}' to {1}.", stringToConvert, byteValue)
Catch e As FormatException
   Console.WriteLine("Unable to parse '{0}'.", stringToConvert)
Catch e As OverflowException
   Console.WriteLine("'{0}' is greater than {1} or less than {2}.", _
                     stringToConvert, Byte.MaxValue, Byte.MinValue)
End Try  

stringToConvert = " + 214 "
Try
   byteValue = Byte.Parse(stringToConvert, CultureInfo.InvariantCulture)
   Console.WriteLine("Converted '{0}' to {1}.", stringToConvert, byteValue)
Catch e As FormatException
   Console.WriteLine("Unable to parse '{0}'.", stringToConvert)
Catch e As OverflowException
   Console.WriteLine("'{0}' is greater than {1} or less than {2}.", _
                     stringToConvert, Byte.MaxValue, Byte.MinValue)
End Try  

stringToConvert = " +214 "
Try
   byteValue = Byte.Parse(stringToConvert, CultureInfo.InvariantCulture)
   Console.WriteLine("Converted '{0}' to {1}.", stringToConvert, byteValue)
Catch e As FormatException
   Console.WriteLine("Unable to parse '{0}'.", stringToConvert)
Catch e As OverflowException
   Console.WriteLine("'{0}' is greater than {1} or less than {2}.", _
                     stringToConvert, Byte.MaxValue, Byte.MinValue)
End Try
' The example displays the following output to the console:
'       Converted ' 214 ' to 214.
'       Unable to parse ' + 214 '.
'       Converted ' +214 ' to 214.

Remarks

The s parameter contains a number of the form:

[ws][sign]digits[ws]

Elements in square brackets ([ and ]) are optional. The following table describes each element.

Element	Description
ws	Optional white space.
sign	An optional positive sign.
digits	A sequence of digits ranging from 0 to 9.

The s parameter is interpreted using the Integer style. In addition to the byte value's decimal digits, only leading and trailing spaces together with a leading sign are allowed. (If the sign is present, it must be a positive sign or the method throws an OverflowException.) To explicitly define the style elements together with the culture-specific formatting information that can be present in s, use the Byte.Parse(String, NumberStyles, IFormatProvider) method.

The s parameter is parsed using the formatting information in a NumberFormatInfo object supplied by provider. The provider parameter is an IFormatProvider implementation such as a NumberFormatInfo or CultureInfo object. The provider parameter supplies culture-specific information used in parsing. If provider is null, the thread current culture is used.

Applies to

Parse(String, NumberStyles)

Source:: Byte.cs

Source:: Byte.cs

Source:: Byte.cs

Converts the string representation of a number in a specified style to its Byte equivalent.

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

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

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

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

Parameters

s: String

A string that contains a number to convert. The string is interpreted using the style specified by style.

style: NumberStyles

A bitwise combination of enumeration values that indicates the style elements that can be present in s. A typical value to specify is Integer.

Returns

Byte

A byte value that is equivalent to the number contained in s.

Exceptions

ArgumentNullException

s is null.

FormatException

s is not of the correct format.

OverflowException

s represents a number less than Byte.MinValue or greater than Byte.MaxValue.

-or-

s includes non-zero, fractional digits.

ArgumentException

style is not a NumberStyles value.

-or-

style is not a combination of AllowHexSpecifier and HexNumber values.

Examples

The following example parses string representations of Byte values with the Byte.Parse(String, NumberStyles) method. The current culture for the example is en-US.

String^ value;
NumberStyles style;
Byte number;

// Parse value with no styles allowed.
style = NumberStyles::None;
value = " 241 ";
try
{
   number = Byte::Parse(value, style);
   Console::WriteLine("Converted '{0}' to {1}.", value, number);
}
catch (FormatException^) {
   Console::WriteLine("Unable to parse '{0}'.", value); }   

// Parse value with trailing sign.
style = NumberStyles::Integer | NumberStyles::AllowTrailingSign;
value = " 163+";
number = Byte::Parse(value, style);
Console::WriteLine("Converted '{0}' to {1}.", value, number);

// Parse value with leading sign.
value = "   +253  ";
number = Byte::Parse(value, style);
Console::WriteLine("Converted '{0}' to {1}.", value, number);
// This example displays the following output to the console:
//       Unable to parse ' 241 '.
//       Converted ' 163+' to 163.
//       Converted '   +253  ' to 253.

string value;
NumberStyles style;
byte number;

// Parse value with no styles allowed.
style = NumberStyles.None;
value = " 241 ";
try
{
   number = Byte.Parse(value, style);
   Console.WriteLine("Converted '{0}' to {1}.", value, number);
}
catch (FormatException) {
   Console.WriteLine("Unable to parse '{0}'.", value); }

// Parse value with trailing sign.
style = NumberStyles.Integer | NumberStyles.AllowTrailingSign;
value = " 163+";
number = Byte.Parse(value, style);
Console.WriteLine("Converted '{0}' to {1}.", value, number);

// Parse value with leading sign.
value = "   +253  ";
number = Byte.Parse(value, style);
Console.WriteLine("Converted '{0}' to {1}.", value, number);
// This example displays the following output to the console:
//       Unable to parse ' 241 '.
//       Converted ' 163+' to 163.
//       Converted '   +253  ' to 253.

// Parse value with no styles allowed.
let style = NumberStyles.None
let value = " 241 "
try
    let number = Byte.Parse(value, style);
    printfn $"Converted '{value}' to {number}."
with :? FormatException ->
    printfn $"Unable to parse '{value}'."

// Parse value with trailing sign.
let style = NumberStyles.Integer ||| NumberStyles.AllowTrailingSign
let value = " 163+"
let number = Byte.Parse(value, style)
printfn $"Converted '{value}' to {number}."

// Parse value with leading sign.
let value = "   +253  "
let number = Byte.Parse(value, style)
printfn $"Converted '{value}' to {number}."

// This example displays the following output to the console:
//       Unable to parse ' 241 '.
//       Converted ' 163+' to 163.
//       Converted '   +253  ' to 253.

Dim value As String
Dim style As NumberStyles
Dim number As Byte

' Parse value with no styles allowed.
style = NumberStyles.None
value = " 241 "
Try
   number = Byte.Parse(value, style)
   Console.WriteLine("Converted '{0}' to {1}.", value, number)
Catch e As FormatException
   Console.WriteLine("Unable to parse '{0}'.", value)   
End Try
  
' Parse value with trailing sign.
style = NumberStyles.Integer Or NumberStyles.AllowTrailingSign
value = " 163+"
number = Byte.Parse(value, style)
Console.WriteLine("Converted '{0}' to {1}.", value, number)

' Parse value with leading sign.
value = "   +253  "
number = Byte.Parse(value, style)
Console.WriteLine("Converted '{0}' to {1}.", value, number)
' This example displays the following output to the console:
'       Unable to parse ' 241 '.
'       Converted ' 163+' to 163.
'       Converted '   +253  ' to 253.

Remarks

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

Or, if style includes AllowHexSpecifier:

[ws]hexdigits[ws]

Elements in square brackets ([ and ]) are optional. The following table describes each element.

Element	Description
ws	Optional white space. White space can appear at the beginning of `s` if `style` includes the NumberStyles.AllowLeadingWhite flag, or at the end of s if style includes the NumberStyles.AllowTrailingWhite flag.
$	A culture-specific currency symbol. Its position in the string is defined by the NumberFormatInfo.CurrencyPositivePattern property of the current culture. The current culture's currency symbol can appear in `s` if `style` includes the NumberStyles.AllowCurrencySymbol flag.
sign	An optional positive sign. (The method throws an OverflowException if a negative sign is present in `s`.) The sign can appear at the beginning of `s` if `style` includes the NumberStyles.AllowLeadingSign flag, or at the end of `s` if `style` includes the NumberStyles.AllowTrailingSign flag.
digits	A sequence of digits from 0 through 9.
.	A culture-specific decimal point symbol. The current culture's decimal point symbol can appear in `s` if `style` includes the NumberStyles.AllowDecimalPoint flag.
fractional_digits	One or more occurrences of the digit 0. Fractional digits can appear in `s` only if `style` includes the NumberStyles.AllowDecimalPoint flag.
e	The e or E character, which indicates that the value is represented in exponential notation. The `s` parameter can represent a number in exponential notation if `style` includes the NumberStyles.AllowExponent flag.
hexdigits	A sequence of hexadecimal digits from 0 through f, or 0 through F.

Note

Any terminating NUL (U+0000) characters in s are ignored by the parsing operation, regardless of the value of the style argument.

Non-composite NumberStyles values	Elements permitted in s in addition to digits
NumberStyles.None	Decimal digits only.
NumberStyles.AllowDecimalPoint	The . and fractional_digits elements. However, fractional_digits must consist of only one or more 0 digits or an OverflowException is thrown.
NumberStyles.AllowExponent	The `s` parameter can also use exponential notation.
NumberStyles.AllowLeadingWhite	The ws element at the beginning of `s`.
NumberStyles.AllowTrailingWhite	The ws element at the end of `s`.
NumberStyles.AllowLeadingSign	A positive sign can appear before digits.
NumberStyles.AllowTrailingSign	A positive sign can appear after digits.
NumberStyles.AllowParentheses	Although this flag is supported, the use of parentheses in `s` results in an OverflowException.
NumberStyles.AllowThousands	Although the group separator symbol can appear in `s`, it can be preceded by only one or more 0 digits.
NumberStyles.AllowCurrencySymbol	The $ element.

If the NumberStyles.AllowHexSpecifier flag is used, s must be a hexadecimal value without a prefix. For example, "F3" parses successfully, but "0xF3" does not. The only other flags that can be combined with it are NumberStyles.AllowLeadingWhite and NumberStyles.AllowTrailingWhite. (The NumberStyles enumeration includes a composite number style, NumberStyles.HexNumber, that includes both white space flags.)

The s parameter is parsed using the formatting information in a NumberFormatInfo object that is initialized for the current system culture. To use the formatting information of some other culture, call the Byte.Parse(String, NumberStyles, IFormatProvider) overload.

Applies to

Parse(ReadOnlySpan<Char>, IFormatProvider)

Source:: Byte.cs

Source:: Byte.cs

Source:: Byte.cs

Parses a span of characters into a value.

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

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

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

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

Parameters

s: ReadOnlySpan<Char>

The span of characters to parse.

provider: IFormatProvider

An object that provides culture-specific formatting information about s.

Returns

Byte

The result of parsing s.

Implements

Parse(ReadOnlySpan<Char>, IFormatProvider)

Applies to

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Source:: Byte.cs

Source:: Byte.cs

Parses a span of UTF-8 characters into a value.

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

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

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

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

Parameters

utf8Text: ReadOnlySpan<Byte>

The span of UTF-8 characters to parse.

provider: IFormatProvider

An object that provides culture-specific formatting information about utf8Text.

Returns

Byte

The result of parsing utf8Text.

Implements

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Applies to

Parse(String)

Source:: Byte.cs

Source:: Byte.cs

Source:: Byte.cs

Converts the string representation of a number to its Byte equivalent.

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

public static byte Parse (string s);

static member Parse : string -> byte

Public Shared Function Parse (s As String) As Byte

Parameters

s: String

A string that contains a number to convert. The string is interpreted using the Integer style.

Returns

Byte

A byte value that is equivalent to the number contained in s.

Exceptions

ArgumentNullException

s is null.

FormatException

s is not of the correct format.

OverflowException

s represents a number less than Byte.MinValue or greater than Byte.MaxValue.

Examples

The following example demonstrates how to convert a string value into a byte value using the Byte.Parse(String) method. The resulting byte value is then displayed to the console.

String^ stringToConvert = " 162";
Byte byteValue;
try
{
   byteValue = Byte::Parse(stringToConvert);
   Console::WriteLine("Converted '{0}' to {1}.", stringToConvert, byteValue);
}   
catch (FormatException^)
{
   Console::WriteLine("Unable to parse '{0}'.", stringToConvert);
}
catch (OverflowException^)
{
   Console::WriteLine("'{0}' is greater than {1} or less than {2}.", 
                     stringToConvert, Byte::MaxValue, Byte::MinValue);
}  
// The example displays the following output to the console:
//       Converted ' 162' to 162.

string stringToConvert = " 162";
byte byteValue;
try
{
   byteValue = Byte.Parse(stringToConvert);
   Console.WriteLine("Converted '{0}' to {1}.", stringToConvert, byteValue);
}
catch (FormatException)
{
   Console.WriteLine("Unable to parse '{0}'.", stringToConvert);
}
catch (OverflowException)
{
   Console.WriteLine("'{0}' is greater than {1} or less than {2}.",
                     stringToConvert, Byte.MaxValue, Byte.MinValue);
}
// The example displays the following output to the console:
//       Converted ' 162' to 162.

let stringToConvert = " 162"
try
    let byteValue = Byte.Parse stringToConvert
    printfn $"Converted '{stringToConvert}' to {byteValue}."
with
| :? FormatException ->
    printfn $"Unable to parse '{stringToConvert}'."
| :? OverflowException ->
    printfn $"'{stringToConvert}' is greater than {Byte.MaxValue} or less than {Byte.MinValue}."

// The example displays the following output to the console:
//       Converted ' 162' to 162.

Dim stringToConvert As String = " 162"
Dim byteValue As Byte
Try
   byteValue = Byte.Parse(stringToConvert)
   Console.WriteLine("Converted '{0}' to {1}.", stringToConvert, byteValue)
Catch e As FormatException
   Console.WriteLine("Unable to parse '{0}'.", stringToConvert)
Catch e As OverflowException
   Console.WriteLine("'{0}' is greater than {1} or less than {2}.", _
                     stringToConvert, Byte.MaxValue, Byte.MinValue)
End Try  
' The example displays the following output to the console:
'       Converted ' 162' to 162.

Remarks

The s parameter contains a number of the form:

[ws][sign]digits[ws]

Elements in square brackets ([ and ]) are optional. The following table describes each element.

Element	Description
ws	Optional white space.
sign	An optional positive or negative sign.
digits	A sequence of digits ranging from 0 to 9.

The s parameter is interpreted using the NumberStyles.Integer style. In addition to the byte value's decimal digits, only leading and trailing spaces together with a leading sign are allowed. (If the sign is present, it must be a positive sign or the method throws an OverflowException.) To explicitly define the style elements that can be present in s, use either the Byte.Parse(String, NumberStyles) or the Byte.Parse(String, NumberStyles, IFormatProvider) method.

The s parameter is parsed using the formatting information in a NumberFormatInfo object that is initialized for the current system culture. For more information, see CurrentInfo. To parse a string using the formatting information of some other culture, use the Byte.Parse(String, NumberStyles, IFormatProvider) method.

Applies to

Dijeli putem

Byte.Parse Method

Definition

Overloads

Parse(String, NumberStyles, IFormatProvider)

Parameters

Returns

Implements

Exceptions

Examples

Remarks

See also

Applies to

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Parameters

Returns

Implements

Applies to

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Parameters

Returns

Implements

Applies to

Parse(String, IFormatProvider)

Parameters

Returns

Implements

Exceptions

Examples

Remarks

See also

Applies to

Parse(String, NumberStyles)

Parameters

Returns

Exceptions

Examples

Remarks

See also

Applies to

Parse(ReadOnlySpan<Char>, IFormatProvider)

Parameters

Returns

Implements

Applies to

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Parameters

Returns

Implements

Applies to

Parse(String)

Parameters

Returns

Exceptions

Examples

Remarks

See also

Applies to

Dodatni resursi