This topic has not yet been rated - Rate this topic

# Decimal Less Than Or Equal Operator

.NET Framework 1.1

Returns a value indicating whether a specified Decimal is less than or equal to another specified Decimal.

```[Visual Basic]
returnValue = Decimal.op_LessThanOrEqual(d1, d2)
[C#]
public static bool operator <=(
decimal d1,
decimal d2
);
[C++]
public: static bool op_LessThanOrEqual(
Decimal d1,
Decimal d2
);
[JScript]
returnValue = d1 <= d2;```

[Visual Basic] In Visual Basic, you can use the operators defined by a type, but you cannot define your own. You can use the Compare method instead of the Decimal less than or equal operator.

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

d1
A Decimal.
d2
A Decimal.

d1
A Decimal.
d2
A Decimal.

#### Return Value

true if d1 is less than or equal to d2; otherwise, false.

#### Example

[Visual Basic, C#, C++] The following code example compares several Decimal values to a reference Decimal value using the Less Than or Equal operator.

```[Visual Basic]
' Example of the Decimal relational operators.
Imports System
Imports Microsoft.VisualBasic

Module DecRelationalOpsDemo

Const dataFmt As String = "{0,-47}{1}"

' Compare Decimal parameters, and display them with the results.
Sub CompareDecimals( Left As Decimal, Right As Decimal, _
RightText As String )

Console.WriteLine( )
Console.WriteLine( dataFmt, "Right: " & RightText, Right )

' The op_Equality, op_GreaterThan, op_GreaterThanOrEqual,
' op_Inequality, op_LessThan, and op_LessThanOrEqual operators
' must be explicitly coded in Visual Basic. If binary =, >,
' >=, <>, <, or <= are used, the Compare method is called.
Console.WriteLine( dataFmt, _
"Decimal.op_Equality( Left, Right )", _
Decimal.op_Equality( Left, Right ) )
Console.WriteLine( dataFmt, _
"Decimal.op_GreaterThan( Left, Right )", _
Decimal.op_GreaterThan( Left, Right ) )
Console.WriteLine( dataFmt, _
"Decimal.op_GreaterThanOrEqual( Left, Right )", _
Decimal.op_GreaterThanOrEqual( Left, Right ) )
Console.WriteLine( dataFmt, _
"Decimal.op_Inequality( Left, Right )", _
Decimal.op_Inequality( Left, Right ) )
Console.WriteLine( dataFmt, _
"Decimal.op_LessThan( Left, Right )", _
Decimal.op_LessThan( Left, Right ) )
Console.WriteLine( dataFmt, _
"Decimal.op_LessThanOrEqual( Left, Right )", _
Decimal.op_LessThanOrEqual( Left, Right ) )
End Sub

Sub Main( )
Dim Left As New Decimal( 123.456 )

Console.WriteLine( _
"This example of the Decimal relational operators " & _
"generates the " & vbCrLf & "following output. It " & _
"creates several different Decimal values " & vbCrLf & _
"and compares them with the following reference " & _
"value." & vbCrLf )
Console.WriteLine( dataFmt, "Left: Decimal( 123.456 )", Left )

' Create objects to compare with a 2-hour Decimal.
CompareDecimals( Left, New Decimal( 1.23456E+2 ), _
"Decimal( 1.23456E+2 )" )
CompareDecimals( Left, New Decimal( 123.4567 ), _
"Decimal( 123.4567 )" )
CompareDecimals( Left, New Decimal( 123.4553 ), _
"Decimal( 123.4553 )" )
CompareDecimals( Left, New Decimal( 123456000, 0, 0, False, 6 ), _
"Decimal( 123456000, 0, 0, False, 6 )" )
End Sub
End Module

' This example of the Decimal relational operators generates the
' following output. It creates several different Decimal values
' and compares them with the following reference value.
'
' Left: Decimal( 123.456 )                       123.456
'
' Right: Decimal( 1.23456E+2 )                   123.456
' Decimal.op_Equality( Left, Right )             True
' Decimal.op_GreaterThan( Left, Right )          False
' Decimal.op_GreaterThanOrEqual( Left, Right )   True
' Decimal.op_Inequality( Left, Right )           False
' Decimal.op_LessThan( Left, Right )             False
' Decimal.op_LessThanOrEqual( Left, Right )      True
'
' Right: Decimal( 123.4567 )                     123.4567
' Decimal.op_Equality( Left, Right )             False
' Decimal.op_GreaterThan( Left, Right )          False
' Decimal.op_GreaterThanOrEqual( Left, Right )   False
' Decimal.op_Inequality( Left, Right )           True
' Decimal.op_LessThan( Left, Right )             True
' Decimal.op_LessThanOrEqual( Left, Right )      True
'
' Right: Decimal( 123.4553 )                     123.4553
' Decimal.op_Equality( Left, Right )             False
' Decimal.op_GreaterThan( Left, Right )          True
' Decimal.op_GreaterThanOrEqual( Left, Right )   True
' Decimal.op_Inequality( Left, Right )           True
' Decimal.op_LessThan( Left, Right )             False
' Decimal.op_LessThanOrEqual( Left, Right )      False
'
' Right: Decimal( 123456000, 0, 0, False, 6 )    123.456000
' Decimal.op_Equality( Left, Right )             True
' Decimal.op_GreaterThan( Left, Right )          False
' Decimal.op_GreaterThanOrEqual( Left, Right )   True
' Decimal.op_Inequality( Left, Right )           False
' Decimal.op_LessThan( Left, Right )             False
' Decimal.op_LessThanOrEqual( Left, Right )      True

[C#]
// Example of the decimal relational operators.
using System;

class DecRelationalOpsDemo
{
const string dataFmt = "{0,43}    {1}" ;

// Compare decimal parameters, and display them with the results.
static void CompareDecimals( decimal Left, decimal Right,
string RightText )
{
Console.WriteLine( );
Console.WriteLine( dataFmt, "Right: " + RightText, Right );
Console.WriteLine( dataFmt, "Left == Right", Left == Right );
Console.WriteLine( dataFmt, "Left >  Right", Left > Right );
Console.WriteLine( dataFmt, "Left >= Right", Left >= Right );
Console.WriteLine( dataFmt, "Left != Right", Left != Right );
Console.WriteLine( dataFmt, "Left <  Right", Left < Right );
Console.WriteLine( dataFmt, "Left <= Right", Left <= Right );
}

static void Main( )
{
decimal Left = new decimal( 123.456 );

Console.WriteLine(
"This example of the decimal relational operators " +
"generates the \nfollowing output. It creates several " +
"different decimal values \nand compares them with " +
"the following reference value.\n" );
Console.WriteLine( dataFmt,
"Left: decimal( 123.456 )", Left );

// Create objects to compare with a 2-hour decimal.
CompareDecimals( Left, new decimal( 1.23456E+2 ),
"decimal( 1.23456E+2 )" );
CompareDecimals( Left, new decimal( 123.4567 ),
"decimal( 123.4567 )" );
CompareDecimals( Left, new decimal( 123.4553 ),
"decimal( 123.4553 )" );
CompareDecimals( Left, new decimal( 123456000, 0, 0, false, 6 ),
"decimal( 123456000, 0, 0, false, 6 )" );
}
}

/*
This example of the decimal relational operators generates the
following output. It creates several different decimal values
and compares them with the following reference value.

Left: decimal( 123.456 )    123.456

Right: decimal( 1.23456E+2 )    123.456
Left == Right    True
Left >  Right    False
Left >= Right    True
Left != Right    False
Left <  Right    False
Left <= Right    True

Right: decimal( 123.4567 )    123.4567
Left == Right    False
Left >  Right    False
Left >= Right    False
Left != Right    True
Left <  Right    True
Left <= Right    True

Right: decimal( 123.4553 )    123.4553
Left == Right    False
Left >  Right    True
Left >= Right    True
Left != Right    True
Left <  Right    False
Left <= Right    False

Right: decimal( 123456000, 0, 0, false, 6 )    123.456000
Left == Right    True
Left >  Right    False
Left >= Right    True
Left != Right    False
Left <  Right    False
Left <= Right    True
*/

[C++]
// Example of the Decimal relational operators.
#using <mscorlib.dll>
using namespace System;

const __wchar_t* dataFmt = L"{0,43}    {1}" ;

// Compare Decimal parameters, and display them with the results.
void CompareDecimals( Decimal Left, Decimal Right, String* RightText )
{
Console::WriteLine( );
Console::WriteLine( dataFmt,
String::Concat( S"Right: ", RightText ), __box( Right ) );
Console::WriteLine( dataFmt, S"Left == Right",
__box( Left == Right ) );
Console::WriteLine( dataFmt, S"Left >  Right",
__box( Left > Right ) );
Console::WriteLine( dataFmt, S"Left >= Right",
__box( Left >= Right ) );
Console::WriteLine( dataFmt, S"Left != Right",
__box( Left != Right ) );
Console::WriteLine( dataFmt, S"Left <  Right",
__box( Left < Right ) );
Console::WriteLine( dataFmt, S"Left <= Right",
__box( Left <= Right ) );
}

void main( )
{
Decimal Left = Decimal( 123.456 );

Console::WriteLine(
S"This example of the Decimal relational operators "
S"generates the \nfollowing output. It creates several "
S"different Decimal values \nand compares them with "
S"the following reference value.\n" );
Console::WriteLine( dataFmt, S"Left: Decimal( 123.456 )",
__box( Left ) );

// Create objects to compare with a 2-hour Decimal.
CompareDecimals( Left, Decimal( 1.23456E+2 ),
S"Decimal( 1.23456E+2 )" );
CompareDecimals( Left, Decimal( 123.4567 ),
S"Decimal( 123.4567 )" );
CompareDecimals( Left, Decimal( 123.4553 ),
S"Decimal( 123.4553 )");
CompareDecimals( Left, Decimal( 123456000, 0, 0, false, 6 ),
S"Decimal( 123456000, 0, 0, false, 6 )" );
}

/*
This example of the Decimal relational operators generates the
following output. It creates several different Decimal values
and compares them with the following reference value.

Left: Decimal( 123.456 )    123.456

Right: Decimal( 1.23456E+2 )    123.456
Left == Right    True
Left >  Right    False
Left >= Right    True
Left != Right    False
Left <  Right    False
Left <= Right    True

Right: Decimal( 123.4567 )    123.4567
Left == Right    False
Left >  Right    False
Left >= Right    False
Left != Right    True
Left <  Right    True
Left <= Right    True

Right: Decimal( 123.4553 )    123.4553
Left == Right    False
Left >  Right    True
Left >= Right    True
Left != Right    True
Left <  Right    False
Left <= Right    False

Right: Decimal( 123456000, 0, 0, false, 6 )    123.456000
Left == Right    True
Left >  Right    False
Left >= Right    True
Left != Right    False
Left <  Right    False
Left <= Right    True
*/
```

[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