String.CompareTo 方法
定義
重要
部分資訊涉及發行前產品，在發行之前可能會有大幅修改。 Microsoft 對此處提供的資訊，不做任何明確或隱含的瑕疵擔保。
多載
| CompareTo(String) |
比較這個執行個體與指定的 String 物件，並且表示這個執行個體在排序次序中，位於所指定字串之前、之後或相同位置。 |
| CompareTo(Object) |
比較這個執行個體與指定的 Object，並且指出這個執行個體在排序次序中，位於所指定 Object 之前、之後或相同位置。 |
備註
方法的兩個 CompareTo 多載都會執行區分文化特性和區分大小寫的比較。 您無法使用這個方法來執行不區分文化特性或序數比較。 為了清楚瞭解程式碼，建議您避免 CompareTo 方法，並改為呼叫 Compare 方法。
CompareTo(String)
比較這個執行個體與指定的 String 物件，並且表示這個執行個體在排序次序中，位於所指定字串之前、之後或相同位置。
public:
virtual int CompareTo(System::String ^ strB);public:
int CompareTo(System::String ^ strB);public int CompareTo (string strB);public int CompareTo (string? strB);abstract member CompareTo : string -> int
override this.CompareTo : string -> intmember this.CompareTo : string -> intPublic Function CompareTo (strB As String) As Integer參數
- strB
- String
要和這個執行個體比較的字串。
傳回
32 位元帶正負號的整數，指出這個執行個體在排序次序中，位於 strB 參數之前、之後或相同位置。
| 值 | 條件 |
|---|---|
| 小於零 | 這個執行個體位於 strB 之前。
|
| 零 | 這個執行個體在排序次序中的位置與 strB 相同。
|
| 大於零 | 這個執行個體位於 strB 之後。
-或-
|
實作
範例
下列範例會 CompareTo 使用 方法來比較目前的字串實例與其他字串。
using namespace System;
String^ CompareStrings(String^ str1, String^ str2)
{
// compare the values, using the CompareTo method on the first string
int cmpVal = str1->CompareTo(str2);
if (cmpVal == 0)
// the values are the same
return "The strings occur in the same position in the sort order.";
else if (cmpVal < 0)
return "The first string precedes the second in the sort order.";
else
return "The first string follows the second in the sort order.";
}
int main()
{
String^ strFirst = "Goodbye";
String^ strSecond = "Hello";
String^ strThird = "a small String*";
String^ strFourth = "goodbye";
// Compare a string to itself.
Console::WriteLine(CompareStrings(strFirst, strFirst));
Console::WriteLine(CompareStrings(strFirst, strSecond));
Console::WriteLine(CompareStrings(strFirst, strThird));
// Compare a string to another string that varies only by case.
Console::WriteLine(CompareStrings(strFirst, strFourth));
Console::WriteLine(CompareStrings(strFourth, strFirst));
}
// The example displays the following output:
// The strings occur in the same position in the sort order.
// The first string precedes the second in the sort order.
// The first string follows the second in the sort order.
// The first string follows the second in the sort order.
// The first string precedes the second in the sort order.
using System;
public class Example
{
public static void Main()
{
string strFirst = "Goodbye";
string strSecond = "Hello";
string strThird = "a small string";
string strFourth = "goodbye";
// Compare a string to itself.
Console.WriteLine(CompareStrings(strFirst, strFirst));
Console.WriteLine(CompareStrings(strFirst, strSecond));
Console.WriteLine(CompareStrings(strFirst, strThird));
// Compare a string to another string that varies only by case.
Console.WriteLine(CompareStrings(strFirst, strFourth));
Console.WriteLine(CompareStrings(strFourth, strFirst));
}
private static string CompareStrings( string str1, string str2 )
{
// Compare the values, using the CompareTo method on the first string.
int cmpVal = str1.CompareTo(str2);
if (cmpVal == 0) // The strings are the same.
return "The strings occur in the same position in the sort order.";
else if (cmpVal < 0)
return "The first string precedes the second in the sort order.";
else
return "The first string follows the second in the sort order.";
}
}
// The example displays the following output:
// The strings occur in the same position in the sort order.
// The first string precedes the second in the sort order.
// The first string follows the second in the sort order.
// The first string follows the second in the sort order.
// The first string precedes the second in the sort order.
let strFirst = "Goodbye"
let strSecond = "Hello"
let strThird = "a small string"
let strFourth = "goodbye"
let compareStrings (str1: string) str2 =
// Compare the values, using the CompareTo method on the first string.
match str1.CompareTo str2 with
| 0 -> // The strings are the same.
"The strings occur in the same position in the sort order."
| x when x < 0 ->
"The first string precedes the second in the sort order."
| _ ->
"The first string follows the second in the sort order."
// Compare a string to itself.
printfn $"{compareStrings strFirst strFirst}"
printfn $"{compareStrings strFirst strSecond}"
printfn $"{compareStrings strFirst strThird}"
// Compare a string to another string that varies only by case.
printfn $"{compareStrings strFirst strFourth}"
printfn $"{compareStrings strFourth strFirst}"
// The example displays the following output:
// The strings occur in the same position in the sort order.
// The first string precedes the second in the sort order.
// The first string follows the second in the sort order.
// The first string follows the second in the sort order.
// The first string precedes the second in the sort order.
Public Module Example
Public Sub Main()
Dim strFirst As String = "Goodbye"
Dim strSecond As String = "Hello"
Dim strThird As String = "a small string"
Dim strFourth As String = "goodbye"
' Compare a string to itself.
Console.WriteLine(CompareStrings(strFirst, strFirst))
Console.WriteLine(CompareStrings(strFirst, strSecond))
Console.WriteLine(CompareStrings(strFirst, strThird))
' Compare a string to another string that varies only by case.
Console.WriteLine(CompareStrings(strFirst, strFourth))
Console.WriteLine(CompareStrings(strFourth, strFirst))
End Sub
Private Function CompareStrings(str1 As String, str2 As String) As String
Dim cmpVal As Integer = str1.CompareTo(str2)
If cmpVal = 0 Then
' The values are the same.
Return "The strings occur in the same position in the sort order."
ElseIf cmpVal < 0 Then
Return "The first string precedes the second in the sort order."
Else
Return "The first string follows the second in the sort order."
End If
End Function
End Module
' This example displays the following output:
' The strings occur in the same position in the sort order.
' The strings occur in the same position in the sort order.
' The first string precedes the second in the sort order.
' The first string follows the second in the sort order.
' The first string follows the second in the sort order.
' The first string precedes the second in the sort order.
下列範例示範數個值和參考類型的 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.
open System
let show caption (var1: obj) (var2: obj) resultGeneric resultNonGeneric =
printf "%s" caption
if resultGeneric = resultNonGeneric then
let relation =
if resultGeneric < 0 then "less than"
elif resultGeneric > 0 then "greater than"
else "equal to"
printfn $"{var1} is {relation} {var2}"
// The following condition will never occur because the generic and non-generic
// CompareTo methods are equivalent.
else
printfn $"Generic CompareTo = {resultGeneric} non-generic CompareTo = {resultNonGeneric}"
let now = DateTime.Now
// Time span = 11 days, 22 hours, 33 minutes, 44 seconds
let tsX = TimeSpan(11, 22, 33, 44)
// Version = 1.2.333.4
let versX = Version "1.2.333.4"
// Guid = CA761232-ED42-11CE-BACD-00AA0057B223
let guidX = Guid "{CA761232-ED42-11CE-BACD-00AA0057B223}"
let a1, a2 = true, true
let b1, b2 = 1uy, 1uy
let c1, c2 = -2s, 2s
let d1, d2 = 3, 3
let e1, e2 = 4L, -4L
let f1, f2 = -5.5m, 5.5m
let g1, g2 = 6.6f, 6.6f
let h1, h2 = 7.7, -7.7
let i1, i2 = 'A', 'A'
let j1, j2 = "abc", "abc"
let k1, k2 = now, now
let l1, l2 = tsX, tsX
let m1, m2 = versX, Version "2.0"
let n1, n2 = guidX, guidX
// The following types are not CLS-compliant.
let w1, w2 = 8y, 8y
let x1, x2 = 9us, 9us
let y1, y2 = 10u, 10u
let z1, z2 = 11uL, 11uL
printfn "\nThe following is the result of using the generic and non-generic\nversions of the CompareTo method for several base types:\n"
try
// The second and third show function call parameters are automatically boxed because
// the second and third show function declaration arguments expect type Object.
show "Boolean: " a1 a2 (a1.CompareTo a2) (a1.CompareTo (a2 :> obj))
show "Byte: " b1 b2 (b1.CompareTo b2) (b1.CompareTo (b2 :> obj))
show "Int16: " c1 c2 (c1.CompareTo c2) (c1.CompareTo (c2 :> obj))
show "Int32: " d1 d2 (d1.CompareTo d2) (d1.CompareTo (d2 :> obj))
show "Int64: " e1 e2 (e1.CompareTo e2) (e1.CompareTo (e2 :> obj))
show "Decimal: " f1 f2 (f1.CompareTo f2) (f1.CompareTo (f2 :> obj))
show "Single: " g1 g2 (g1.CompareTo g2) (g1.CompareTo (g2 :> obj))
show "Double: " h1 h2 (h1.CompareTo h2) (h1.CompareTo (h2 :> obj))
show "Char: " i1 i2 (i1.CompareTo i2) (i1.CompareTo (i2 :> obj))
show "String: " j1 j2 (j1.CompareTo j2) (j1.CompareTo (j2 :> obj))
show "DateTime: " k1 k2 (k1.CompareTo k2) (k1.CompareTo (k2 :> obj))
show "TimeSpan: " l1 l2 (l1.CompareTo l2) (l1.CompareTo (l2 :> obj))
show "Version: " m1 m2 (m1.CompareTo m2) (m1.CompareTo (m2 :> obj))
show "Guid: " n1 n2 (n1.CompareTo n2) (n1.CompareTo (n2 :> obj))
printfn "\nThe following types are not CLS-compliant:"
show "SByte: " w1 w2 (w1.CompareTo w2) (w1.CompareTo (w2 :> obj))
show "UInt16: " x1 x2 (x1.CompareTo x2) (x1.CompareTo (x2 :> obj))
show "UInt32: " y1 y2 (y1.CompareTo y2) (y1.CompareTo (y2 :> obj))
show "UInt64: " z1 z2 (z1.CompareTo z2) (z1.CompareTo (z2 :> obj))
with e -> printfn $"{e}"
// 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.Globalization.CompareOptions 。
如需此方法行為的詳細資訊，請參閱 方法的一 Compare(String, String) 節。
這個方法會實作 System.IComparable<T> 介面並執行比 方法稍微好 String.CompareTo(Object) 一點，因為它不需要判斷引數是否 strB 為必須 Boxed 的可變實值型別，而且不需要將其參數從 ObjectString 轉換成 。
給呼叫者的注意事項
字元集包含可忽略的字元。 方法 CompareTo(String) 在執行區分文化特性的比較時，不會考慮這類字元。 例如，如果下列程式碼是在.NET Framework 4 或更新版本上執行，則使用軟連字號或 U+00AD) 表示這兩個字串相等的「動物」 與 「ani-mal」 (比較。
using System;
public class Example
{
public static void Main()
{
string s1 = "ani\u00ADmal";
string s2 = "animal";
Console.WriteLine("Comparison of '{0}' and '{1}': {2}",
s1, s2, s1.CompareTo(s2));
}
}
// The example displays the following output:
// Comparison of 'ani-mal' and 'animal': 0
let s1 = "ani\u00ADmal"
let s2 = "animal"
printfn $"Comparison of '{s1}' and '{s2}': {s1.CompareTo s2}"
// The example displays the following output:
// Comparison of 'ani-mal' and 'animal': 0
Module Example
Public Sub Main()
Dim s1 As String = "ani" + ChrW(&h00AD) + "mal"
Dim s2 As String = "animal"
Console.WriteLine("Comparison of '{0}' and '{1}': {2}",
s1, s2, s1.CompareTo(s2))
End Sub
End Module
' The example displays the following output:
' Comparison of 'ani-mal' and 'animal': 0
若要辨識字串比較中的可忽略字元，請呼叫 CompareOrdinal(String, String) 方法。
另請參閱
適用於
CompareTo(Object)
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參數
傳回
32 位元帶正負號的整數，指出這個執行個體在排序次序中，位於 value 參數之前、之後或相同位置。
| 值 | 條件 |
|---|---|
| 小於零 | 這個執行個體位於 value 之前。
|
| 零 | 這個執行個體在排序次序中的位置與 value 相同。
|
| 大於零 | 這個執行個體位於 value 之後。
-或-
|
實作
例外狀況
value 不是 String。
範例
下列範例使用 CompareTo 方法搭配 Object 。 因為它嘗試比較 String 實例與 TestClass 物件，所以 方法會 ArgumentException 擲回 。
using namespace System;
public ref class TestClass{};
int main()
{
TestClass^ test = gcnew TestClass;
array<Object^>^ objectsToCompare = { test, test->ToString(), 123,
(123).ToString(), "some text",
"Some Text" };
String^ s = "some text";
for each (Object^ objectToCompare in objectsToCompare) {
try {
Int32 i = s->CompareTo(objectToCompare);
Console::WriteLine("Comparing '{0}' with '{1}': {2}",
s, objectToCompare, i);
}
catch (ArgumentException^ e) {
Console::WriteLine("Bad argument: {0} (type {1})",
objectToCompare,
objectToCompare->GetType()->Name);
}
}
}
// The example displays the following output:
// Bad argument: TestClass (type TestClass)
// Comparing 'some text' with 'TestClass': -1
// Bad argument: 123 (type Int32)
// Comparing 'some text' with '123': 1
// Comparing 'some text' with 'some text': 0
// Comparing 'some text' with 'Some Text': -1
using System;
public class TestClass
{}
public class Example
{
public static void Main()
{
var test = new TestClass();
Object[] objectsToCompare = { test, test.ToString(), 123,
123.ToString(), "some text",
"Some Text" };
string s = "some text";
foreach (var objectToCompare in objectsToCompare) {
try {
int i = s.CompareTo(objectToCompare);
Console.WriteLine("Comparing '{0}' with '{1}': {2}",
s, objectToCompare, i);
}
catch (ArgumentException) {
Console.WriteLine("Bad argument: {0} (type {1})",
objectToCompare,
objectToCompare.GetType().Name);
}
}
}
}
// The example displays the following output:
// Bad argument: TestClass (type TestClass)
// Comparing 'some text' with 'TestClass': -1
// Bad argument: 123 (type Int32)
// Comparing 'some text' with '123': 1
// Comparing 'some text' with 'some text': 0
// Comparing 'some text' with 'Some Text': -1
open System
type TestClass() = class end
let test = TestClass()
let objectsToCompare: obj list =
[ test; string test; 123
string 123; "some text"
"Some Text" ]
let s = "some text"
for objectToCompare in objectsToCompare do
try
let i = s.CompareTo objectToCompare
printfn $"Comparing '{s}' with '{objectToCompare}': {i}"
with :? ArgumentException ->
printfn $"Bad argument: {objectToCompare} (type {objectToCompare.GetType().Name})"
// The example displays the following output:
// Bad argument: TestClass (type TestClass)
// Comparing 'some text' with 'TestClass': -1
// Bad argument: 123 (type Int32)
// Comparing 'some text' with '123': 1
// Comparing 'some text' with 'some text': 0
// Comparing 'some text' with 'Some Text': -1
Public Class TestClass
End Class
Public Class Example
Public Shared Sub Main()
Dim test As New TestClass()
Dim objectsToCompare() As Object = { test, test.ToString(), 123,
123.ToString(), "some text",
"Some Text" }
Dim s As String = "some text"
For Each objectToCompare In objectsToCompare
Try
Dim i As Integer = s.CompareTo(objectToCompare)
Console.WriteLine("Comparing '{0}' with '{1}': {2}",
s, objectToCompare, i)
Catch e As ArgumentException
Console.WriteLine("Bad argument: {0} (type {1})",
objectToCompare,
objectToCompare.GetType().Name)
End Try
Next
End Sub
End Class
' The example displays the following output:
' Bad argument: TestClass (type TestClass)
' Comparing 'some text' with 'TestClass': -1
' Bad argument: 123 (type Int32)
' Comparing 'some text' with '123': 1
' Comparing 'some text' with 'some text': 0
' Comparing 'some text' with 'Some Text': -1
備註
value 必須是 String 物件。
這個方法會使用目前文化特性來執行單字 (區分大小寫和區分文化特性) 比較。 如需字組、字串和序數排序的詳細資訊，請參閱 System.Globalization.CompareOptions 。
如需此方法行為的詳細資訊，請參閱 方法的一 String.Compare(String, String) 節。
給呼叫者的注意事項
字元集包含可忽略的字元。 方法 CompareTo(Object) 在執行區分文化特性的比較時，不會考慮這類字元。 例如，如果下列程式碼是在.NET Framework 4 或更新版本上執行，則使用軟連字號或 U+00AD) 表示這兩個字串相等的「動物」 與 「ani-mal」 (比較。
using System;
public class Example
{
public static void Main()
{
string s1 = "ani\u00ADmal";
object o1 = "animal";
Console.WriteLine("Comparison of '{0}' and '{1}': {2}",
s1, o1, s1.CompareTo(o1));
}
}
// The example displays the following output:
// Comparison of 'ani-mal' and 'animal': 0
let s1 = "ani\u00ADmal"
let o1: obj = "animal"
printfn $"Comparison of '{s1}' and '{o1}': {s1.CompareTo o1}"
// The example displays the following output:
// Comparison of 'ani-mal' and 'animal': 0
Module Example
Public Sub Main()
Dim s1 As String = "ani" + ChrW(&h00AD) + "mal"
Dim o1 As Object = "animal"
Console.WriteLine("Comparison of '{0}' and '{1}': {2}",
s1, o1, s1.CompareTo(o1))
End Sub
End Module
' The example displays the following output:
' Comparison of 'ani-mal' and 'animal': 0
若要辨識字串比較中的可忽略字元，請呼叫 CompareOrdinal(String, String) 方法。
另請參閱
適用於
意見反應
即將推出：在 2024 年，我們將隨著內容的意見反應機制逐步淘汰 GitHub 問題，並以新的意見反應系統來取代。 如需詳細資訊，請參閱 https://aka.ms/ContentUserFeedback。
提交並檢視相關的意見反應