Decimal.Equals Méthode

Référence

Définition

Espace de noms:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Retourne une valeur indiquant si deux instances de Decimal représentent la même valeur.

Surcharges

Equals(Decimal, Decimal)	Retourne une valeur indiquant si deux instances spécifiées de Decimal représentent la même valeur.
Equals(Decimal)	Retourne une valeur indiquant si cette instance et un objet Decimal spécifié représentent la même valeur.
Equals(Object)	Retourne une valeur indiquant si cette instance et une Object spécifiée représentent le même type et la même valeur.

Equals(Decimal, Decimal)

Source:: Decimal.cs

Source:: Decimal.cs

Source:: Decimal.cs

Retourne une valeur indiquant si deux instances spécifiées de Decimal représentent la même valeur.

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

Paramètres

d1: Decimal

Première valeur à comparer.

d2: Decimal

Deuxième valeur à comparer.

Retours

Boolean

true si d1 et d2 sont égaux ; sinon, false.

Exemples

L’exemple de code suivant compare plusieurs valeurs Decimal à une valeur de référence Decimal à l’aide de la méthode Equals statique.

// 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

Voir aussi

S’applique à

.NET 9 et autres versions

Produit	Versions
.NET	Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9
.NET Framework	1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
.NET Standard	1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1
UWP	10.0

Equals(Decimal)

Source:: Decimal.cs

Source:: Decimal.cs

Source:: Decimal.cs

Retourne une valeur indiquant si cette instance et un objet Decimal spécifié représentent la même valeur.

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

Paramètres

value: Decimal

Objet à comparer à cette instance.

Retours

Boolean

true si value est égal à cette instance ; sinon, false.

Implémente

Equals(T)

Remarques

Cette méthode implémente l’interface System.IEquatable<T> et fonctionne légèrement mieux que Equals, car elle n’a pas besoin de convertir le paramètre value en objet.

Si value a moins de bits (est plus étroit) que le type d’instance, certains langages de programmation effectuent une conversion étendue implicite qui transforme la valeur du paramètre en valeur avec plus de bits.

Par exemple, supposons que le type d’instance est Int32 et que le type de paramètre est Byte. Le compilateur Microsoft C# génère des instructions pour représenter la valeur du paramètre en tant qu’objet Int32, puis génère une méthode Int32.CompareTo pour comparer l’instance Int32 et la représentation des paramètres.

Consultez la documentation de votre langage de programmation pour déterminer si son compilateur effectue des conversions étendues implicites sur des types numériques.

Notes pour les appelants

La résolution de surcharge du compilateur peut tenir compte d’une différence apparente dans le comportement des deux surcharges de méthode Equals(Object). Si une conversion implicite entre l’argument value et un Decimal est définie et que l’argument n’est pas typé en tant que Object, les compilateurs peuvent effectuer une conversion implicite et appeler la méthode Equals(Decimal). Sinon, ils appellent la méthode Equals(Object), qui retourne toujours false si son argument value n’est pas une valeur Decimal. L’exemple suivant illustre la différence de comportement entre les deux surcharges de méthode. Dans le cas de tous les types intégraux primitifs, y compris les types signés et non signés, la première comparaison retourne true, car le compilateur effectue automatiquement une conversion étendue et appelle la méthode Equals(Decimal), tandis que la deuxième comparaison retourne false car le compilateur appelle la méthode Equals(Object).

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

Voir aussi

S’applique à

.NET 9 et autres versions

Produit	Versions
.NET	Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9
.NET Framework	2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
.NET Standard	1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1
UWP	10.0

Equals(Object)

Source:: Decimal.cs

Source:: Decimal.cs

Source:: Decimal.cs

Retourne une valeur indiquant si cette instance et une Object spécifiée représentent le même type et la même valeur.

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

Paramètres

value: Object

Objet à comparer à cette instance.

Retours

Boolean

true si value est un Decimal et égal à cette instance ; sinon, false.

Exemples

L’exemple de code suivant compare plusieurs Decimal et d’autres objets à une valeur de référence Decimal à l’aide de la méthode 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

Notes pour les appelants

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

Voir aussi

S’applique à

.NET 9 et autres versions

Produit	Versions
.NET	Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9
.NET Framework	1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
.NET Standard	1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1
UWP	10.0

Partager via

Decimal.Equals Méthode

Définition

Surcharges

Equals(Decimal, Decimal)

Paramètres

Retours

Exemples

Voir aussi

S’applique à

Equals(Decimal)

Paramètres

Retours

Implémente

Remarques

Notes pour les appelants

Voir aussi

S’applique à

Equals(Object)

Paramètres

Retours

Exemples

Notes pour les appelants

Voir aussi

S’applique à

Ressources supplémentaires