Export (0) Print
Expand All

Byte.Parse Method (String, NumberStyles)

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

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

public:
static unsigned char Parse (
	String^ s, 
	NumberStyles style
)
public static byte Parse (
	String s, 
	NumberStyles style
)
public static function Parse (
	s : String, 
	style : NumberStyles
) : 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.

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 initialized for the current system culture.

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 following code example parses string representations of Byte values with several overloads of the Parse method.

// Example of the Byte::Parse( ) methods.
using namespace System;
using namespace System::Globalization;
using namespace System::Collections;
void ByteParse( NumberStyles styles, IFormatProvider^ provider )
{
   array<String^>^byteFormats = gcnew array<String^>(5);
   byteFormats[ 0 ] = " 99 ";
   byteFormats[ 1 ] = " +246 ";
   byteFormats[ 2 ] = " plus246 ";
   byteFormats[ 3 ] = " 1_2_3";
   byteFormats[ 4 ] = " DE ";
   
   // Parse each string in the byteFormat array, using 
   // NumberStyles and IFormatProvider, if specified.
   // This implements foreach( String* byteString in byteFormats ).
   IEnumerator^ myEnum = byteFormats->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      String^ byteString = safe_cast<String^>(myEnum->Current);
      Byte byteNumber;
      
      // Display the first part of the output line.
      Console::Write( "  Parse of {0,-15}", String::Format( "\"{0}\"", byteString ) );
      try
      {
         
         // Use the appropriate Byte::Parse overload, based 
         // on the parameters that are specified.
         if ( provider == nullptr )
                  if ( (int)styles < 0 )
                  byteNumber = Byte::Parse( byteString );
         else
                  byteNumber = Byte::Parse( byteString, styles );
         else
         if ( (int)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 );
      }

   }
}

void RunParseDemo()
{
   IFormatProvider^ null = nullptr;
   
   // Do not use IFormatProvider or NumberStyles.
   Console::WriteLine( "\nNumberStyles and IFormatProvider are not used:" );
   ByteParse( (NumberStyles)( -1), nullptr );
   
   // Use NumberStyles.HexNumber; do not use IFormatProvider.
   Console::WriteLine( "\nNumberStyles::HexNumber "
   "is used; IFormatProvider is not used:" );
   ByteParse( NumberStyles::HexNumber, nullptr );
   
   // Get the NumberFormatInfo object from the invariant 
   // culture, and set the positive-sign string to "plus".
   CultureInfo^ culture = gcnew 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 = "_";
   array<Int32>^sizes = {1};
   numFormat->NumberGroupSizes = sizes;
   
   // Use NumberStyles::Number and the same IFormatProvider.
   Console::WriteLine( "\nNumberStyles.Number is "
   "used, group separator = \"_\", size = 1:" );
   ByteParse( NumberStyles::Number, numFormat );
}

int 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

Community Additions

ADD
Show:
© 2014 Microsoft