# Decimal.Equals 方法

## 多載

 Equals(Decimal) 傳回值，該值表示這個執行個體和指定的 Decimal 物件是否代表相同值。Returns a value indicating whether this instance and a specified Decimal object represent the same value. Equals(Object) 傳回值，指出這個執行個體和指定的 Object 是否表示相同的類型和值。Returns a value indicating whether this instance and a specified Object represent the same type and value. Equals(Decimal, Decimal) 傳回數值，指出 Decimal 的兩個指定執行個體是否表示相同的值。Returns a value indicating whether two specified instances of Decimal represent the same value.

## Equals(Decimal)

``````public:
virtual bool Equals(System::Decimal value);``````
``public bool Equals (decimal value);``
``override this.Equals : decimal -> bool``
``Public Function Equals (value As Decimal) As Boolean``

value
Decimal

### 給呼叫者的注意事項

[！ code-csharpsystem.object # 2][！ code-vb system.string# 2][!code-csharpSystem.Decimal.Equals#2] [!code-vbSystem.Decimal.Equals#2]

## Equals(Object)

``````public:
override bool Equals(System::Object ^ value);``````
``public override bool Equals (object value);``
``override this.Equals : obj -> bool``
``Public Overrides Function Equals (value As Object) As Boolean``

value
Object

### 範例

``````// Example of the Decimal::CompareTo and Decimal::Equals instance
// methods.
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 );
}

// Compare the Decimal to the Object parameters,
// and display the Object parameters with the results.
void CompDecimalToObject( Decimal Left, Object^ Right, String^ RightText )
{
Console::WriteLine( "{0,-46}{1}", String::Concat( "Object: ", RightText ), Right );
Console::WriteLine( "{0,-46}{1}", "Left.Equals( Object )", Left.Equals( Right ) );
Console::Write( "{0,-46}", "Left.CompareTo( Object )" );
try
{

// Catch the exception if CompareTo( ) throws one.
Console::WriteLine( "{0}\n", Left.CompareTo( Right ) );
}
catch ( Exception^ ex )
{
Console::WriteLine( "{0}\n", GetExceptionType( ex ) );
}

}

int main()
{
Console::WriteLine( "This example of the Decimal::Equals( Object* ) and \n"
"Decimal::CompareTo( Object* ) methods generates the \n"
"following output. It creates several different "
"Decimal \nvalues and compares them with the following "
"reference value.\n" );

// Create a reference Decimal value.
Decimal Left = Decimal(987.654);
Console::WriteLine( "{0,-46}{1}\n", "Left: Decimal( 987.654 )", Left );

// Create objects to compare with the reference.
CompDecimalToObject( Left, Decimal(9.8765400E+2), "Decimal( 9.8765400E+2 )" );
CompDecimalToObject( Left, Decimal::Parse( "987.6541" ), "Decimal::Parse( \"987.6541\" )" );
CompDecimalToObject( Left, Decimal::Parse( "987.6539" ), "Decimal::Parse( \"987.6539\" )" );
CompDecimalToObject( Left, Decimal(987654000,0,0,false,6), "Decimal( 987654000, 0, 0, false, 6 )" );
CompDecimalToObject( Left, 9.8765400E+2, "Double 9.8765400E+2" );
CompDecimalToObject( Left, "987.654", "String \"987.654\"" );
}

/*
This example of the Decimal::Equals( Object* ) and
Decimal::CompareTo( Object* ) methods generates the
following output. It creates several different Decimal
values and compares them with the following reference value.

Left: Decimal( 987.654 )                      987.654

Object: Decimal( 9.8765400E+2 )               987.654
Left.Equals( Object )                         True
Left.CompareTo( Object )                      0

Object: Decimal::Parse( "987.6541" )          987.6541
Left.Equals( Object )                         False
Left.CompareTo( Object )                      -1

Object: Decimal::Parse( "987.6539" )          987.6539
Left.Equals( Object )                         False
Left.CompareTo( Object )                      1

Object: Decimal( 987654000, 0, 0, false, 6 )  987.654000
Left.Equals( Object )                         True
Left.CompareTo( Object )                      0

Object: Double 9.8765400E+2                   987.654
Left.Equals( Object )                         False
Left.CompareTo( Object )                      ArgumentException

Object: String "987.654"                      987.654
Left.Equals( Object )                         False
Left.CompareTo( Object )                      ArgumentException
*/
``````
``````// Example of the decimal.CompareTo and decimal.Equals instance
// methods.
using System;

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

// Compare the decimal to the object parameters,
// and display the object parameters with the results.
public static void CompDecimalToObject( decimal Left,
object Right, string RightText )
{

Console.WriteLine( "{0,-46}{1}", "object: "+RightText,
Right );
Console.WriteLine( "{0,-46}{1}", "Left.Equals( object )",
Left.Equals( Right ) );
Console.Write( "{0,-46}", "Left.CompareTo( object )" );

try
{
// Catch the exception if CompareTo( ) throws one.
Console.WriteLine( "{0}\n", Left.CompareTo( Right ) );
}
catch( Exception ex )
{
Console.WriteLine( "{0}\n", GetExceptionType( ex ) );
}
}

public static void Main( )
{
Console.WriteLine(
"This example of the decimal.Equals( object ) and \n" +
"decimal.CompareTo( object ) methods generates the \n" +
"following output. It creates several different " +
"decimal \nvalues and compares them with the following " +
"reference value.\n" );

// Create a reference decimal value.
decimal Left = new decimal( 987.654 );

Console.WriteLine( "{0,-46}{1}\n",
"Left: decimal( 987.654 )", Left );

// Create objects to compare with the reference.
CompDecimalToObject( Left, new decimal( 9.8765400E+2 ),
"decimal( 9.8765400E+2 )" );
CompDecimalToObject( Left, 987.6541M, "987.6541D" );
CompDecimalToObject( Left, 987.6539M, "987.6539D" );
CompDecimalToObject( Left,
new decimal( 987654000, 0, 0, false, 6 ),
"decimal( 987654000, 0, 0, false, 6 )" );
CompDecimalToObject( Left, 9.8765400E+2,
"Double 9.8765400E+2" );
CompDecimalToObject( Left, "987.654", "String \"987.654\"" );
}
}

/*
This example of the decimal.Equals( object ) and
decimal.CompareTo( object ) methods generates the
following output. It creates several different decimal
values and compares them with the following reference value.

Left: decimal( 987.654 )                      987.654

object: decimal( 9.8765400E+2 )               987.654
Left.Equals( object )                         True
Left.CompareTo( object )                      0

object: 987.6541D                             987.6541
Left.Equals( object )                         False
Left.CompareTo( object )                      -1

object: 987.6539D                             987.6539
Left.Equals( object )                         False
Left.CompareTo( object )                      1

object: decimal( 987654000, 0, 0, false, 6 )  987.654000
Left.Equals( object )                         True
Left.CompareTo( object )                      0

object: Double 9.8765400E+2                   987.654
Left.Equals( object )                         False
Left.CompareTo( object )                      ArgumentException

object: String "987.654"                      987.654
Left.Equals( object )                         False
Left.CompareTo( object )                      ArgumentException
*/
``````
``````' Example of the Decimal.CompareTo and Decimal.Equals instance methods.
Module DecCompToEqualsObjDemo

' 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

' Compare the Decimal to the Object parameters,
' and display the Object parameters with the results.
Sub CompDecimalToObject( Left as Decimal, Right as Object, _
RightText as String )

Console.WriteLine( "{0,-46}{1}", "Object: " & RightText, _
Right )
Console.WriteLine( "{0,-46}{1}", "Left.Equals( Object )", _
Left.Equals( Right ) )
Console.Write( "{0,-46}", "Left.CompareTo( Object )" )

' Catch the exception if CompareTo( ) throws one.
Try
Console.WriteLine( "{0}" & vbCrLf, _
Left.CompareTo( Right ) )
Catch ex As Exception
Console.WriteLine( "{0}" & vbCrLf, _
GetExceptionType( ex ) )
End Try
End Sub

Sub Main( )
Console.WriteLine( _
"This example of the Decimal.Equals( Object ) " & _
"and " & vbCrLf & "Decimal.CompareTo( Object ) " & _
"methods generates the " & vbCrLf & _
"following output. It creates several different " & _
"Decimal " & vbCrLf & "values and compares them " & _
"with the following reference value." & vbCrLf )

' Create a reference Decimal value.
Dim Left as New Decimal( 987.654 )

Console.WriteLine( "{0,-46}{1}" & vbCrLf, _
"Left: Decimal( 987.654 )", Left )

' Create objects to compare with the reference.
CompDecimalToObject( Left, New Decimal( 9.8765400E+2 ), _
"Decimal( 9.8765400E+2 )" )
CompDecimalToObject( Left, 987.6541D, "987.6541D" )
CompDecimalToObject( Left, 987.6539D, "987.6539D" )
CompDecimalToObject( Left, _
New Decimal( 987654000, 0, 0, false, 6 ), _
"Decimal( 987654000, 0, 0, false, 6 )" )
CompDecimalToObject( Left, 9.8765400E+2, _
"Double 9.8765400E+2" )
CompDecimalToObject( Left, "987.654", _
"String ""987.654""" )
End Sub
End Module

' This example of the Decimal.Equals( Object ) and
' Decimal.CompareTo( Object ) methods generates the
' following output. It creates several different Decimal
' values and compares them with the following reference value.
'
' Left: Decimal( 987.654 )                      987.654
'
' Object: Decimal( 9.8765400E+2 )               987.654
' Left.Equals( Object )                         True
' Left.CompareTo( Object )                      0
'
' Object: 987.6541D                             987.6541
' Left.Equals( Object )                         False
' Left.CompareTo( Object )                      -1
'
' Object: 987.6539D                             987.6539
' Left.Equals( Object )                         False
' Left.CompareTo( Object )                      1
'
' Object: Decimal( 987654000, 0, 0, false, 6 )  987.654000
' Left.Equals( Object )                         True
' Left.CompareTo( Object )                      0
'
' Object: Double 9.8765400E+2                   987.654
' Left.Equals( Object )                         False
' Left.CompareTo( Object )                      ArgumentException
'
' Object: String "987.654"                      987.654
' Left.Equals( Object )                         False
' Left.CompareTo( Object )                      ArgumentException
``````

### 給呼叫者的注意事項

[！ code-csharpsystem.object # 2][！ code-vb system.string# 2][!code-csharpSystem.Decimal.Equals#2] [!code-vbSystem.Decimal.Equals#2]

## Equals(Decimal, Decimal)

``````public:
static bool Equals(System::Decimal d1, System::Decimal d2);``````
``public static bool Equals (decimal d1, decimal d2);``
``static member Equals : decimal * decimal -> bool``
``Public Shared Function Equals (d1 As Decimal, d2 As Decimal) As Boolean``

d1
Decimal

d2
Decimal

### 範例

``````// Example of the Decimal::Compare and static Decimal::Equals methods.
using namespace System;
const __wchar_t * protoFmt = L"{0,-45}{1}";

// Compare Decimal parameters, and display them with the results.
void CompareDecimals( Decimal Left, Decimal Right, String^ RightText )
{
String^ dataFmt = gcnew String( protoFmt );
Console::WriteLine();
Console::WriteLine( dataFmt, String::Concat( "Right: ", RightText ), Right );
Console::WriteLine( dataFmt, "Decimal::Equals( Left, Right )", Decimal::Equals( Left, Right ) );
Console::WriteLine( dataFmt, "Decimal::Compare( Left, Right )", Decimal::Compare( Left, Right ) );
}

int main()
{
Console::WriteLine( "This example of the Decimal::Equals( Decimal, Decimal "
") and \nDecimal::Compare( Decimal, Decimal ) "
"methods generates the \nfollowing output. It creates "
"several different Decimal \nvalues and compares them "
"with the following reference value.\n" );

// Create a reference Decimal value.
Decimal Left = Decimal(123.456);
Console::WriteLine( gcnew String( protoFmt ), "Left: Decimal( 123.456 )", Left );

// Create Decimal values to compare with the reference.
CompareDecimals( Left, Decimal(1.2345600E+2), "Decimal( 1.2345600E+2 )" );
CompareDecimals( Left, Decimal::Parse( "123.4561" ), "Decimal::Parse( \"123.4561\" )" );
CompareDecimals( Left, Decimal::Parse( "123.4559" ), "Decimal::Parse( \"123.4559\" )" );
CompareDecimals( Left, Decimal::Parse( "123.456000" ), "Decimal::Parse( \"123.456000\" )" );
CompareDecimals( Left, Decimal(123456000,0,0,false,6), "Decimal( 123456000, 0, 0, false, 6 )" );
}

/*
This example of the Decimal::Equals( Decimal, Decimal ) and
Decimal::Compare( Decimal, Decimal ) methods 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.2345600E+2 )               123.456
Decimal::Equals( Left, Right )               True
Decimal::Compare( Left, Right )              0

Right: Decimal::Parse( "123.4561" )          123.4561
Decimal::Equals( Left, Right )               False
Decimal::Compare( Left, Right )              -1

Right: Decimal::Parse( "123.4559" )          123.4559
Decimal::Equals( Left, Right )               False
Decimal::Compare( Left, Right )              1

Right: Decimal::Parse( "123.456000" )        123.456000
Decimal::Equals( Left, Right )               True
Decimal::Compare( Left, Right )              0

Right: Decimal( 123456000, 0, 0, false, 6 )  123.456000
Decimal::Equals( Left, Right )               True
Decimal::Compare( Left, Right )              0
*/
``````
``````// Example of the decimal.Compare and static decimal.Equals methods.
using System;

class DecCompareEqualsDemo
{
const string dataFmt = "{0,-45}{1}";

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

public static void Main( )
{
Console.WriteLine( "This example of the " +
"decimal.Equals( decimal, decimal ) and \n" +
"decimal.Compare( decimal, decimal ) methods " +
"generates the \nfollowing output. It creates several " +
"different decimal \nvalues and compares them with " +
"the following reference value.\n" );

// Create a reference decimal value.
decimal Left = new decimal( 123.456 );

Console.WriteLine( dataFmt, "Left: decimal( 123.456 )",
Left );

// Create decimal values to compare with the reference.
CompareDecimals( Left, new decimal( 1.2345600E+2 ),
"decimal( 1.2345600E+2 )" );
CompareDecimals( Left, 123.4561M, "123.4561M" );
CompareDecimals( Left, 123.4559M, "123.4559M" );
CompareDecimals( Left, 123.456000M, "123.456000M" );
CompareDecimals( Left,
new decimal( 123456000, 0, 0, false, 6 ),
"decimal( 123456000, 0, 0, false, 6 )" );
}
}

/*
This example of the decimal.Equals( decimal, decimal ) and
decimal.Compare( decimal, decimal ) methods 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.2345600E+2 )               123.456
decimal.Equals( Left, Right )                True
decimal.Compare( Left, Right )               0

Right: 123.4561M                             123.4561
decimal.Equals( Left, Right )                False
decimal.Compare( Left, Right )               -1

Right: 123.4559M                             123.4559
decimal.Equals( Left, Right )                False
decimal.Compare( Left, Right )               1

Right: 123.456000M                           123.456000
decimal.Equals( Left, Right )                True
decimal.Compare( Left, Right )               0

Right: decimal( 123456000, 0, 0, false, 6 )  123.456000
decimal.Equals( Left, Right )                True
decimal.Compare( Left, Right )               0
*/
``````
``````' Example of the Decimal.Compare and static Decimal.Equals methods.
Module DecCompareEqualsDemo

Const dataFmt As String = "{0,-45}{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 )
Console.WriteLine( dataFmt, "Decimal.Equals( Left, Right )", _
Decimal.Equals( Left, Right ) )
Console.WriteLine( dataFmt, _
"Decimal.Compare( Left, Right )", _
Decimal.Compare( Left, Right ) )
End Sub

Sub Main( )
Console.WriteLine( _
"This example of the Decimal.Equals( Decimal, " & _
"Decimal ) and " & vbCrLf & "Decimal.Compare( " & _
"Decimal, Decimal ) methods generates the " & vbCrLf & _
"following output. It creates several different " & _
"Decimal " & vbCrLf & "values and compares them " & _
"with the following reference value." & vbCrLf )

' Create a reference Decimal value.
Dim Left as New Decimal( 123.456 )

Console.WriteLine( dataFmt, "Left: Decimal( 123.456 )", Left )

' Create Decimal values to compare with the reference.
CompareDecimals( Left, New Decimal( 1.2345600E+2 ), _
"Decimal( 1.2345600E+2 )" )
CompareDecimals( Left, 123.4561D, "123.4561D" )
CompareDecimals( Left, 123.4559D, "123.4559D" )
CompareDecimals( Left, 123.456000D, "123.456000D" )
CompareDecimals( Left, _
New Decimal( 123456000, 0, 0, false, 6 ), _
"Decimal( 123456000, 0, 0, false, 6 )" )
End Sub
End Module

' This example of the Decimal.Equals( Decimal, Decimal ) and
' Decimal.Compare( Decimal, Decimal ) methods 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.2345600E+2 )               123.456
' Decimal.Equals( Left, Right )                True
' Decimal.Compare( Left, Right )               0
'
' Right: 123.4561D                             123.4561
' Decimal.Equals( Left, Right )                False
' Decimal.Compare( Left, Right )               -1
'
' Right: 123.4559D                             123.4559
' Decimal.Equals( Left, Right )                False
' Decimal.Compare( Left, Right )               1
'
' Right: 123.456000D                           123.456
' Decimal.Equals( Left, Right )                True
' Decimal.Compare( Left, Right )               0
'
' Right: Decimal( 123456000, 0, 0, false, 6 )  123.456000
' Decimal.Equals( Left, Right )                True
' Decimal.Compare( Left, Right )               0
``````