# Decimal Unary Plus Operator

.NET Framework 1.1

Returns the value of the Decimal operand (the sign of the operand is unchanged).

[Visual Basic]
returnValue = Decimal.op_UnaryPlus(d)
[C#]
public static decimal operator +(
decimal d
);
[C++]
public: static Decimal op_UnaryPlus(
Decimal d
);
[JScript]
returnValue = +d;

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

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

#### Arguments [Visual Basic, JScript]

d
The Decimal operand.

#### Parameters [C#, C++]

d
The Decimal operand.

#### Return Value

The value of the operand, d.

#### Example

[Visual Basic, C#, C++] The following code example applies the Unary Plus operator to several Decimal values.

[Visual Basic]
' Example of the Decimal increment, decrement, unary negation, and
' unary plus operators.
Imports System
Imports Microsoft.VisualBasic

Module DecIncrDecrUnaryDemo

' 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

' Display the argument and the incremented and decremented values.
Sub DecIncrDecrUnary( argument as Decimal )

Dim toBeIncr As Decimal = argument
Dim toBeDecr As Decimal = argument

Console.WriteLine( "{0,-36}{1}", "Decimal argument: ", _
argument )

' The op_Increment and op_Decrement operators must be
' explicitly coded in Visual Basic.

' Catch the exception if the increment operator throws one.
Console.Write( "{0,-36}", "Decimal.op_Increment( argument )" )
Try
toBeIncr = Decimal.op_Increment( toBeIncr )
Console.WriteLine( "{0}", toBeIncr )
Catch ex As Exception
Console.WriteLine( "{0}", GetExceptionType( ex ) )
End Try

' Catch the exception if the decrement operator throws one.
Console.Write( "{0,-36}", "Decimal.op_Decrement( argument )" )
Try
toBeDecr = Decimal.op_Decrement( toBeDecr )
Console.WriteLine( "{0}", toBeDecr )
Catch ex As Exception
Console.WriteLine( "{0}", GetExceptionType( ex ) )
End Try

Console.WriteLine( )
End Sub

Sub Main( )
Console.WriteLine( _
"This example of the Decimal increment, decrement, " & _
"unary negation, " & vbCrLf & "and unary plus " & _
"operators generates the following output. It " & vbCrLf & _
"displays the results of the operators on several " & _
"Decimal values." & vbCrLf  )

' Create objects to compare with the reference.
DecIncrDecrUnary( 0.000000123D )
DecIncrDecrUnary( New Decimal( 123000000, 0, 0, false, 9 ) )

' The op_UnaryNegation and op_UnaryPlus operators must be
' explicitly coded in Visual Basic. If unary + or - is used,
' other methods are called.
DecIncrDecrUnary( Decimal.op_UnaryNegation( _
New Decimal( 123000000, 0, 0, false, 9 ) ) )
DecIncrDecrUnary( Decimal.op_UnaryPlus( Decimal.MaxValue ) )
DecIncrDecrUnary( Decimal.op_UnaryNegation( Decimal.MaxValue ) )
DecIncrDecrUnary( Decimal.op_UnaryPlus( _
7.5000000000000000000000000001D ) )
End Sub
End Module

' This example of the Decimal increment, decrement, unary negation,
' and unary plus operators generates the following output. It
' displays the results of the operators on several Decimal values.
'
' Decimal argument:                   0.000000123
' Decimal.op_Increment( argument )    1.000000123
' Decimal.op_Decrement( argument )    -0.999999877
'
' Decimal argument:                   0.123000000
' Decimal.op_Increment( argument )    1.123000000
' Decimal.op_Decrement( argument )    -0.877000000
'
' Decimal argument:                   -0.123000000
' Decimal.op_Increment( argument )    0.877000000
' Decimal.op_Decrement( argument )    -1.123000000
'
' Decimal argument:                   79228162514264337593543950335
' Decimal.op_Increment( argument )    OverflowException
' Decimal.op_Decrement( argument )    79228162514264337593543950334
'
' Decimal argument:                   -79228162514264337593543950335
' Decimal.op_Increment( argument )    -79228162514264337593543950334
' Decimal.op_Decrement( argument )    OverflowException
'
' Decimal argument:                   7.5000000000000000000000000001
' Decimal.op_Increment( argument )    8.500000000000000000000000000
' Decimal.op_Decrement( argument )    6.5000000000000000000000000001

[C#]
// Example of the decimal increment, decrement, unary negation, and
// unary plus operators.
using System;

class DecIncrDecrUnaryDemo
{
// 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 );
}

// Display the argument and the incremented and decremented values.
public static void DecIncrDecrUnary( decimal argument )
{
decimal toBeIncr = argument;
decimal toBeDecr = argument;

Console.WriteLine( "{0,-26}{1}", "decimal argument: ",
argument );

// Catch the exception if the increment operator throws one.
Console.Write( "{0,-26}", "argument ++" );
try
{
toBeIncr ++;
Console.WriteLine( "{0}", toBeIncr );
}
catch( Exception ex )
{
Console.WriteLine( "{0}", GetExceptionType( ex ) );
}

// Catch the exception if the decrement operator throws one.
Console.Write( "{0,-26}", "argument --" );
try
{
toBeDecr --;
Console.WriteLine( "{0}", toBeDecr );
}
catch( Exception ex )
{
Console.WriteLine( "{0}", GetExceptionType( ex ) );
}

Console.WriteLine( );
}

public static void Main( )
{
Console.WriteLine( "This example of the decimal increment, " +
"decrement, unary negation, \nand unary plus operators " +
"generates the following output. It \ndisplays the " +
"results of the operators on several decimal values.\n" );

// Create objects to compare with the reference.
DecIncrDecrUnary( 0.000000123M );
DecIncrDecrUnary( new decimal( 123000000, 0, 0, false, 9 ) );
DecIncrDecrUnary( - new decimal( 123000000, 0, 0, false, 9 ) );
DecIncrDecrUnary( + decimal.MaxValue );
DecIncrDecrUnary( - decimal.MaxValue );
DecIncrDecrUnary( + 7.5000000000000000000000000001M );
}
}

/*
This example of the decimal increment, decrement, unary negation,
and unary plus operators generates the following output. It
displays the results of the operators on several decimal values.

decimal argument:         0.000000123
argument ++               1.000000123
argument --               -0.999999877

decimal argument:         0.123000000
argument ++               1.123000000
argument --               -0.877000000

decimal argument:         -0.123000000
argument ++               0.877000000
argument --               -1.123000000

decimal argument:         79228162514264337593543950335
argument ++               OverflowException
argument --               79228162514264337593543950334

decimal argument:         -79228162514264337593543950335
argument ++               -79228162514264337593543950334
argument --               OverflowException

decimal argument:         7.5000000000000000000000000001
argument ++               8.500000000000000000000000000
argument --               6.5000000000000000000000000001
*/

[C++]
// Example of the Decimal increment, decrement, unary negation, and
// unary plus operators.
#using <mscorlib.dll>
using namespace System;

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

// Display the argument and the incremented and decremented values.
void DecIncrDecrUnary( Decimal argument )
{
Decimal toBeIncr = argument;
Decimal toBeDecr = argument;

Console::WriteLine( S"{0,-26}{1}", S"Decimal argument: ",
__box( argument ) );

// Catch the exception if the increment operator throws one.
Console::Write( S"{0,-26}", S"argument ++" );
try
{
toBeIncr ++;
Console::WriteLine( S"{0}", __box( toBeIncr ) );
}
catch( Exception* ex )
{
Console::WriteLine( S"{0}", GetExceptionType( ex ) );
}

// Catch the exception if the decrement operator throws one.
Console::Write( S"{0,-26}", S"argument --" );
try
{
toBeDecr --;
Console::WriteLine( S"{0}", __box( toBeDecr ) );
}
catch( Exception* ex )
{
Console::WriteLine( S"{0}", GetExceptionType( ex ) );
}

Console::WriteLine( );
}

void main( )
{
Console::WriteLine( S"This example of the Decimal increment, "
S"decrement, unary negation, \nand unary plus operators "
S"generates the following output. It \ndisplays the "
S"results of the operators on several Decimal values.\n" );

// Create objects to compare with the reference.
DecIncrDecrUnary( Decimal::Parse( S"0.000000123" ) );
DecIncrDecrUnary( Decimal( 123000000, 0, 0, false, 9 ) );
DecIncrDecrUnary( - Decimal( 123000000, 0, 0, false, 9 ) );
DecIncrDecrUnary( + Decimal::MaxValue );
DecIncrDecrUnary( - Decimal::MaxValue );
DecIncrDecrUnary(
+ Decimal::Parse( S"7.5000000000000000000000000001" ) );
}

/*
This example of the Decimal increment, decrement, unary negation,
and unary plus operators generates the following output. It
displays the results of the operators on several Decimal values.

Decimal argument:         0.000000123
argument ++               1.000000123
argument --               -0.999999877

Decimal argument:         0.123000000
argument ++               1.123000000
argument --               -0.877000000

Decimal argument:         -0.123000000
argument ++               0.877000000
argument --               -1.123000000

Decimal argument:         79228162514264337593543950335
argument ++               OverflowException
argument --               79228162514264337593543950334

Decimal argument:         -79228162514264337593543950335
argument ++               -79228162514264337593543950334
argument --               OverflowException

Decimal argument:         7.5000000000000000000000000001
argument ++               8.500000000000000000000000000
argument --               6.5000000000000000000000000001
*/

[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