Decimal.Equals 메서드

  • 참조

정의

네임스페이스:
System
어셈블리:
System.Runtime.dll
어셈블리:
mscorlib.dll
어셈블리:
netstandard.dll

Decimal의 두 인스턴스가 같은 값을 표시하는지를 나타내는 값을 반환합니다.

오버로드

Equals(Decimal, Decimal)

지정된 두 개의 Decimal 인스턴스가 같은 값을 표시하는지 여부를 나타내는 값을 반환합니다.
Equals(Object)

이 인스턴스와 지정된 Object가 같은 형식과 값을 표시하는지 여부를 나타내는 값을 반환합니다.
Equals(Decimal)

이 인스턴스의 값과 지정된 Decimal 개체의 값이 같은지를 나타내는 값을 반환합니다.

Equals(Decimal, Decimal)

Source:
Decimal.cs
Source:
Decimal.cs
Source:
Decimal.cs

지정된 두 개의 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

비교할 두 번째 값입니다.

반환

Boolean

d1과 d2가 같으면 true이고, 그렇지 않으면 false입니다.

예제

다음 코드 예제에서는 정적 Equals 메서드를 사용하여 여러 Decimal 값을 참조 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.
open System

let print message obj = printfn $"%-45s{message}{obj}"

// Compare decimal parameters, and display them with the results.
let compareDecimals (left: decimal) (right: decimal) (rightText: string) =
    printfn ""
    print $"right: {rightText}" right
    print "decimal.Equals(left, right)  " (Decimal.Equals(left, right))
    print "decimal.Compare(left, right)  " (Decimal.Compare(left, right))

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.
let left = decimal 123.456

print "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 123.4561M "123.4561M"
compareDecimals left 123.4559M "123.4559M"
compareDecimals left 123.456000M "123.456000M"
compareDecimals left (Decimal(123456000, 0, 0, false, 6uy)) "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

추가 정보

적용 대상

Equals(Object)

Source:
Decimal.cs
Source:
Decimal.cs
Source:
Decimal.cs

이 인스턴스와 지정된 Object가 같은 형식과 값을 표시하는지 여부를 나타내는 값을 반환합니다.

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

매개 변수

value
Object

이 인스턴스와 비교할 개체입니다.

반환

Boolean

value가 Decimal이고 이 인스턴스와 같으면 true이고, 그렇지 않으면 false입니다.

예제

다음 코드 예제에서는 메서드를 사용하여 여러 Decimal 개체와 다른 개체를 참조 Decimal 값과 Equals 비교합니다.

// 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.
open System

// Get the exception type name remove the namespace prefix.
let getExceptionType (ex: exn) =
    let exceptionType = ex.GetType() |> string
    exceptionType.Substring(exceptionType.LastIndexOf '.'  + 1)

// Compare the decimal to the object parameters,
// and display the object parameters with the results.
let compDecimalToObject (left: decimal) (right: obj) (rightText: string) =
    printfn $"object: %-38s{rightText}{right}"
    printfn $"""%-46s{"left.Equals(object)"}{left.Equals right}"""       
    printf $"""%-46s{"left.CompareTo(object)"}"""

    try
        // Catch the exception if CompareTo( ) throws one.
        printfn $"{left.CompareTo right}\n"
    with ex ->
        printfn $"{getExceptionType ex}\n"

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.
let left = decimal 987.654

printfn $"""{"Left: decimal(987.654)",-46}{left}\n"""

// Create objects to compare with the reference.
compDecimalToObject left (decimal 9.8765400E+2 ) "decimal(9.8765400E+2)"
compDecimalToObject left 987.6541M "987.6541D"
compDecimalToObject left 987.6539M "987.6539D"
compDecimalToObject left (Decimal(987654000, 0, 0, false, 6uy)) "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

호출자 참고

컴파일러 오버로드 확인은 두 Equals(Object) 메서드 오버로드의 동작에 명백한 차이를 설명할 수 있습니다. 인수와 Decimal 의 암시적 변환 obj 이 정의되고 인수가 로 Object형식화되지 않은 경우 컴파일러가 암시적 변환을 수행하고 메서드를 호출할 Equals(Decimal) 수 있습니다. 그렇지 않으면 메서드를 Equals(Object) 호출합니다. 메서드는 인수가 obj 값이 아닌 Decimal 경우 항상 를 반환 false 합니다. 다음 예제에서는 두 메서드 오버로드 간의 동작 차이를 보여 줍니다. 부호 있는 형식과 부호 없는 형식을 비롯한 모든 기본 정수 계열 형식의 경우 컴파일러가 자동으로 확대 변환을 수행하고 메서드를 호출 Equals(Decimal) 하기 때문에 첫 번째 비교가 반환 true 되는 반면, 두 번째 비교는 컴파일러가 메서드를 호출 Equals(Object) 하기 때문에 를 반환 false 합니다.

using System;

public class Example
{
   static decimal value = 112m;

   public static void Main()
   {
      byte byte1= 112;
      Console.WriteLine("value = byte1: {0,17}", value.Equals(byte1));
      TestObjectForEquality(byte1);

      short short1 = 112;
      Console.WriteLine("value = short1: {0,17}", value.Equals(short1));
      TestObjectForEquality(short1);

      int int1 = 112;
      Console.WriteLine("value = int1: {0,19}", value.Equals(int1));
      TestObjectForEquality(int1);

      long long1 = 112;
      Console.WriteLine("value = long1: {0,18}", value.Equals(long1));
      TestObjectForEquality(long1);

      sbyte sbyte1 = 112;
      Console.WriteLine("value = sbyte1: {0,17}", value.Equals(sbyte1));
      TestObjectForEquality(sbyte1);

      ushort ushort1 = 112;
      Console.WriteLine("value = ushort1: {0,17}", value.Equals(ushort1));
      TestObjectForEquality(ushort1);

      uint uint1 = 112;
      Console.WriteLine("value = uint1: {0,19}", value.Equals(uint1));
      TestObjectForEquality(uint1);

      ulong ulong1 = 112;
      Console.WriteLine("value = ulong1: {0,18}", value.Equals(ulong1));
      TestObjectForEquality(ulong1);

      float sng1 = 112;
      Console.WriteLine("value = sng1: {0,21}", value.Equals(sng1));
      TestObjectForEquality(sng1);

      double dbl1 = 112;
      Console.WriteLine("value = dbl1: {0,21}", value.Equals(dbl1));
      TestObjectForEquality(dbl1);
   }

   private static void TestObjectForEquality(Object obj)
   {
      Console.WriteLine("{0} ({1}) = {2} ({3}): {4}\n",
                        value, value.GetType().Name,
                        obj, obj.GetType().Name,
                        value.Equals(obj));
   }
}
// The example displays the following output:
//       value = byte1:              True
//       112 (Decimal) = 112 (Byte): False
//
//       value = short1:              True
//       112 (Decimal) = 112 (Int16): False
//
//       value = int1:                True
//       112 (Decimal) = 112 (Int32): False
//
//       value = long1:               True
//       112 (Decimal) = 112 (Int64): False
//
//       value = sbyte1:              True
//       112 (Decimal) = 112 (SByte): False
//
//       value = ushort1:              True
//       112 (Decimal) = 112 (UInt16): False
//
//       value = uint1:                True
//       112 (Decimal) = 112 (UInt32): False
//
//       value = ulong1:               True
//       112 (Decimal) = 112 (UInt64): False
//
//       value = sng1:                 False
//       112 (Decimal) = 112 (Single): False
//
//       value = dbl1:                 False
//       112 (Decimal) = 112 (Double): False

let value = 112m

let testObjectForEquality (obj: obj) =
    printfn $"{value} ({value.GetType().Name}) = {obj} ({obj.GetType().Name}): {value.Equals obj}\n"

let byte1 = 112uy
printfn $"value = byte1: {value.Equals byte1,17}"
testObjectForEquality byte1

let short1 = 112s
printfn $"value = short1: {value.Equals short1,17}"
testObjectForEquality short1

let int1 = 112
printfn $"value = int1: {value.Equals int1,19}"
testObjectForEquality int1

let long1 = 112L
printfn $"value = long1: {value.Equals long1,18}"
testObjectForEquality long1

let sbyte1 = 112y
printfn $"value = sbyte1: {value.Equals sbyte1,17}"
testObjectForEquality sbyte1

let ushort1 = 112us
printfn $"value = ushort1: {value.Equals ushort1,17}"
testObjectForEquality ushort1

let uint1 = 112u
printfn $"value = uint1: {value.Equals uint1,19}"
testObjectForEquality uint1

let ulong1 = 112uL
printfn $"value = ulong1: {value.Equals ulong1,18}"
testObjectForEquality ulong1

let sng1 = 112f
printfn $"value = sng1: {value.Equals sng1,21}"
testObjectForEquality sng1

let dbl1 = 112.
printfn $"value = dbl1: {value.Equals dbl1,21}"
testObjectForEquality dbl1


// The example displays the following output:
//       value = byte1:              True
//       112 (Decimal) = 112 (Byte): False
//
//       value = short1:              True
//       112 (Decimal) = 112 (Int16): False
//
//       value = int1:                True
//       112 (Decimal) = 112 (Int32): False
//
//       value = long1:               True
//       112 (Decimal) = 112 (Int64): False
//
//       value = sbyte1:              True
//       112 (Decimal) = 112 (SByte): False
//
//       value = ushort1:              True
//       112 (Decimal) = 112 (UInt16): False
//
//       value = uint1:                True
//       112 (Decimal) = 112 (UInt32): False
//
//       value = ulong1:               True
//       112 (Decimal) = 112 (UInt64): False
//
//       value = sng1:                 False
//       112 (Decimal) = 112 (Single): False
//
//       value = dbl1:                 False
//       112 (Decimal) = 112 (Double): False

Module Example
   Dim value As Decimal = 112d
   
   Public Sub Main()
      Dim byte1 As Byte = 112
      Console.WriteLine("value = byte1: {0,17}", value.Equals(byte1))
      TestObjectForEquality(byte1)
      
      Dim short1 As Short = 112
      Console.WriteLine("value = short1: {0,17}", value.Equals(short1))
      TestObjectForEquality(short1)

      Dim int1 As Integer = 112
      Console.WriteLine("value = int1: {0,19}", value.Equals(int1))
      TestObjectForEquality(int1)

      Dim long1 As Long = 112
      Console.WriteLine("value = long1: {0,18}", value.Equals(long1))
      TestObjectForEquality(long1)

      Dim sbyte1 As SByte = 112
      Console.WriteLine("value = sbyte1: {0,17}", value.Equals(sbyte1))
      TestObjectForEquality(sbyte1)
      
      Dim ushort1 As UShort = 112
      Console.WriteLine("value = ushort1: {0,17}", value.Equals(ushort1))
      TestObjectForEquality(ushort1)

      Dim uint1 As UInteger = 112
      Console.WriteLine("value = uint1: {0,19}", value.Equals(uint1))
      TestObjectForEquality(uint1)

      Dim ulong1 As ULong = 112
      Console.WriteLine("value = ulong1: {0,18}", value.Equals(ulong1))
      TestObjectForEquality(ulong1)

      Dim sng1 As Single = 112
      Console.WriteLine("value = sng1: {0,21}", value.Equals(sng1))
      TestObjectForEquality(sng1)

      Dim dbl1 As Double = 112
      Console.WriteLine("value = dbl1: {0,21}", value.Equals(dbl1))
      TestObjectForEquality(dbl1)
   End Sub
   
   Private Sub TestObjectForEquality(obj As Object)
      Console.WriteLine("{0} ({1}) = {2} ({3}): {4}",
                        value, value.GetType().Name,
                        obj, obj.GetType().Name,
                        value.Equals(obj))
      Console.WriteLine()
   End Sub
End Module
' The example displays the following output:
'       value = byte1:              True
'       112 (Decimal) = 112 (Byte): False
'
'       value = short1:              True
'       112 (Decimal) = 112 (Int16): False
'
'       value = int1:                True
'       112 (Decimal) = 112 (Int32): False
'
'       value = long1:               True
'       112 (Decimal) = 112 (Int64): False
'
'       value = sbyte1:              True
'       112 (Decimal) = 112 (SByte): False
'
'       value = ushort1:              True
'       112 (Decimal) = 112 (UInt16): False
'
'       value = uint1:                True
'       112 (Decimal) = 112 (UInt32): False
'
'       value = ulong1:               True
'       112 (Decimal) = 112 (UInt64): False
'
'       value = sng1:                 False
'       112 (Decimal) = 112 (Single): False
'
'       value = dbl1:                 False
'       112 (Decimal) = 112 (Double): False

추가 정보

적용 대상

Equals(Decimal)

Source:
Decimal.cs
Source:
Decimal.cs
Source:
Decimal.cs

이 인스턴스의 값과 지정된 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

이 인스턴스와 비교할 개체입니다.

반환

Boolean

true가 이 인스턴스와 같으면 value이고, 그러지 않으면 false입니다.

구현

Equals(T)

설명

이 메서드는 인터페이스를 System.IEquatable<T> 구현하고 매개 변수를 개체로 변환 value 할 필요가 없기 때문에 보다 Equals 약간 더 잘 수행됩니다.

인스턴스 형식보다 적은 비트(좁은 비트)가 있는 경우 value 일부 프로그래밍 언어는 매개 변수 값을 비트가 더 많은 값으로 변환하는 암시적 확대 변환을 수행합니다.

예를 들어 인스턴스 형식이 이 Int32 고 매개 변수 형식이 인 경우를 가정해 Byte보겠습니다. Microsoft C# 컴파일러는 매개 변수의 값을 개체로 Int32 나타내는 명령을 생성한 다음 인스턴스와 매개 변수 표현을 비교하는 메서드를 Int32 생성합니다Int32.CompareTo.

프로그래밍 언어의 설명서를 참조하여 컴파일러가 숫자 형식에서 암시적 확대 변환을 수행하는지 여부를 확인합니다.

호출자 참고

컴파일러 오버로드 확인은 두 Equals(Object) 메서드 오버로드의 동작에 명백한 차이를 설명할 수 있습니다. 인수와 Decimal 의 암시적 변환 obj 이 정의되고 인수가 로 Object형식화되지 않은 경우 컴파일러가 암시적 변환을 수행하고 메서드를 호출할 Equals(Decimal) 수 있습니다. 그렇지 않으면 메서드를 Equals(Object) 호출합니다. 메서드는 인수가 obj 값이 아닌 Decimal 경우 항상 를 반환 false 합니다. 다음 예제에서는 두 메서드 오버로드 간의 동작 차이를 보여 줍니다. 부호 있는 형식과 부호 없는 형식을 비롯한 모든 기본 정수 계열 형식의 경우 컴파일러가 자동으로 확대 변환을 수행하고 메서드를 호출 Equals(Decimal) 하기 때문에 첫 번째 비교가 반환 true 되는 반면, 두 번째 비교는 컴파일러가 메서드를 호출 Equals(Object) 하기 때문에 를 반환 false 합니다.

using System;

public class Example
{
   static decimal value = 112m;

   public static void Main()
   {
      byte byte1= 112;
      Console.WriteLine("value = byte1: {0,17}", value.Equals(byte1));
      TestObjectForEquality(byte1);

      short short1 = 112;
      Console.WriteLine("value = short1: {0,17}", value.Equals(short1));
      TestObjectForEquality(short1);

      int int1 = 112;
      Console.WriteLine("value = int1: {0,19}", value.Equals(int1));
      TestObjectForEquality(int1);

      long long1 = 112;
      Console.WriteLine("value = long1: {0,18}", value.Equals(long1));
      TestObjectForEquality(long1);

      sbyte sbyte1 = 112;
      Console.WriteLine("value = sbyte1: {0,17}", value.Equals(sbyte1));
      TestObjectForEquality(sbyte1);

      ushort ushort1 = 112;
      Console.WriteLine("value = ushort1: {0,17}", value.Equals(ushort1));
      TestObjectForEquality(ushort1);

      uint uint1 = 112;
      Console.WriteLine("value = uint1: {0,19}", value.Equals(uint1));
      TestObjectForEquality(uint1);

      ulong ulong1 = 112;
      Console.WriteLine("value = ulong1: {0,18}", value.Equals(ulong1));
      TestObjectForEquality(ulong1);

      float sng1 = 112;
      Console.WriteLine("value = sng1: {0,21}", value.Equals(sng1));
      TestObjectForEquality(sng1);

      double dbl1 = 112;
      Console.WriteLine("value = dbl1: {0,21}", value.Equals(dbl1));
      TestObjectForEquality(dbl1);
   }

   private static void TestObjectForEquality(Object obj)
   {
      Console.WriteLine("{0} ({1}) = {2} ({3}): {4}\n",
                        value, value.GetType().Name,
                        obj, obj.GetType().Name,
                        value.Equals(obj));
   }
}
// The example displays the following output:
//       value = byte1:              True
//       112 (Decimal) = 112 (Byte): False
//
//       value = short1:              True
//       112 (Decimal) = 112 (Int16): False
//
//       value = int1:                True
//       112 (Decimal) = 112 (Int32): False
//
//       value = long1:               True
//       112 (Decimal) = 112 (Int64): False
//
//       value = sbyte1:              True
//       112 (Decimal) = 112 (SByte): False
//
//       value = ushort1:              True
//       112 (Decimal) = 112 (UInt16): False
//
//       value = uint1:                True
//       112 (Decimal) = 112 (UInt32): False
//
//       value = ulong1:               True
//       112 (Decimal) = 112 (UInt64): False
//
//       value = sng1:                 False
//       112 (Decimal) = 112 (Single): False
//
//       value = dbl1:                 False
//       112 (Decimal) = 112 (Double): False

let value = 112m

let testObjectForEquality (obj: obj) =
    printfn $"{value} ({value.GetType().Name}) = {obj} ({obj.GetType().Name}): {value.Equals obj}\n"

let byte1 = 112uy
printfn $"value = byte1: {value.Equals byte1,17}"
testObjectForEquality byte1

let short1 = 112s
printfn $"value = short1: {value.Equals short1,17}"
testObjectForEquality short1

let int1 = 112
printfn $"value = int1: {value.Equals int1,19}"
testObjectForEquality int1

let long1 = 112L
printfn $"value = long1: {value.Equals long1,18}"
testObjectForEquality long1

let sbyte1 = 112y
printfn $"value = sbyte1: {value.Equals sbyte1,17}"
testObjectForEquality sbyte1

let ushort1 = 112us
printfn $"value = ushort1: {value.Equals ushort1,17}"
testObjectForEquality ushort1

let uint1 = 112u
printfn $"value = uint1: {value.Equals uint1,19}"
testObjectForEquality uint1

let ulong1 = 112uL
printfn $"value = ulong1: {value.Equals ulong1,18}"
testObjectForEquality ulong1

let sng1 = 112f
printfn $"value = sng1: {value.Equals sng1,21}"
testObjectForEquality sng1

let dbl1 = 112.
printfn $"value = dbl1: {value.Equals dbl1,21}"
testObjectForEquality dbl1


// The example displays the following output:
//       value = byte1:              True
//       112 (Decimal) = 112 (Byte): False
//
//       value = short1:              True
//       112 (Decimal) = 112 (Int16): False
//
//       value = int1:                True
//       112 (Decimal) = 112 (Int32): False
//
//       value = long1:               True
//       112 (Decimal) = 112 (Int64): False
//
//       value = sbyte1:              True
//       112 (Decimal) = 112 (SByte): False
//
//       value = ushort1:              True
//       112 (Decimal) = 112 (UInt16): False
//
//       value = uint1:                True
//       112 (Decimal) = 112 (UInt32): False
//
//       value = ulong1:               True
//       112 (Decimal) = 112 (UInt64): False
//
//       value = sng1:                 False
//       112 (Decimal) = 112 (Single): False
//
//       value = dbl1:                 False
//       112 (Decimal) = 112 (Double): False

Module Example
   Dim value As Decimal = 112d
   
   Public Sub Main()
      Dim byte1 As Byte = 112
      Console.WriteLine("value = byte1: {0,17}", value.Equals(byte1))
      TestObjectForEquality(byte1)
      
      Dim short1 As Short = 112
      Console.WriteLine("value = short1: {0,17}", value.Equals(short1))
      TestObjectForEquality(short1)

      Dim int1 As Integer = 112
      Console.WriteLine("value = int1: {0,19}", value.Equals(int1))
      TestObjectForEquality(int1)

      Dim long1 As Long = 112
      Console.WriteLine("value = long1: {0,18}", value.Equals(long1))
      TestObjectForEquality(long1)

      Dim sbyte1 As SByte = 112
      Console.WriteLine("value = sbyte1: {0,17}", value.Equals(sbyte1))
      TestObjectForEquality(sbyte1)
      
      Dim ushort1 As UShort = 112
      Console.WriteLine("value = ushort1: {0,17}", value.Equals(ushort1))
      TestObjectForEquality(ushort1)

      Dim uint1 As UInteger = 112
      Console.WriteLine("value = uint1: {0,19}", value.Equals(uint1))
      TestObjectForEquality(uint1)

      Dim ulong1 As ULong = 112
      Console.WriteLine("value = ulong1: {0,18}", value.Equals(ulong1))
      TestObjectForEquality(ulong1)

      Dim sng1 As Single = 112
      Console.WriteLine("value = sng1: {0,21}", value.Equals(sng1))
      TestObjectForEquality(sng1)

      Dim dbl1 As Double = 112
      Console.WriteLine("value = dbl1: {0,21}", value.Equals(dbl1))
      TestObjectForEquality(dbl1)
   End Sub
   
   Private Sub TestObjectForEquality(obj As Object)
      Console.WriteLine("{0} ({1}) = {2} ({3}): {4}",
                        value, value.GetType().Name,
                        obj, obj.GetType().Name,
                        value.Equals(obj))
      Console.WriteLine()
   End Sub
End Module
' The example displays the following output:
'       value = byte1:              True
'       112 (Decimal) = 112 (Byte): False
'
'       value = short1:              True
'       112 (Decimal) = 112 (Int16): False
'
'       value = int1:                True
'       112 (Decimal) = 112 (Int32): False
'
'       value = long1:               True
'       112 (Decimal) = 112 (Int64): False
'
'       value = sbyte1:              True
'       112 (Decimal) = 112 (SByte): False
'
'       value = ushort1:              True
'       112 (Decimal) = 112 (UInt16): False
'
'       value = uint1:                True
'       112 (Decimal) = 112 (UInt32): False
'
'       value = ulong1:               True
'       112 (Decimal) = 112 (UInt64): False
'
'       value = sng1:                 False
'       112 (Decimal) = 112 (Single): False
'
'       value = dbl1:                 False
'       112 (Decimal) = 112 (Double): False

추가 정보

적용 대상