Decimal.CompareTo 메서드
정의
중요
일부 정보는 릴리스되기 전에 상당 부분 수정될 수 있는 시험판 제품과 관련이 있습니다. Microsoft는 여기에 제공된 정보에 대해 어떠한 명시적이거나 묵시적인 보증도 하지 않습니다.
이 인스턴스를 지정된 개체나 Decimal와 비교하여 상대 값의 표시를 반환합니다.
오버로드
| CompareTo(Decimal) |
이 인스턴스를 지정된 Decimal 개체와 비교하여 상대 값의 비교를 반환합니다. |
| CompareTo(Object) |
이 인스턴스를 지정된 개체와 비교하여 상대 값의 비교를 반환합니다. |
CompareTo(Decimal)
- Source:
- Decimal.cs
- Source:
- Decimal.cs
- Source:
- Decimal.cs
이 인스턴스를 지정된 Decimal 개체와 비교하여 상대 값의 비교를 반환합니다.
public:
virtual int CompareTo(System::Decimal value);public int CompareTo (decimal value);abstract member CompareTo : decimal -> int
override this.CompareTo : decimal -> intPublic Function CompareTo (value As Decimal) As Integer매개 변수
- value
- Decimal
이 인스턴스와 비교할 개체입니다.
반환
이 인스턴스와 value의 상대 값을 나타내는 부호 있는 숫자입니다.
| 반환 값 | 의미 |
|---|---|
| 0보다 작음 | 이 인스턴스는 value보다 작습니다.
|
| 0 | 이 인스턴스가 value과 같은 경우
|
| 0보다 큼 | 이 인스턴스는 value보다 큽니다.
|
구현
예제
다음 코드 예제에서는 여러 값 및 참조 형식에 대 한 메서드의 CompareTo 제네릭 및 비일반 버전을 보여 줍니다.
// This example demonstrates the two versions of the
// CompareTo method for several base types.
// The general version takes a parameter of type Object, while the specific
// version takes a type-specific parameter, such as Boolean, Int32, or Double.
using namespace System;
void Show( String^ caption, Object^ var1, Object^ var2, int resultGeneric, int resultNonGeneric )
{
String^ relation;
Console::Write( caption );
if ( resultGeneric == resultNonGeneric )
{
if ( resultGeneric < 0 )
relation = "less than";
else
if ( resultGeneric > 0 )
relation = "greater than";
else
relation = "equal to";
Console::WriteLine( "{0} is {1} {2}", var1, relation, var2 );
}
// The following condition will never occur because the generic and non-generic
// CompareTo methods are equivalent.
else
{
Console::WriteLine( "Generic CompareTo = {0}; non-generic CompareTo = {1}", resultGeneric, resultNonGeneric );
}
}
int main()
{
String^ nl = Environment::NewLine;
String^ msg = "{0}The following is the result of using the generic and non-generic{0}"
"versions of the CompareTo method for several base types:{0}";
Object^ obj; // An Object used to insure CompareTo(Object) is called.
DateTime now = DateTime::Now;
// Time span = 11 days, 22 hours, 33 minutes, 44 seconds
TimeSpan tsX = TimeSpan(11,22,33,44);
// Version = 1.2.333.4
Version^ versX = gcnew Version( "1.2.333.4" );
// Guid = CA761232-ED42-11CE-BACD-00AA0057B223
Guid guidX = Guid( "{CA761232-ED42-11CE-BACD-00AA0057B223}");
Boolean a1 = true,a2 = true;
Byte b1 = 1,b2 = 1;
Int16 c1 = -2,c2 = 2;
Int32 d1 = 3,d2 = 3;
Int64 e1 = 4,e2 = -4;
Decimal f1 = Decimal(-5.5), f2 = Decimal(5.5);
Single g1 = 6.6f,g2 = 6.6f;
Double h1 = 7.7,h2 = -7.7;
Char i1 = 'A',i2 = 'A';
String^ j1 = "abc", ^j2 = "abc";
DateTime k1 = now,k2 = now;
TimeSpan l1 = tsX,l2 = tsX;
Version^ m1 = versX, ^m2 = gcnew Version( "2.0" );
Guid n1 = guidX,n2 = guidX;
// The following types are not CLS-compliant.
SByte w1 = 8,w2 = 8;
UInt16 x1 = 9,x2 = 9;
UInt32 y1 = 10,y2 = 10;
UInt64 z1 = 11,z2 = 11;
//
Console::WriteLine( msg, nl );
try
{
Show( "Boolean: ", a1, a2, a1.CompareTo( a2 ), a1.CompareTo( a2 ) );
Show( "Byte: ", b1, b2, b1.CompareTo( b2 ), b1.CompareTo( b2 ) );
Show( "Int16: ", c1, c2, c1.CompareTo( c2 ), c1.CompareTo( c2 ) );
Show( "Int32: ", d1, d2, d1.CompareTo( d2 ), d1.CompareTo( d2 ) );
Show( "Int64: ", e1, e2, e1.CompareTo( e2 ), e1.CompareTo( e2 ) );
Show( "Decimal: ", f1, f2, f1.CompareTo( f2 ), f1.CompareTo( f2 ) );
Show( "Single: ", g1, g2, g1.CompareTo( g2 ), g1.CompareTo( g2 ) );
Show( "Double: ", h1, h2, h1.CompareTo( h2 ), h1.CompareTo( h2 ) );
Show( "Char: ", i1, i2, i1.CompareTo( i2 ), i1.CompareTo( i2 ) );
// Use an anonymous object to hide the String object.
obj = j2;
Show( "String: ", j1, j2, j1->CompareTo( j2 ), j1->CompareTo( obj ) );
Show( "DateTime:", k1, k2, k1.CompareTo( k2 ), k1.CompareTo( k2 ) );
Show( "TimeSpan: ", l1, l2, l1.CompareTo( l2 ), l1.CompareTo( l2 ) );
// Use an anonymous object to hide the Version object.
obj = m2;
Show( "Version: ", m1, m2, m1->CompareTo( m2 ), m1->CompareTo( obj ) );
Show( "Guid: ", n1, n2, n1.CompareTo( n2 ), n1.CompareTo( n2 ) );
//
Console::WriteLine( "{0}The following types are not CLS-compliant:", nl );
Show( "SByte: ", w1, w2, w1.CompareTo( w2 ), w1.CompareTo( w2 ) );
Show( "UInt16: ", x1, x2, x1.CompareTo( x2 ), x1.CompareTo( x2 ) );
Show( "UInt32: ", y1, y2, y1.CompareTo( y2 ), y1.CompareTo( y2 ) );
Show( "UInt64: ", z1, z2, z1.CompareTo( z2 ), z1.CompareTo( z2 ) );
}
catch ( Exception^ e )
{
Console::WriteLine( e );
}
}
// This example displays the following output:
//
// The following is the result of using the generic and non-generic versions of the
// CompareTo method for several base types:
//
// Boolean: True is equal to True
// Byte: 1 is equal to 1
// Int16: -2 is less than 2
// Int32: 3 is equal to 3
// Int64: 4 is greater than -4
// Decimal: -5.5 is less than 5.5
// Single: 6.6 is equal to 6.6
// Double: 7.7 is greater than -7.7
// Char: A is equal to A
// String: abc is equal to abc
// DateTime: 12/1/2003 5:37:46 PM is equal to 12/1/2003 5:37:46 PM
// TimeSpan: 11.22:33:44 is equal to 11.22:33:44
// Version: 1.2.333.4 is less than 2.0
// Guid: ca761232-ed42-11ce-bacd-00aa0057b223 is equal to ca761232-ed42-11ce-bacd-00
// aa0057b223
//
// The following types are not CLS-compliant:
// SByte: 8 is equal to 8
// UInt16: 9 is equal to 9
// UInt32: 10 is equal to 10
// UInt64: 11 is equal to 11
// This example demonstrates the generic and non-generic versions of the
// CompareTo method for several base types.
// The non-generic version takes a parameter of type Object, while the generic
// version takes a type-specific parameter, such as Boolean, Int32, or Double.
using System;
class Sample
{
public static void Main()
{
string nl = Environment.NewLine;
string msg = "{0}The following is the result of using the generic and non-generic{0}" +
"versions of the CompareTo method for several base types:{0}";
DateTime now = DateTime.Now;
// Time span = 11 days, 22 hours, 33 minutes, 44 seconds
TimeSpan tsX = new TimeSpan(11, 22, 33, 44);
// Version = 1.2.333.4
Version versX = new Version("1.2.333.4");
// Guid = CA761232-ED42-11CE-BACD-00AA0057B223
Guid guidX = new Guid("{CA761232-ED42-11CE-BACD-00AA0057B223}");
Boolean a1 = true, a2 = true;
Byte b1 = 1, b2 = 1;
Int16 c1 = -2, c2 = 2;
Int32 d1 = 3, d2 = 3;
Int64 e1 = 4, e2 = -4;
Decimal f1 = -5.5m, f2 = 5.5m;
Single g1 = 6.6f, g2 = 6.6f;
Double h1 = 7.7d, h2 = -7.7d;
Char i1 = 'A', i2 = 'A';
String j1 = "abc", j2 = "abc";
DateTime k1 = now, k2 = now;
TimeSpan l1 = tsX, l2 = tsX;
Version m1 = versX, m2 = new Version("2.0");
Guid n1 = guidX, n2 = guidX;
// The following types are not CLS-compliant.
SByte w1 = 8, w2 = 8;
UInt16 x1 = 9, x2 = 9;
UInt32 y1 = 10, y2 = 10;
UInt64 z1 = 11, z2 = 11;
//
Console.WriteLine(msg, nl);
try
{
// The second and third Show method call parameters are automatically boxed because
// the second and third Show method declaration arguments expect type Object.
Show("Boolean: ", a1, a2, a1.CompareTo(a2), a1.CompareTo((Object)a2));
Show("Byte: ", b1, b2, b1.CompareTo(b2), b1.CompareTo((Object)b2));
Show("Int16: ", c1, c2, c1.CompareTo(c2), c1.CompareTo((Object)c2));
Show("Int32: ", d1, d2, d1.CompareTo(d2), d1.CompareTo((Object)d2));
Show("Int64: ", e1, e2, e1.CompareTo(e2), e1.CompareTo((Object)e2));
Show("Decimal: ", f1, f2, f1.CompareTo(f2), f1.CompareTo((Object)f2));
Show("Single: ", g1, g2, g1.CompareTo(g2), g1.CompareTo((Object)g2));
Show("Double: ", h1, h2, h1.CompareTo(h2), h1.CompareTo((Object)h2));
Show("Char: ", i1, i2, i1.CompareTo(i2), i1.CompareTo((Object)i2));
Show("String: ", j1, j2, j1.CompareTo(j2), j1.CompareTo((Object)j2));
Show("DateTime: ", k1, k2, k1.CompareTo(k2), k1.CompareTo((Object)k2));
Show("TimeSpan: ", l1, l2, l1.CompareTo(l2), l1.CompareTo((Object)l2));
Show("Version: ", m1, m2, m1.CompareTo(m2), m1.CompareTo((Object)m2));
Show("Guid: ", n1, n2, n1.CompareTo(n2), n1.CompareTo((Object)n2));
//
Console.WriteLine("{0}The following types are not CLS-compliant:", nl);
Show("SByte: ", w1, w2, w1.CompareTo(w2), w1.CompareTo((Object)w2));
Show("UInt16: ", x1, x2, x1.CompareTo(x2), x1.CompareTo((Object)x2));
Show("UInt32: ", y1, y2, y1.CompareTo(y2), y1.CompareTo((Object)y2));
Show("UInt64: ", z1, z2, z1.CompareTo(z2), z1.CompareTo((Object)z2));
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
public static void Show(string caption, Object var1, Object var2,
int resultGeneric, int resultNonGeneric)
{
string relation;
Console.Write(caption);
if (resultGeneric == resultNonGeneric)
{
if (resultGeneric < 0) relation = "less than";
else if (resultGeneric > 0) relation = "greater than";
else relation = "equal to";
Console.WriteLine("{0} is {1} {2}", var1, relation, var2);
}
// The following condition will never occur because the generic and non-generic
// CompareTo methods are equivalent.
else
{
Console.WriteLine("Generic CompareTo = {0}; non-generic CompareTo = {1}",
resultGeneric, resultNonGeneric);
}
}
}
/*
This example produces the following results:
The following is the result of using the generic and non-generic versions of the
CompareTo method for several base types:
Boolean: True is equal to True
Byte: 1 is equal to 1
Int16: -2 is less than 2
Int32: 3 is equal to 3
Int64: 4 is greater than -4
Decimal: -5.5 is less than 5.5
Single: 6.6 is equal to 6.6
Double: 7.7 is greater than -7.7
Char: A is equal to A
String: abc is equal to abc
DateTime: 12/1/2003 5:37:46 PM is equal to 12/1/2003 5:37:46 PM
TimeSpan: 11.22:33:44 is equal to 11.22:33:44
Version: 1.2.333.4 is less than 2.0
Guid: ca761232-ed42-11ce-bacd-00aa0057b223 is equal to ca761232-ed42-11ce-bacd-00
aa0057b223
The following types are not CLS-compliant:
SByte: 8 is equal to 8
UInt16: 9 is equal to 9
UInt32: 10 is equal to 10
UInt64: 11 is equal to 11
*/
' This example demonstrates the generic and non-generic versions of the
' CompareTo method for several base types.
' The non-generic version takes a parameter of type Object, while the generic
' version takes a type-specific parameter, such as Boolean, Int32, or Double.
Class Sample
Public Shared Sub Main()
Dim nl As String = Environment.NewLine
Dim msg As String = _
"{0}The following is the result of using the generic and non-generic{0}" & _
"versions of the CompareTo method for several base types:{0}"
Dim now As DateTime = DateTime.Now
' Time span = 11 days, 22 hours, 33 minutes, 44 seconds
Dim tsX As New TimeSpan(11, 22, 33, 44)
' Version = 1.2.333.4
Dim versX As New Version("1.2.333.4")
' Guid = CA761232-ED42-11CE-BACD-00AA0057B223
Dim guidX As New Guid("{CA761232-ED42-11CE-BACD-00AA0057B223}")
Dim a1 As [Boolean] = True, a2 As [Boolean] = True
Dim b1 As [Byte] = 1, b2 As [Byte] = 1
Dim c1 As Int16 = -2, c2 As Int16 = 2
Dim d1 As Int32 = 3, d2 As Int32 = 3
Dim e1 As Int64 = 4, e2 As Int64 = -4
Dim f1 As [Decimal] = -5.5D, f2 As [Decimal] = 5.5D
Dim g1 As [Single] = 6.6F, g2 As [Single] = 6.6F
Dim h1 As [Double] = 7.7, h2 As [Double] = -7.7
Dim i1 As [Char] = "A"c, i2 As [Char] = "A"c
Dim j1 As String = "abc", j2 As String = "abc"
Dim k1 As DateTime = now, k2 As DateTime = now
Dim l1 As TimeSpan = tsX, l2 As TimeSpan = tsX
Dim m1 As Version = versX, m2 As New Version("2.0")
Dim n1 As Guid = guidX, n2 As Guid = guidX
' The following types are not CLS-compliant.
' SByte, UInt16, UInt32, UInt64
Console.WriteLine(msg, nl)
Try
' The second and third Show method call parameters are automatically boxed because
' the second and third Show method declaration arguments expect type Object.
Show("Boolean: ", a1, a2, a1.CompareTo(a2), a1.CompareTo(CObj(a2)))
Show("Byte: ", b1, b2, b1.CompareTo(b2), b1.CompareTo(CObj(b2)))
Show("Int16: ", c1, c2, c1.CompareTo(c2), c1.CompareTo(CObj(c2)))
Show("Int32: ", d1, d2, d1.CompareTo(d2), d1.CompareTo(CObj(d2)))
Show("Int64: ", e1, e2, e1.CompareTo(e2), e1.CompareTo(CObj(e2)))
Show("Decimal: ", f1, f2, f1.CompareTo(f2), f1.CompareTo(CObj(f2)))
Show("Single: ", g1, g2, g1.CompareTo(g2), g1.CompareTo(CObj(g2)))
Show("Double: ", h1, h2, h1.CompareTo(h2), h1.CompareTo(CObj(h2)))
Show("Char: ", i1, i2, i1.CompareTo(i2), i1.CompareTo(CObj(i2)))
Show("String: ", j1, j2, j1.CompareTo(j2), j1.CompareTo(CObj(j2)))
Show("DateTime: ", k1, k2, k1.CompareTo(k2), k1.CompareTo(CObj(k2)))
Show("TimeSpan: ", l1, l2, l1.CompareTo(l2), l1.CompareTo(CObj(l2)))
Show("Version: ", m1, m2, m1.CompareTo(m2), m1.CompareTo(CObj(m2)))
Show("Guid: ", n1, n2, n1.CompareTo(n2), n1.CompareTo(CObj(n2)))
'
Console.WriteLine("{0}The following types are not CLS-compliant:", nl)
Console.WriteLine("SByte, UInt16, UInt32, UInt64")
Catch e As Exception
Console.WriteLine(e)
End Try
End Sub
Public Shared Sub Show(caption As String, var1 As [Object], var2 As [Object], _
resultGeneric As Integer, resultNonGeneric As Integer)
Dim relation As String
Console.Write(caption)
If resultGeneric = resultNonGeneric Then
If resultGeneric < 0 Then
relation = "less than"
ElseIf resultGeneric > 0 Then
relation = "greater than"
Else
relation = "equal to"
End If
Console.WriteLine("{0} is {1} {2}", var1, relation, var2)
' The following condition will never occur because the generic and non-generic
' CompareTo methods are equivalent.
Else
Console.WriteLine("Generic CompareTo = {0}; non-generic CompareTo = {1}", _
resultGeneric, resultNonGeneric)
End If
End Sub
End Class
'
'This example produces the following results:
'
'The following is the result of using the generic and non-generic versions of the
'CompareTo method for several base types:
'
'Boolean: True is equal to True
'Byte: 1 is equal to 1
'Int16: -2 is less than 2
'Int32: 3 is equal to 3
'Int64: 4 is greater than -4
'Decimal: -5.5 is less than 5.5
'Single: 6.6 is equal to 6.6
'Double: 7.7 is greater than -7.7
'Char: A is equal to A
'String: abc is equal to abc
'DateTime: 12/1/2003 5:37:46 PM is equal to 12/1/2003 5:37:46 PM
'TimeSpan: 11.22:33:44 is equal to 11.22:33:44
'Version: 1.2.333.4 is less than 2.0
'Guid: ca761232-ed42-11ce-bacd-00aa0057b223 is equal to ca761232-ed42-11ce-bacd-00
'aa0057b223
'
'The following types are not CLS-compliant:
'SByte, UInt16, UInt32, UInt64
'
설명
이 메서드는 인터페이스를 System.IComparable<T> 구현하고 매개 변수를 개체로 변환 value 할 필요가 없으므로 메서드보다 Decimal.CompareTo 약간 더 잘 수행됩니다.
프로그래밍 언어에 따라 매개 변수 형식에 인스턴스 형식보다 적은 비트(더 좁은)가 있는 메서드를 코딩 CompareTo 할 수 있습니다. 일부 프로그래밍 언어는 인스턴스만큼 비트가 많은 형식으로 매개 변수를 나타내는 암시적 확대 변환을 수행하기 때문에 가능합니다.
예를 들어 인스턴스 형식이 이 Int32 고 매개 변수 형식이 인 경우를 가정해 Byte보겠습니다. Microsoft C# 컴파일러는 매개 변수를 개체로 Int32 나타내는 지침을 생성한 다음 인스턴스의 값 Int32 과 매개 변수 표현을 비교하는 메서드를 Int32 생성 Int32.CompareTo 합니다.
프로그래밍 언어의 설명서를 참조하여 컴파일러가 숫자 형식에서 암시적 확대 변환을 수행하는지 여부를 확인합니다.
추가 정보
적용 대상
CompareTo(Object)
- Source:
- Decimal.cs
- Source:
- Decimal.cs
- Source:
- Decimal.cs
이 인스턴스를 지정된 개체와 비교하여 상대 값의 비교를 반환합니다.
public:
virtual int CompareTo(System::Object ^ value);public int CompareTo (object? value);public int CompareTo (object value);abstract member CompareTo : obj -> int
override this.CompareTo : obj -> intPublic Function CompareTo (value As Object) As Integer매개 변수
- value
- Object
이 인스턴스와 비교할 개체 또는 null입니다.
반환
이 인스턴스와 value의 상대 값을 나타내는 부호 있는 숫자입니다.
| 반환 값 | 의미 |
|---|---|
| 0보다 작음 | 이 인스턴스는 value보다 작습니다.
|
| 0 | 이 인스턴스가 value과 같은 경우
|
| 0보다 큼 | 이 인스턴스는 value보다 크거나 value가 null입니다.
|
구현
예외
value이(가) Decimal가 아닌 경우
예제
다음 코드 예제에서는 메서드를 사용 하 여 참조 Decimal 값에 여러 개체 Decimal 와 다른 개체를 CompareTo 비교 합니다.
// 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
설명
의 모든 인스턴스는 Decimal값에 관계없이 보다 null큰 것으로 간주됩니다.
매개 변수 value 는 또는 인스턴스Decimal여야 null 합니다. 그렇지 않으면 예외가 throw됩니다.
추가 정보
적용 대상
GitHub에서 Microsoft와 공동 작업
이 콘텐츠의 원본은 GitHub에서 찾을 수 있으며, 여기서 문제와 끌어오기 요청을 만들고 검토할 수도 있습니다. 자세한 내용은 참여자 가이드를 참조하세요.
.NET
피드백
출시 예정: 2024년 내내 콘텐츠에 대한 피드백 메커니즘으로 GitHub 문제를 단계적으로 폐지하고 이를 새로운 피드백 시스템으로 바꿀 예정입니다. 자세한 내용은 다음을 참조하세요. https://aka.ms/ContentUserFeedback
다음에 대한 사용자 의견 제출 및 보기