This documentation is archived and is not being maintained.

Decimal.ToByte Method

Converts the value of the specified Decimal to the equivalent 8-bit unsigned integer.

[Visual Basic]
Public Shared Function ToByte( _
   ByVal value As Decimal _
) As Byte
[C#]
public static byte ToByte(
 decimal value
);
[C++]
public: static unsigned char ToByte(
 Decimal value
);
[JScript]
public static function ToByte(
   value : Decimal
) : Byte;

Parameters

value
The Decimal value.

Return Value

An 8-bit unsigned integer equivalent to value.

Exceptions

Exception Type Condition
OverflowException value is less than Byte.MinValue or greater than Byte.MaxValue.

Remarks

Parameter value is rounded to the nearest integer value toward zero, and that result is returned.

Example

[Visual Basic, C#, C++] The following code example converts Decimal numbers to Byte values using the ToByte method.

[Visual Basic] 
' Example of the Decimal.ToSByte and Decimal.ToByte methods.
Imports System
Imports Microsoft.VisualBasic

Module DecimalToS_ByteDemo

    Dim formatter As String = "{0,16}{1,19}{2,19}"

    ' Get the exception type name; remove the namespace prefix.
    Function GetExceptionType( ex As Exception ) As String

        Dim exceptionType   As String = ex.GetType( ).ToString( )
        Return  exceptionType.Substring( _
            exceptionType.LastIndexOf( "."c ) + 1 )
    End Function

    ' Convert the Decimal argument; catch exceptions that are thrown.
    Sub DecimalToS_Byte( argument As Decimal )

        Dim SByteValue    As Object
        Dim ByteValue   As Object

        ' Convert the argument to an SByte value.
        Try
            SByteValue = Decimal.ToSByte( argument )
        Catch ex As Exception
            SByteValue = GetExceptionType( ex )
        End Try

        ' Convert the argument to a Byte value.
        Try
            ByteValue = Decimal.ToByte( argument )
        Catch ex As Exception
            ByteValue = GetExceptionType( ex )
        End Try

        Console.WriteLine( formatter, argument, _
            SByteValue, ByteValue )
    End Sub

    Sub Main( )

        Console.WriteLine( "This example of the " & vbCrLf & _
            "  Decimal.ToSByte( Decimal ) and " & vbCrLf & _
            "  Decimal.ToByte( Decimal ) " & vbCrLf & "methods " & _
            "generates the following output. It " & vbCrLf & _
            "displays several converted Decimal values." & vbCrLf )
        Console.WriteLine( formatter, "Decimal argument", _
            "SByte/exception", "Byte/exception" )
        Console.WriteLine( formatter, "----------------", _
            "---------------", "--------------" )

        ' Convert Decimal values and display the results.
        DecimalToS_Byte( 78D )
        DecimalToS_Byte( New Decimal( 78000, 0, 0, False, 3 ) )
        DecimalToS_Byte( 78.999D )
        DecimalToS_Byte( 255.999D )
        DecimalToS_Byte( 256D )
        DecimalToS_Byte( 127.999D )
        DecimalToS_Byte( 128D )
        DecimalToS_Byte( - 0.999D )
        DecimalToS_Byte( - 1D )
        DecimalToS_Byte( - 128.999D )
        DecimalToS_Byte( - 129D )
    End Sub 
End Module 

' This example of the
'   Decimal.ToSByte( Decimal ) and
'   Decimal.ToByte( Decimal )
' methods generates the following output. It
' displays several converted Decimal values.
' 
' Decimal argument    SByte/exception     Byte/exception
' ----------------    ---------------     --------------
'               78                 78                 78
'           78.000                 78                 78
'           78.999                 78                 78
'          255.999  OverflowException                255
'              256  OverflowException  OverflowException
'          127.999                127                127
'              128  OverflowException                128
'           -0.999                  0                  0
'               -1                 -1  OverflowException
'         -128.999               -128  OverflowException
'             -129  OverflowException  OverflowException

[C#] 
// Example of the decimal.ToSByte and decimal.ToByte methods.
using System;

class DecimalToS_ByteDemo
{
    const string formatter = "{0,16}{1,19}{2,19}";

    // Get the exception type name; remove the namespace prefix.
    public static string GetExceptionType( Exception ex )
    {
        string exceptionType = ex.GetType( ).ToString( );
        return exceptionType.Substring( 
            exceptionType.LastIndexOf( '.' ) + 1 );
    }

    // Convert the decimal argument; catch exceptions that are thrown.
    public static void DecimalToS_Byte( decimal argument )
    {
        object SByteValue;
        object ByteValue;

        // Convert the argument to an sbyte value.
        try
        {
            SByteValue = decimal.ToSByte( argument );
        }
        catch( Exception ex )
        {
            SByteValue = GetExceptionType( ex );
        }

        // Convert the argument to a byte value.
        try
        {
            ByteValue = decimal.ToByte( argument );
        }
        catch( Exception ex )
        {
            ByteValue = GetExceptionType( ex );
        }

        Console.WriteLine( formatter, argument, 
            SByteValue, ByteValue );
    }

    public static void Main( )
    {
        Console.WriteLine( "This example of the \n" +
            "  decimal.ToSByte( decimal ) and \n" +
            "  decimal.ToByte( decimal ) \nmethods " +
            "generates the following output. It \ndisplays " +
            "several converted decimal values.\n" );
        Console.WriteLine( formatter, "decimal argument", 
            "sbyte/exception", "byte/exception" );
        Console.WriteLine( formatter, "----------------", 
            "---------------", "--------------" );

        // Convert decimal values and display the results.
        DecimalToS_Byte( 78M );
        DecimalToS_Byte( new decimal( 78000, 0, 0, false, 3 ) );
        DecimalToS_Byte( 78.999M );
        DecimalToS_Byte( 255.999M );
        DecimalToS_Byte( 256M );
        DecimalToS_Byte( 127.999M );
        DecimalToS_Byte( 128M );
        DecimalToS_Byte( -0.999M );
        DecimalToS_Byte( -1M );
        DecimalToS_Byte( -128.999M );
        DecimalToS_Byte( -129M );
    }
}

/*
This example of the
  decimal.ToSByte( decimal ) and
  decimal.ToByte( decimal )
methods generates the following output. It
displays several converted decimal values.

decimal argument    sbyte/exception     byte/exception
----------------    ---------------     --------------
              78                 78                 78
          78.000                 78                 78
          78.999                 78                 78
         255.999  OverflowException                255
             256  OverflowException  OverflowException
         127.999                127                127
             128  OverflowException                128
          -0.999                  0                  0
              -1                 -1  OverflowException
        -128.999               -128  OverflowException
            -129  OverflowException  OverflowException
*/

[C++] 
// Example of the Decimal::ToByte and Decimal::ToSByte methods.
#using <mscorlib.dll>
using namespace System;

const __wchar_t* formatter = L"{0,16}{1,19}{2,19}";

// Get the exception type name; remove the namespace prefix.
String* GetExceptionType( Exception* ex )
{
    String* exceptionType = ex->GetType( )->ToString( );
    return exceptionType->Substring( 
        exceptionType->LastIndexOf( '.' ) + 1 );
}

// Convert the Decimal argument; catch exceptions that are thrown.
void DecimalToS_Byte( Decimal argument )
{
    Object* ByteValue;
    Object* SByteValue;

    // Convert the argument to an unsigned char value.
    try
    {
        ByteValue = __box( Decimal::ToByte( argument ) );
    }
    catch( Exception* ex )
    {
        ByteValue = GetExceptionType( ex );
    }

    // Convert the argument to a signed char value.
    try
    {
        SByteValue = __box( Decimal::ToSByte( argument ) );
    }
    catch( Exception* ex )
    {
        SByteValue = GetExceptionType( ex );
    }

    Console::WriteLine( formatter, __box( argument ), 
        ByteValue, SByteValue );
}

void main( )
{
    Console::WriteLine( S"This example of the \n" 
        S"  Decimal::ToByte( Decimal ) and \n" 
        S"  Decimal::ToSByte( Decimal ) \nmethods " 
        S"generates the following output. It \ndisplays " 
        S"several converted Decimal values.\n" );
    Console::WriteLine( formatter, S"Decimal argument", 
        S"unsigned char", S"(signed) char" );
    Console::WriteLine( formatter, S"----------------", 
        S"-------------", S"-------------" );

    // Convert Decimal values and display the results.
    DecimalToS_Byte( Decimal::Parse( "78" ) );
    DecimalToS_Byte( Decimal( 78000, 0, 0, false, 3 ) );
    DecimalToS_Byte( Decimal::Parse( "78.999" ) );
    DecimalToS_Byte( Decimal::Parse( "255.999" ) );
    DecimalToS_Byte( Decimal::Parse( "256" ) );
    DecimalToS_Byte( Decimal::Parse( "127.999" ) );
    DecimalToS_Byte( Decimal::Parse( "128" ) );
    DecimalToS_Byte( Decimal::Parse( "-0.999" ) );
    DecimalToS_Byte( Decimal::Parse( "-1" ) );
    DecimalToS_Byte( Decimal::Parse( "-128.999" ) );
    DecimalToS_Byte( Decimal::Parse( "-129" ) );
}

/*
This example of the
  Decimal::ToByte( Decimal ) and
  Decimal::ToSByte( Decimal )
methods generates the following output. It
displays several converted Decimal values.

Decimal argument      unsigned char      (signed) char
----------------      -------------      -------------
              78                 78                 78
          78.000                 78                 78
          78.999                 78                 78
         255.999                255  OverflowException
             256  OverflowException  OverflowException
         127.999                127                127
             128                128  OverflowException
          -0.999                  0                  0
              -1  OverflowException                 -1
        -128.999  OverflowException               -128
            -129  OverflowException  OverflowException
*/

[JScript] No example is available for JScript. To view a Visual Basic, C#, or C++ example, click the Language Filter button Language Filter in the upper-left corner of the page.

Requirements

Platforms: Windows 98, Windows NT 4.0, Windows Millennium Edition, Windows 2000, Windows XP Home Edition, Windows XP Professional, Windows Server 2003 family, .NET Compact Framework

See Also

Decimal Structure | Decimal Members | System Namespace | Byte

Show: