Export (0) Print
Expand All
This topic has not yet been rated - Rate this topic

Byte.Parse Method (String, NumberStyles, IFormatProvider)

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

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

public static byte Parse (
	string s,
	NumberStyles style,
	IFormatProvider provider
)
public static byte Parse (
	String s, 
	NumberStyles style, 
	IFormatProvider provider
)
public static function Parse (
	s : String, 
	style : NumberStyles, 
	provider : IFormatProvider
) : byte

Parameters

s

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

style

A bitwise combination of NumberStyles values that indicates the permitted format of s. A typical value to specify is Integer.

provider

An IFormatProvider that supplies culture-specific formatting information about s. If provider is a null reference (Nothing in Visual Basic), the current system culture is used.

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.

ArgumentException

style is not a NumberStyles value.

-or-

style is not a combination of AllowHexSpecifier and HexNumber values.

The s parameter is parsed using the formatting information in a NumberFormatInfo supplied by provider.

The s parameter contains a number of the form:

[ws][sign]digits[ws]

Or, if style includes AllowHexSpecifier:

[ws]hexdigits[ws]

Items in square brackets ([ and ]) are optional, and other items are as follows.

ws

Optional white space if permitted by style.

sign

An optional sign.

digits

A sequence of digits from 0 through 9.

hexdigits

A sequence of hexadecimal digits from 0 through f, or 0 through F.

The provider parameter is an IFormatProvider instance that supplies a NumberFormatInfo object. The NumberFormatInfo object provides culture-specific information about the format of s.

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

// 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 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 .NET Framework does not support all versions of every platform. For a list of the supported versions, see System Requirements.

.NET Framework

Supported in: 2.0, 1.1, 1.0

.NET Compact Framework

Supported in: 2.0, 1.0
Did you find this helpful?
(1500 characters remaining)
Thank you for your feedback

Community Additions

ADD
Show:
© 2014 Microsoft. All rights reserved.