Decimal.Equals Decimal.Equals Decimal.Equals Decimal.Equals Method

Definition

Gibt einen Wert zurück, der angibt, ob zwei Instanzen der Decimal-Struktur denselben Wert darstellen.Returns a value indicating whether two instances of Decimal represent the same value.

Überlädt

Equals(Decimal) Equals(Decimal) Equals(Decimal) Equals(Decimal)

Gibt einen Wert zurück, der angibt, ob diese Instanz und ein angegebenes Decimal-Objekt den gleichen Wert darstellen.Returns a value indicating whether this instance and a specified Decimal object represent the same value.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Gibt einen Wert zurück, der angibt, ob diese Instanz und ein angegebenes Object denselben Typ und Wert darstellen.Returns a value indicating whether this instance and a specified Object represent the same type and value.

Equals(Decimal, Decimal) Equals(Decimal, Decimal) Equals(Decimal, Decimal) Equals(Decimal, Decimal)

Gibt einen Wert zurück, der angibt, ob zwei angegebene Instanzen von Decimal denselben Wert darstellen.Returns a value indicating whether two specified instances of Decimal represent the same value.

Equals(Decimal) Equals(Decimal) Equals(Decimal) Equals(Decimal)

Gibt einen Wert zurück, der angibt, ob diese Instanz und ein angegebenes Decimal-Objekt den gleichen Wert darstellen.Returns a value indicating whether this instance and a specified Decimal object represent the same value.

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

Parameter

value
Decimal Decimal Decimal Decimal

Ein mit dieser Instanz zu vergleichendes Objekt.An object to compare to this instance.

Gibt zurück

true, wenn value gleich dieser Instanz ist, andernfalls false.true if value is equal to this instance; otherwise, false.

Implementiert

Hinweise

Diese Methode implementiert die System.IEquatable<T> -Schnittstelle und führt etwas bessere Leistung als Equals , da es keine konvertieren die value Parameter für ein Objekt.This method implements the System.IEquatable<T> interface, and performs slightly better than Equals because it does not have to convert the value parameter to an object.

Wenn value weniger Bits aufweist (schmaler ist) als den Instanztyp führen einige Programmiersprachen eine implizite erweiternde Konvertierung, die den Wert des Parameters in einen Wert mit mehr Bits transformiert.If value has fewer bits (is narrower) than the instance type, some programming languages perform an implicit widening conversion that transforms the value of the parameter into a value with more bits.

Nehmen wir beispielsweise an, der Instanztyp Int32 und der Parametertyp ist Byte.For example, suppose the instance type is Int32 and the parameter type is Byte. Microsoft C#-Compiler generiert den Anweisungen, um den Wert des Parameters als darstellen einer Int32 Objekt und erstellt dann eine Int32.CompareTo -Methode zum Vergleichen der Int32 -Instanz und die Parameter-Darstellung.The Microsoft C# compiler generates instructions to represent the value of the parameter as an Int32 object, then generates a Int32.CompareTo method to compare the Int32 instance and parameter representation.

Ihre bevorzugte Programmiersprache Dokumentation, um festzustellen, ob der Compiler implizite erweiternde Konvertierungen für numerische Typen ausführt.Consult your programming language's documentation to determine whether its compiler performs implicit widening conversions on numeric types.

Hinweise für Aufrufer

Überladungsauflösung des Compiler möglicherweise einen offensichtlichen Unterschied im Verhalten der beiden berücksichtigen Equals(Object) Überladungen der Methode.Compiler overload resolution may account for an apparent difference in the behavior of the two Equals(Object) method overloads. Wenn eine implizite Konvertierung zwischen den obj Argument und ein Decimal definiert ist und das Argument als nicht typisiert ist ein Object, Compilern möglicherweise führen Sie eine implizite Konvertierung und rufen die Equals(Decimal) Methode.If an implicit conversion between the obj argument and a Decimal is defined and the argument is not typed as an Object, compilers may perform an implicit conversion and call the Equals(Decimal) method. Sie rufen Sie andernfalls die Equals(Object) Methode, die immer zurückgibt false wenn seine obj Argument ist keine Decimal Wert.Otherwise, they call the Equals(Object) method, which always returns false if its obj argument is not a Decimal value. Das folgende Beispiel veranschaulicht den Unterschied im Verhalten zwischen den zwei Überladungen.The following example illustrates the difference in behavior between the two method overloads. Im Fall von alle primitiven integralen Typen, einschließlich signiert und Typen ohne Vorzeichen, der erste Vergleich gibt true , da der Compiler automatisch eine erweiternde Konvertierung und ruft führt die Equals(Decimal) -Methode, während die zweite Vergleich gibt false , da der Compiler Ruft die Equals(Object) Methode.In the case of all primitive integral types, including both signed and unsigned types, the first comparison returns true because the compiler automatically performs a widening conversion and calls the Equals(Decimal) method, whereas the second comparison returns false because the compiler calls the Equals(Object) method.

[! Code-CsharpSystem.Decimal.Equals#2] [! Code – VbSystem.Decimal.Equals#2][!code-csharpSystem.Decimal.Equals#2] [!code-vbSystem.Decimal.Equals#2]

Siehe auch

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Gibt einen Wert zurück, der angibt, ob diese Instanz und ein angegebenes Object denselben Typ und Wert darstellen.Returns a value indicating whether this instance and a specified Object represent the same type and value.

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

Parameter

value
Object Object Object Object

Das Objekt, das mit dieser Instanz verglichen werden soll.The object to compare with this instance.

Gibt zurück

true, wenn value ein Decimal und gleich dieser Instanz ist, andernfalls false.true if value is a Decimal and equal to this instance; otherwise, false.

Beispiele

Im folgenden Codebeispiel wird vergleicht mehrere Decimal und andere Objekte auf einen Verweis Decimal -Wert mithilfe der Equals Methode.The following code example compares several Decimal and other objects to a reference Decimal value using the Equals method.

// 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.
Imports System
Imports Microsoft.VisualBasic

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

Hinweise für Aufrufer

Überladungsauflösung des Compiler möglicherweise einen offensichtlichen Unterschied im Verhalten der beiden berücksichtigen Equals(Object) Überladungen der Methode.Compiler overload resolution may account for an apparent difference in the behavior of the two Equals(Object) method overloads. Wenn eine implizite Konvertierung zwischen den obj Argument und ein Decimal definiert ist und das Argument als nicht typisiert ist ein Object, Compilern möglicherweise führen Sie eine implizite Konvertierung und rufen die Equals(Decimal) Methode.If an implicit conversion between the obj argument and a Decimal is defined and the argument is not typed as an Object, compilers may perform an implicit conversion and call the Equals(Decimal) method. Sie rufen Sie andernfalls die Equals(Object) Methode, die immer zurückgibt false wenn seine obj Argument ist keine Decimal Wert.Otherwise, they call the Equals(Object) method, which always returns false if its obj argument is not a Decimal value. Das folgende Beispiel veranschaulicht den Unterschied im Verhalten zwischen den zwei Überladungen.The following example illustrates the difference in behavior between the two method overloads. Im Fall von alle primitiven integralen Typen, einschließlich signiert und Typen ohne Vorzeichen, der erste Vergleich gibt true , da der Compiler automatisch eine erweiternde Konvertierung und ruft führt die Equals(Decimal) -Methode, während die zweite Vergleich gibt false , da der Compiler Ruft die Equals(Object) Methode.In the case of all primitive integral types, including both signed and unsigned types, the first comparison returns true because the compiler automatically performs a widening conversion and calls the Equals(Decimal) method, whereas the second comparison returns false because the compiler calls the Equals(Object) method.

[! Code-CsharpSystem.Decimal.Equals#2] [! Code – VbSystem.Decimal.Equals#2][!code-csharpSystem.Decimal.Equals#2] [!code-vbSystem.Decimal.Equals#2]

Siehe auch

Equals(Decimal, Decimal) Equals(Decimal, Decimal) Equals(Decimal, Decimal) Equals(Decimal, Decimal)

Gibt einen Wert zurück, der angibt, ob zwei angegebene Instanzen von Decimal denselben Wert darstellen.Returns a value indicating whether two specified instances of Decimal represent the same value.

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

Parameter

d1
Decimal Decimal Decimal Decimal

Der erste zu vergleichende Wert.The first value to compare.

d2
Decimal Decimal Decimal Decimal

Der zweite zu vergleichende Wert.The second value to compare.

Gibt zurück

true, wenn d1 und d2 gleich sind, andernfalls false.true if d1 and d2 are equal; otherwise, false.

Beispiele

Im folgenden Codebeispiel wird vergleicht mehrere Decimal Werte einen Verweis Decimal mithilfe der statischen Equals Methode.The following code example compares several Decimal values to a reference Decimal value using the static Equals method.

// 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.
Imports System
Imports Microsoft.VisualBasic

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
Siehe auch

Gilt für: