Export (0) Print
Expand All

Decimal.ToSByte Method

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

This method is not CLS-compliant. The CLS-compliant alternative is the ToInt16 member. For more information about CLS compliance, see What is the Common Language Specification.

[Visual Basic]
<CLSCompliant(False)>
Public Shared Function ToSByte( _
   ByVal value As Decimal _
) As SByte
[C#]
[CLSCompliant(false)]
public static sbyte ToSByte(
 decimal value
);
[C++]
[CLSCompliant(false)]
public: static char ToSByte(
 Decimal value
);
[JScript]
public
   CLSCompliant(false)
static function ToSByte(
 value : Decimal
) : SByte;

Parameters

value
A Decimal value.

Return Value

An 8-bit signed integer equivalent to value.

Exceptions

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

Example

[Visual Basic, C#, C++] The following code example converts Decimal numbers to SByte values using the ToSByte 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 | SByte

Show:
© 2015 Microsoft