Parse Method (String)
Collapse the table of content
Expand the table of content

Byte.Parse Method (String)

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

Namespace: System
Assembly: mscorlib (in mscorlib.dll)

public static byte Parse (
	string s
)
public static byte Parse (
	String s
)
public static function Parse (
	s : String
) : byte
Not applicable.

Parameters

s

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

Return Value

The Byte value equivalent to the number contained in s.

Exception typeCondition

ArgumentNullException

s is a null reference (Nothing in Visual Basic).

FormatException

s is not of the correct format.

OverflowException

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

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.

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.

// Example of the Byte.Parse( ) methods.
using System;
using System.Globalization;

class ByteParseDemo
{
    static void ByteParse( NumberStyles styles, 
        IFormatProvider provider )
    {
        string[ ] byteFormats = {
            " 99 ", " +246 ", " plus246 ", " 1_2_3", " DE " };
            
        // Parse each string in the byteFormat array, using 
        // NumberStyles and IFormatProvider, if specified.
        foreach ( string byteString in byteFormats )
        {
            byte byteNumber;
                
            // Display the first part of the output line.
            Console.Write( "  Parse of {0,-15}", 
                String.Format( "\"{0}\"", byteString ) );

            // Use the appropriate Byte.Parse overload, based 
            // on the parameters that are specified.
            try
            {
                if( provider == null )
                    if( styles < 0 )
                        byteNumber = Byte.Parse( byteString );
                    else
                        byteNumber = 
                            Byte.Parse( byteString, styles );
                else if( styles < 0 )
                    byteNumber = 
                        Byte.Parse( byteString, provider );
                else
                    byteNumber = 
                        Byte.Parse( byteString, styles, provider );
                
                // Display the resulting value if Parse succeeded.
                Console.WriteLine( "succeeded: {0}", byteNumber );

            }
            catch( Exception ex )
            {
                // Display the exception message if Parse failed.
                Console.WriteLine( "failed: {0}", ex.Message );
            }
        }
    } 
        
    static void RunParseDemo( )
    {
        // Do not use IFormatProvider or NumberStyles.
        Console.WriteLine(
            "\nNumberStyles and IFormatProvider are not used:" );
        ByteParse( (NumberStyles)(-1), null );
            
        // Use NumberStyles.HexNumber; do not use IFormatProvider.
        Console.WriteLine( "\nNumberStyles.HexNumber, " +
            "is used; IFormatProvider is not used:" );
        ByteParse( NumberStyles.HexNumber, null );
            
        // Get the NumberFormatInfo object from the invariant 
        // culture, and set the positive-sign string to "plus".
        CultureInfo culture = new CultureInfo( "" );
        NumberFormatInfo numFormat = culture.NumberFormat;
        numFormat.PositiveSign = "plus";
            
        // Use the NumberFormatInfo object as the IFormatProvider.
        // Do not use a NumberStyles value.
        Console.WriteLine( "\nA NumberStyles value is not used, " +
            "but the positive sign is \"plus\":" );
        ByteParse( (NumberStyles)(-1), numFormat );
            
        // Change the digit group separator to '_' and the
        // digit group size to 1.
        numFormat.NumberGroupSeparator = "_";
        numFormat.NumberGroupSizes = new int[ ] { 1 };
            
        // Use NumberStyles.Number and the same IFormatProvider.
        Console.WriteLine( "\nNumberStyles.Number is " +
            "used, group separator = \"_\", size = 1:" );
        ByteParse( NumberStyles.Number, numFormat );
    } 
        
    static void Main( )
    {
        Console.WriteLine( "This example of\n" +
            "  Byte.Parse( string ),\n" +
            "  Byte.Parse( string, NumberStyles ),\n" +
            "  Byte.Parse( string, IFormatProvider ), and \n" +
            "  Byte.Parse( string, NumberStyles, IFormatProvider" +
            " )\ngenerates the following output when parsing " +
            "string representations\nof Byte values with each " +
            "of these forms of Byte.Parse( )." );
            
        RunParseDemo( );
    } 
} 

/*
This example of
  Byte.Parse( string ),
  Byte.Parse( string, NumberStyles ),
  Byte.Parse( string, IFormatProvider ), and
  Byte.Parse( string, NumberStyles, IFormatProvider )
generates the following output when parsing string representations
of Byte values with each of these forms of Byte.Parse( ).

NumberStyles and IFormatProvider are not used:
  Parse of " 99 "         succeeded: 99
  Parse of " +246 "       succeeded: 246
  Parse of " plus246 "    failed: Input string was not in a correct format.
  Parse of " 1_2_3"       failed: Input string was not in a correct format.
  Parse of " DE "         failed: Input string was not in a correct format.

NumberStyles.HexNumber, is used; IFormatProvider is not used:
  Parse of " 99 "         succeeded: 153
  Parse of " +246 "       failed: Input string was not in a correct format.
  Parse of " plus246 "    failed: Input string was not in a correct format.
  Parse of " 1_2_3"       failed: Input string was not in a correct format.
  Parse of " DE "         succeeded: 222

A NumberStyles value is not used, but the positive sign is "plus":
  Parse of " 99 "         succeeded: 99
  Parse of " +246 "       failed: Input string was not in a correct format.
  Parse of " plus246 "    succeeded: 246
  Parse of " 1_2_3"       failed: Input string was not in a correct format.
  Parse of " DE "         failed: Input string was not in a correct format.

NumberStyles.Number is used, group separator = "_", size = 1:
  Parse of " 99 "         succeeded: 99
  Parse of " +246 "       failed: Input string was not in a correct format.
  Parse of " plus246 "    succeeded: 246
  Parse of " 1_2_3"       succeeded: 123
  Parse of " DE "         failed: Input string was not in a correct format.
*/ 

// Example of the Byte.Parse( ) methods.
import System.*;
import System.Globalization.*;

class ByteParseDemo
{
    static void ByteParse(NumberStyles styles, IFormatProvider provider)
    {
        String byteFormats[] =  { " 99 ", " +246 ", " plus246 ", " 1_2_3", 
            " DE " };

        for (int iCtr = 0; iCtr < byteFormats.length; iCtr++) {
            // Parse each string in the byteFormat array, using 
            // NumberStyles and IFormatProvider, if specified.
            ubyte byteNumber;

            // Display the first part of the output line.
            Console.Write("  Parse of {0,-15}", String.Format("\"{0}\"", 
                byteFormats[iCtr]));

            // Use the appropriate Byte.Parse overload, based 
            // on the parameters that are specified.
            try {
                if (provider == null) {
                    if ((int)styles < 0) {
                        byteNumber = System.Byte.Parse(byteFormats[iCtr]);
                    }
                    else {
                        byteNumber = System.Byte.Parse(byteFormats[iCtr], 
                            styles);
                    }
                }
                else {
                    if ((int)styles < 0) {
                        byteNumber = System.Byte.Parse(byteFormats[iCtr], 
                            provider);
                    }
                    else {
                        byteNumber = System.Byte.Parse(byteFormats[iCtr], 
                            styles, provider);
                    }
                }
                // Display the resulting value if Parse succeeded.
                Console.WriteLine("succeeded: {0}", 
                    System.Convert.ToString(byteNumber));
            }
            catch (System.Exception ex) {
                // Display the exception message if Parse failed.
                Console.WriteLine("failed: {0}", ex.get_Message());
            }
            finally { }
        }
    } //ByteParse

    static void RunParseDemo()
    {
        // Do not use IFormatProvider or NumberStyles.
        Console.WriteLine("\nNumberStyles and IFormatProvider are not used:");
        ByteParse(((NumberStyles)(-1)), null);

        // Use NumberStyles.HexNumber; do not use IFormatProvider.
        Console.WriteLine(("\nNumberStyles.HexNumber, "
            + "is used; IFormatProvider is not used:"));
        ByteParse(NumberStyles.HexNumber, null);

        // Get the NumberFormatInfo object from the invariant 
        // culture, and set the positive-sign string to "plus".
        CultureInfo culture = new CultureInfo("");
        NumberFormatInfo numFormat = culture.get_NumberFormat();
        numFormat.set_PositiveSign("plus");

        // Use the NumberFormatInfo object as the IFormatProvider.
        // Do not use a NumberStyles value.
        Console.WriteLine(("\nA NumberStyles value is not used, " 
            + "but the positive sign is \"plus\":"));
        ByteParse(((NumberStyles)(-1)), numFormat);

        // Change the digit group separator to '_' and the
        // digit group size to 1.
        numFormat.set_NumberGroupSeparator("_");
        numFormat.set_NumberGroupSizes(new int[] { 1 });

        // Use NumberStyles.Number and the same IFormatProvider.
        Console.WriteLine(("\nNumberStyles.Number is " 
            + "used, group separator = \"_\", size = 1:"));
        ByteParse(NumberStyles.Number, numFormat);
    } //RunParseDemo

    public static void main(String[] args)
    {
        Console.WriteLine(("This example of\n" + "  Byte.Parse( string ),\n"  
            + "  Byte.Parse( string, NumberStyles ),\n"  
            + "  Byte.Parse( string, IFormatProvider ), and \n"  
            + "  Byte.Parse( string, NumberStyles, IFormatProvider" 
            + " )\ngenerates the following output when parsing "  
            + "string representations\nof Byte values with each "  
            + "of these forms of Byte.Parse( )."));
        RunParseDemo();
    } //main
} //ByteParseDemo

/*
This example of
  Byte.Parse( string ),
  Byte.Parse( string, NumberStyles ),
  Byte.Parse( string, IFormatProvider ), and
  Byte.Parse( string, NumberStyles, IFormatProvider )
generates the following output when parsing string representations
of Byte values with each of these forms of Byte.Parse( ).

NumberStyles and IFormatProvider are not used:
  Parse of " 99 "         succeeded: 99
  Parse of " +246 "       succeeded: 246
  Parse of " plus246 "    failed: Input string was not in a correct format.
  Parse of " 1_2_3"       failed: Input string was not in a correct format.
  Parse of " DE "         failed: Input string was not in a correct format.

NumberStyles.HexNumber, is used; IFormatProvider is not used:
  Parse of " 99 "         succeeded: 153
  Parse of " +246 "       failed: Input string was not in a correct format.
  Parse of " plus246 "    failed: Input string was not in a correct format.
  Parse of " 1_2_3"       failed: Input string was not in a correct format.
  Parse of " DE "         succeeded: 222

A NumberStyles value is not used, but the positive sign is "plus":
  Parse of " 99 "         succeeded: 99
  Parse of " +246 "       failed: Input string was not in a correct format.
  Parse of " plus246 "    succeeded: 246
  Parse of " 1_2_3"       failed: Input string was not in a correct format.
  Parse of " DE "         failed: Input string was not in a correct format.

NumberStyles.Number is used, group separator = "_", size = 1:
  Parse of " 99 "         succeeded: 99
  Parse of " +246 "       failed: Input string was not in a correct format.
  Parse of " plus246 "    succeeded: 246
  Parse of " 1_2_3"       succeeded: 123
  Parse of " DE "         failed: Input string was not in a correct format.
*/

Windows 98, Windows Server 2000 SP4, Windows Millennium Edition, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

The Microsoft .NET Framework 3.0 is supported on Windows Vista, Microsoft Windows XP SP2, and Windows Server 2003 SP1.

.NET Framework

Supported in: 3.0, 2.0, 1.1, 1.0

.NET Compact Framework

Supported in: 2.0, 1.0

XNA Framework

Supported in: 1.0

Community Additions

ADD
Show:
© 2016 Microsoft