This documentation is archived and is not being maintained.

Int16 to Decimal Conversion

.NET Framework 1.1

Converts a 16-bit signed integer to a Decimal.

```[Visual Basic]
returnValue = Decimal.op_Implicit(value)
[C#]
public static implicit operator decimal(
short value
);
[C++]
public: static Decimal op_Implicit(
short value
);
[JScript]
returnValue = value;```

[Visual Basic] In Visual Basic, you can use the conversion operators defined by a type, but you cannot define your own.

[JScript] In JScript, you can use the conversion operators defined by a type, but you cannot define your own.

Arguments [Visual Basic, JScript]

value
A 16-bit signed integer.

Parameters [C#, C++]

value
A 16-bit signed integer.

Return Value

A Decimal that represents the converted 16-bit signed integer.

Example

[Visual Basic, C#, C++] The following code example converts Int16 values to Decimal numbers using the Int16 to Decimal conversion. This conversion is implicit in C#, but requires the op_Implicit operator in Visual Basic and C++. Implicit conversions to Decimal use other methods in these languages.

```[Visual Basic]
' Example of the op_Implicit conversion from Short to Decimal.
Imports System
Imports Microsoft.VisualBasic

Module DecimalFromInt16Demo

Const formatter As String = _
"{0,16}{1,15}{2,10:X8}{3,9:X8}{4,9:X8}{5,9:X8}"

' Convert the Short argument and display the Decimal value.
Sub DecimalFromInt16( argument As Short )

Dim decValue    As Decimal
Dim bits( )     As Integer

' The compiler invokes a constructor in Visual Basic
' unless op_Implicit is explicitly called.
decValue = Decimal.op_Implicit( argument )

' Display the Decimal and its binary representation.
bits = Decimal.GetBits( decValue )
Console.WriteLine( formatter, argument, decValue, _
bits( 3 ), bits( 2 ), bits( 1 ), bits( 0 ) )
End Sub

Sub Main( )

Console.WriteLine( _
"This example of the op_Implicit conversion from " & _
"Short to Decimal generates the " & vbCrLf & _
"following output. It displays the Decimal value " & _
"and its binary representation." & vbCrLf )
Console.WriteLine( formatter, "Short argument", _
"Decimal value", "bits(3)", "bits(2)", _
"bits(1)", "bits(0)" )
Console.WriteLine( formatter, "--------------", _
"-------------", "-------", "-------", _
"-------", "-------" )

' Convert Short values and display the results.
DecimalFromInt16( Short.MinValue )
DecimalFromInt16( Short.MaxValue )
DecimalFromInt16( &HFFF )
DecimalFromInt16( 12345 )
DecimalFromInt16( -10000 )
End Sub
End Module

' This example of the op_Implicit conversion from Short to Decimal generates the
' following output. It displays the Decimal value and its binary representation.
'
'   Short argument  Decimal value   bits(3)  bits(2)  bits(1)  bits(0)
'   --------------  -------------   -------  -------  -------  -------
'           -32768         -32768  80000000 00000000 00000000 00008000
'            32767          32767  00000000 00000000 00000000 00007FFF
'             4095           4095  00000000 00000000 00000000 00000FFF
'            12345          12345  00000000 00000000 00000000 00003039
'           -10000         -10000  80000000 00000000 00000000 00002710

[C#]
// Example of the implicit conversion from short to decimal.
using System;

class DecimalFromInt16Demo
{
const string formatter =
"{0,15}{1,15}{2,10:X8}{3,9:X8}{4,9:X8}{5,9:X8}";

// Convert the short argument and display the decimal value.
public static void DecimalFromInt16( short argument )
{
decimal decValue;
int[ ]  bits;

// Display the decimal and its binary representation.
decValue = argument;
bits = decimal.GetBits( decValue );

Console.WriteLine( formatter, argument, decValue,
bits[ 3 ], bits[ 2 ], bits[ 1 ], bits[ 0 ] );
}

public static void Main( )
{
Console.WriteLine(
"This example of the implicit conversion from short " +
"to decimal generates the \nfollowing output. It " +
"displays the decimal value and its binary " +
"representation.\n" );
Console.WriteLine( formatter, "short argument",
"decimal value", "bits[3]", "bits[2]",
"bits[1]", "bits[0]" );
Console.WriteLine( formatter, "--------------",
"-------------", "-------", "-------",
"-------", "-------" );

// Convert short values and display the results.
DecimalFromInt16( short.MinValue );
DecimalFromInt16( short.MaxValue );
DecimalFromInt16( 0xFFF );
DecimalFromInt16( 12345 );
DecimalFromInt16( -10000 );
}
}

/*
This example of the implicit conversion from short to decimal generates the
following output. It displays the decimal value and its binary representation.

short argument  decimal value   bits[3]  bits[2]  bits[1]  bits[0]
--------------  -------------   -------  -------  -------  -------
-32768         -32768  80000000 00000000 00000000 00008000
32767          32767  00000000 00000000 00000000 00007FFF
4095           4095  00000000 00000000 00000000 00000FFF
12345          12345  00000000 00000000 00000000 00003039
-10000         -10000  80000000 00000000 00000000 00002710
*/

[C++]
// Example of the op_Implicit conversion from short to Decimal.
#using <mscorlib.dll>
using namespace System;

const __wchar_t* formatter =
L"{0,14}{1,15}{2,10:X8}{3,9:X8}{4,9:X8}{5,9:X8}";

// Convert the short argument and display the Decimal value.
void DecimalFromInt16( short argument )
{
Decimal decValue;
Int32   bits[ ];

// The compiler invokes a constructor in the Managed Extensions
// for C++ unless op_Implicit is explicitly called.
decValue = Decimal::op_Implicit( argument );

// Display the Decimal and its binary representation.
bits = Decimal::GetBits( decValue );
Console::WriteLine( formatter, __box( argument ),
__box( decValue ), __box( bits[ 3 ] ),
__box( bits[ 2 ] ), __box( bits[ 1 ] ), __box( bits[ 0 ] ) );
}

void main( )
{
Console::WriteLine(
S"This example of the op_Implicit conversion from "
S"short to Decimal \ngenerates the following output. "
S"It displays the Decimal value \nand its binary "
S"representation.\n" );
Console::WriteLine( formatter, S"short argument",
S"Decimal value", S"bits[3]", S"bits[2]",
S"bits[1]", S"bits[0]" );
Console::WriteLine( formatter, S"--------------",
S"-------------", S"-------", S"-------",
S"-------", S"-------" );

// Convert short values and display the results.
DecimalFromInt16( Int16::MinValue );
DecimalFromInt16( Int16::MaxValue );
DecimalFromInt16( 0xFFF );
DecimalFromInt16( 12345 );
DecimalFromInt16( -10000 );
}

/*
This example of the op_Implicit conversion from short to Decimal
generates the following output. It displays the Decimal value
and its binary representation.

short argument  Decimal value   bits[3]  bits[2]  bits[1]  bits[0]
--------------  -------------   -------  -------  -------  -------
-32768         -32768  80000000 00000000 00000000 00008000
32767          32767  00000000 00000000 00000000 00007FFF
4095           4095  00000000 00000000 00000000 00000FFF
12345          12345  00000000 00000000 00000000 00003039
-10000         -10000  80000000 00000000 00000000 00002710
*/
```

[JScript] No example is available for JScript. To view a Visual Basic, C#, or C++ example, click the Language Filter button 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, Common Language Infrastructure (CLI) Standard