Decimal.Tosbyte() Method In C#

Within this guide, you will explore the Decimal.ToSByte method in C#, examining its syntax, parameters, and illustrations.

What is the Decimal.ToSByte?

The System namespace within C# includes the "Decimal.ToSByte" function, designed for the purpose of converting a decimal value into a signed byte (sbyte).

Syntax:

It has the following syntax:

public static sbyte ToSByte(decimal value);

Parameters

a. Access Modifier

The access modifier determines the visibility of the method. In this specific scenario, any external class or assembly can access it since the method is declared as public.

b. Static Modifier

The static keyword signifies that the method belongs to the class itself rather than any specific object instance. It allows the method to be called directly on the class without the need to instantiate an object.

c. Return Type

public static sbyte ToSByte(decimal value);

d. Method Name

ToSByte: This method is named as such and serves as the reference to invoke it. The method's nomenclature signifies the conversion of a decimal value to a signed byte (sbyte).

e. Parameter

The method specifies the necessary parameters at this point. In this specific instance, it includes a sole parameter of type decimal named value. This parameter symbolizes the decimal value that the method will transform into a signed byte.

Range Limitations

The function is capable of processing values within the range of -128 to 127, which corresponds to the limits of a signed byte. It will trigger an OverflowException if the numerical value surpasses this specified range.

Example 1:

Let's consider a scenario to demonstrate the functionality of the Decimal.ToSByte method in the C# programming language.

using System;
class Demo
{
    static void Main()
    {
        decimal valid_Decimal = 63.8m;
        try
        {
            sbyte result_1 = Decimal.ToSByte(valid_Decimal);
            Console.WriteLine($"Decimal value {valid_Decimal} and converted to SByte: {result_1}");
        }
        catch (OverflowException)
        {
            Console.WriteLine("Conversion resulted in an overflow due to out of SByte range.");
        }
    }
}

Output:

Decimal value 63.8 and converted to SByte: 63

Explanation:

1. Namespace Import

Importing the System namespace allows access to fundamental types and base classes in C#. This line of code is used for importing the namespace.

1. Defining a Class

Within this code snippet, we declare a class named Demo. The focus is on the Main Method.

The static void Main function serves as the starting point for the program's execution. Upon running the program, the Main method is invoked automatically.

1. Declaring Variables

A decimal variable named valid_Decimal is declared and assigned a value of 63.8m. The data type used here is decimal, denoted by the 'm' suffix.

1. Exception Handling using a Try-Catch Block

In a try-catch block, the code within the try block is attempted, and if an OverflowException is encountered, the catch block is executed to handle the exception.

The code within the try block employs the "Decimal.ToSByte" method to transform the valid_Decimal variable into an sbyte.

The transformation is anticipated to be effective as the value 63.8 falls within the acceptable range for an sbyte (-128 to 127).

If there is no overflow, the software displays the outcome of the conversion by utilizing the "Console.WriteLine" method.

1. Console Output

If the transformation is effective, the software will display a message on the Console showing both the initial decimal value and the converted result.

If there is an overflow, the catch block will capture an OverflowException and display a notification stating that the conversion caused an overflow.

Example 2:

Let's consider another scenario to demonstrate the functionality of the Decimal.ToSByte method in the C# programming language.

using System;
class Demo
{
    static void Main()
    {
        decimal overflow_Decimal = 128.5m;
        try
        {
            sbyte result_2 = Decimal.ToSByte(overflow_Decimal);
            Console.WriteLine($"Decimal value {overflow_Decimal} converted to SByte: {result_2}");
        }
        catch (OverflowException)
        {
            Console.WriteLine("\nConversion resulted in an overflow due to out of SByte range.");
        }
    }
}

Output:

Conversion resulted in an overflow due to out of SByte range.

Explanation:

1. Namespace Import

Importing the System namespace in C# is achieved with the following line of code.

1. Class Declaration

class Demo: In this code snippet, we declare a class named Demo.

1. Entry Point

The Main method serves as the entry point for the program's execution. Upon running the program, Main is invoked automatically.

1. Variables Declaration

decimal overflowDecimal = 128.5m;: This line of code defines a decimal variable named overflowDecimal and assigns it a value of 128.5. The 'm' suffix indicates that the literal is a decimal value.

1. Exception Handling Block

In the attempt { ... } catch (OverflowException) { ... } block is employed for managing exceptions.

The code within the try block employs the method "Decimal.ToSByte" to convert the overflow_Decimal variable to an sbyte.

The catch block gets executed in case the conversion results in an overflow (due to the value exceeding the valid range of sbyte).

The catch block intercepts an error message signaling that the conversion led to an overflow and handles an OverflowException.

1. Console Output

The outcome of the conversion or the overflow message gets displayed in the Console using Console.WriteLine.