Char.CompareTo 메서드

정의

네임스페이스:: System

어셈블리:: mscorlib.dll, System.Runtime.dll

어셈블리:: netstandard.dll, System.Runtime.dll

어셈블리:: System.Runtime.dll

어셈블리:: mscorlib.dll

어셈블리:: netstandard.dll

중요

일부 정보는 릴리스되기 전에 상당 부분 수정될 수 있는 시험판 제품과 관련이 있습니다. Microsoft는 여기에 제공된 정보에 대해 어떠한 명시적이거나 묵시적인 보증도 하지 않습니다.

이 인스턴스를 지정된 개체 또는 값 형식과 비교하고, 이 인스턴스가 지정된 개체 또는 값 형식과 정렬 순서의 동일한 위치에 선행, 팔로우 또는 표시되는지 여부를 나타냅니다.

오버로드

Name	Description
CompareTo(Char)	이 인스턴스를 지정된 개체와 비교하고 이 인스턴스가 지정한 Char 개체와 정렬 순서 Char 의 동일한 위치에 선행, 팔로우 또는 표시되는지 여부를 나타냅니다.
CompareTo(Object)	이 인스턴스를 지정된 개체와 비교하고 이 인스턴스가 지정된 순서대로 정렬 순서 Object에서 앞에 오거나, 뒤따르거나, 나타나는지 여부를 나타냅니다.

CompareTo(Char)

Source:: Char.cs

Source:: Char.cs

Source:: Char.cs

Source:: Char.cs

Source:: Char.cs

이 인스턴스를 지정된 개체와 비교하고 이 인스턴스가 지정한 Char 개체와 정렬 순서 Char 의 동일한 위치에 선행, 팔로우 또는 표시되는지 여부를 나타냅니다.

public:
 virtual int CompareTo(char value);

public int CompareTo(char value);

abstract member CompareTo : char -> int
override this.CompareTo : char -> int

Public Function CompareTo (value As Char) As Integer

매개 변수

value: Char

Char 비교할 개체입니다.

반품

Int32

매개 변수와 관련하여 value 정렬 순서로 이 인스턴스의 위치를 나타내는 부호 있는 숫자입니다.

반환 값	설명
0보다 작음	이 인스턴스는 앞에 섰습니다 `value`.
0	이 인스턴스의 위치는 정렬 순서와 같습니다 `value`.
0보다 큼	이 인스턴스는 다음과 같습니다.`value`

구현

CompareTo(T)

예제

다음 코드 예제에서는 여러 값 및 참조 형식에 CompareTo 대 한 메서드의 제네릭 및 비 제네릭 버전을 보여 줍니다.

// 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> 인터페이스를 구현하고 Char.CompareTo 매개 변수를 개체로 변환할 필요가 없으므로 value 메서드보다 약간 더 잘 수행됩니다.

이 메서드에서 수행하는 비교는 어휘 특성이 아니라 이 인스턴스 value의 인코딩된 값을 기반으로 합니다.

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

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

일반적으로 암시적 확대 변환은 숫자 형식에서 수행됩니다. 프로그래밍 언어 설명서를 참조하여 컴파일러가 확대 변환을 수행하는지 확인합니다. 인스턴스 및 매개 변수 형식이 일치하지 않고 적절한 변환을 사용할 수 없는 경우 컴파일러는 매개 변수를 상자로 지정하고 매개 변수를 사용하는 CompareTo 오버로드를 호출 Object 하는 지침을 생성합니다.

추가 정보

적용 대상

CompareTo(Object)

Source:: Char.cs

Source:: Char.cs

Source:: Char.cs

Source:: Char.cs

Source:: Char.cs

이 인스턴스를 지정된 개체와 비교하고 이 인스턴스가 지정된 순서대로 정렬 순서 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 -> int

Public Function CompareTo (value As Object) As Integer

매개 변수

value: Object

이 인스턴스를 비교할 개체 또는 null.

반품

Int32

매개 변수와 관련하여 value 정렬 순서로 이 인스턴스의 위치를 나타내는 부호 있는 숫자입니다.

반환 값 설명

0보다 작음 이 인스턴스는 앞에 섰습니다 value.

0 이 인스턴스의 위치는 정렬 순서와 같습니다 value.

0보다 큼

이 인스턴스는 다음과 같습니다.value

-또는-

value은 null입니다.

구현

CompareTo(Object)

예외

ArgumentException

value가 개체가 아닌 경우 Char

예제

다음 코드 예제에서는 CompareTo.

using System;

public class CompareToSample {
    public static void Main() {
        char chA = 'A';
        char chB = 'B';

        Console.WriteLine(chA.CompareTo('A'));	// Output: "0" (meaning they're equal)
        Console.WriteLine('b'.CompareTo(chB));	// Output: "32" (meaning 'b' is greater than 'B' by 32)
        Console.WriteLine(chA.CompareTo(chB));	// Output: "-1" (meaning 'A' is less than 'B' by 1)
    }
}

let chA = 'A'
let chB = 'B'

printfn $"{chA.CompareTo 'A'}"  // Output: "0" (meaning they're equal)
printfn $"{'b'.CompareTo chB}"  // Output: "32" (meaning 'b' is greater than 'B' by 32)
printfn $"{chA.CompareTo chB}"  // Output: "-1" (meaning 'A' is less than 'B' by 1)

Module CompareToSample

    Sub Main()

        Dim chA As Char
        chA = "A"c
        Dim chB As Char
        chB = "B"c

        Console.WriteLine(chA.CompareTo("A"c))  ' Output: "0" (meaning they're equal)
        Console.WriteLine("b"c.CompareTo(chB))  ' Output: "32" (meaning 'b' is 32 greater than 'B')
    Console.WriteLine(chA.CompareTo(chB))	' Output: "-1" (meaning 'A' is less than 'B' by 1)

    End Sub

End Module

설명

메서드는 CompareTo 인터페이스를 IComparable 구현합니다.

value 매개 변수는 null 또는 Char; 인스턴스여야 합니다. 그렇지 않으면 예외가 throw됩니다.

이 메서드에서 수행하는 비교는 이 인스턴스의 인코딩된 값을 기반으로 하며 value, 해당 어휘 특성이 아닙니다. 값에 관계없이 Char인스턴스는 null보다 큰 것으로 간주됩니다.

추가 정보

적용 대상

피드백

이 페이지가 도움이 되었나요?