TimeSpan.CompareTo 方法

参考

定义

命名空间:: System

程序集:: System.Runtime.dll

程序集:: mscorlib.dll

程序集:: netstandard.dll

重要

一些信息与预发行产品相关，相应产品在发行之前可能会进行重大修改。对于此处提供的信息，Microsoft 不作任何明示或暗示的担保。

将此实例与指定对象或 TimeSpan 对象进行比较，并返回一个整数，该整数指示此实例是短于、等于还是长于指定对象或 TimeSpan 对象。

重载

CompareTo(Object)	将此实例与指定对象进行比较，并返回一个整数，该整数指示此实例是短于、等于还是长于指定对象。
CompareTo(TimeSpan)	将此实例与指定的 TimeSpan 对象进行比较，并返回一个整数，该整数指示此实例是短于、等于还是长于 TimeSpan 对象。

注解

方法的 CompareTo 两个重载返回一个有符号数字，指示此实例和 value 参数的相对值，如下表所示。

值	说明
小于零	此实例短于 `value`。
零	此实例与 `value` 相同。
大于零	此实例长于 `value`。

CompareTo(Object)

Source:: TimeSpan.cs

Source:: TimeSpan.cs

Source:: TimeSpan.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 -> int

Public Function CompareTo (value As Object) As Integer

参数

value: Object

要比较的对象，或为 null。

Int32

以下值之一。

“值”	说明
-1	此实例短于 `value`。
0	此实例等于 `value`。
1	此实例的长度大于 `value`，或 `value` 为 `null`。

实现

CompareTo(Object)

例外

ArgumentException

value 不是 TimeSpan。

示例

以下示例使用 CompareTo 方法将多个TimeSpan结构和其他对象与引用TimeSpan结构进行比较。

// Example of the TimeSpan::CompareTo( Object* ) and 
// TimeSpan::Equals( Object* ) methods.
using namespace System;

// Compare the TimeSpan to the Object parameters, 
// and display the Object parameters with the results.
void CompTimeSpanToObject( TimeSpan Left, Object^ Right, String^ RightText )
{
   Console::WriteLine( "{0,-33}{1}", String::Concat( "Object: ", RightText ), Right );
   Console::WriteLine( "{0,-33}{1}", "Left.Equals( Object )", Left.Equals( Right ) );
   Console::Write( "{0,-33}", "Left.CompareTo( Object )" );
   
   // Catch the exception if CompareTo( ) throws one.
   try
   {
      Console::WriteLine( "{0}\n", Left.CompareTo( Right ) );
   }
   catch ( Exception^ ex ) 
   {
      Console::WriteLine( "Error: {0}\n", ex->Message );
   }

}

int main()
{
   TimeSpan Left = TimeSpan(0,5,0);
   Console::WriteLine( "This example of the TimeSpan::Equals( Object* ) "
   "and \nTimeSpan::CompareTo( Object* ) methods generates "
   "the \nfollowing output by creating several different "
   "TimeSpan \nobjects and comparing them with a "
   "5-minute TimeSpan.\n" );
   Console::WriteLine( "{0,-33}{1}\n", "Left: TimeSpan( 0, 5, 0 )", Left );
   
   // Create objects to compare with a 5-minute TimeSpan.
   CompTimeSpanToObject( Left, TimeSpan(0,0,300), "TimeSpan( 0, 0, 300 )" );
   CompTimeSpanToObject( Left, TimeSpan(0,5,1), "TimeSpan( 0, 5, 1 )" );
   CompTimeSpanToObject( Left, TimeSpan(0,5,-1), "TimeSpan( 0, 5, -1 )" );
   CompTimeSpanToObject( Left, TimeSpan(3000000000), "TimeSpan( 3000000000 )" );
   CompTimeSpanToObject( Left, 3000000000L, "__int64 3000000000L" );
   CompTimeSpanToObject( Left, "00:05:00", "String \"00:05:00\"" );
}

/*
This example of the TimeSpan::Equals( Object* ) and
TimeSpan::CompareTo( Object* ) methods generates the
following output by creating several different TimeSpan
objects and comparing them with a 5-minute TimeSpan.

Left: TimeSpan( 0, 5, 0 )        00:05:00

Object: TimeSpan( 0, 0, 300 )    00:05:00
Left.Equals( Object )            True
Left.CompareTo( Object )         0

Object: TimeSpan( 0, 5, 1 )      00:05:01
Left.Equals( Object )            False
Left.CompareTo( Object )         -1

Object: TimeSpan( 0, 5, -1 )     00:04:59
Left.Equals( Object )            False
Left.CompareTo( Object )         1

Object: TimeSpan( 3000000000 )   00:05:00
Left.Equals( Object )            True
Left.CompareTo( Object )         0

Object: __int64 3000000000L      3000000000
Left.Equals( Object )            False
Left.CompareTo( Object )         Error: Object must be of type TimeSpan.

Object: String "00:05:00"        00:05:00
Left.Equals( Object )            False
Left.CompareTo( Object )         Error: Object must be of type TimeSpan.
*/

// Example of the TimeSpan.CompareTo( Object ) and 
// TimeSpan.Equals( Object ) methods.
using System;

class TSCompToEqualsObjDemo
{
    // Compare the TimeSpan to the Object parameters, 
    // and display the Object parameters with the results.
    static void CompTimeSpanToObject( TimeSpan Left, object Right, 
        string RightText )
    {
        Console.WriteLine( "{0,-33}{1}", "Object: " + RightText, 
            Right );
        Console.WriteLine( "{0,-33}{1}", "Left.Equals( Object )", 
            Left.Equals( Right ) );
        Console.Write( "{0,-33}", "Left.CompareTo( Object )" );

        // Catch the exception if CompareTo( ) throws one.
        try
        {
            Console.WriteLine( "{0}\n", Left.CompareTo( Right ) );
        }
        catch( Exception ex )
        {
            Console.WriteLine( "Error: {0}\n", ex.Message );
        }
    }

    static void Main( )
    {
        TimeSpan Left = new TimeSpan( 0, 5, 0 );

        Console.WriteLine(
            "This example of the TimeSpan.Equals( Object ) " +
            "and \nTimeSpan.CompareTo( Object ) methods generates " +
            "the \nfollowing output by creating several different " +
            "TimeSpan \nobjects and comparing them with a " +
            "5-minute TimeSpan.\n" );
        Console.WriteLine( "{0,-33}{1}\n", 
            "Left: TimeSpan( 0, 5, 0 )", Left );

        // Create objects to compare with a 5-minute TimeSpan.
        CompTimeSpanToObject( Left, new TimeSpan( 0, 0, 300 ), 
            "TimeSpan( 0, 0, 300 )" );
        CompTimeSpanToObject( Left, new TimeSpan( 0, 5, 1 ), 
            "TimeSpan( 0, 5, 1 )" );
        CompTimeSpanToObject( Left, new TimeSpan( 0, 5, -1 ), 
            "TimeSpan( 0, 5, -1 )" );
        CompTimeSpanToObject( Left, new TimeSpan( 3000000000 ), 
            "TimeSpan( 3000000000 )" );
        CompTimeSpanToObject( Left, 3000000000L, 
            "long 3000000000L" );
        CompTimeSpanToObject( Left, "00:05:00", 
            "string \"00:05:00\"" );
    } 
} 

/*
This example of the TimeSpan.Equals( Object ) and
TimeSpan.CompareTo( Object ) methods generates the
following output by creating several different TimeSpan
objects and comparing them with a 5-minute TimeSpan.

Left: TimeSpan( 0, 5, 0 )        00:05:00

Object: TimeSpan( 0, 0, 300 )    00:05:00
Left.Equals( Object )            True
Left.CompareTo( Object )         0

Object: TimeSpan( 0, 5, 1 )      00:05:01
Left.Equals( Object )            False
Left.CompareTo( Object )         -1

Object: TimeSpan( 0, 5, -1 )     00:04:59
Left.Equals( Object )            False
Left.CompareTo( Object )         1

Object: TimeSpan( 3000000000 )   00:05:00
Left.Equals( Object )            True
Left.CompareTo( Object )         0

Object: long 3000000000L         3000000000
Left.Equals( Object )            False
Left.CompareTo( Object )         Error: Object must be of type TimeSpan.

Object: string "00:05:00"        00:05:00
Left.Equals( Object )            False
Left.CompareTo( Object )         Error: Object must be of type TimeSpan.
*/

// Example of the TimeSpan.CompareTo( Object ) and 
// TimeSpan.Equals( Object ) methods.
open System

// Compare the TimeSpan to the Object parameters, 
// and display the Object parameters with the results.
let compTimeSpanToObject (left: TimeSpan) (right: obj) rightText =
    printfn $"""{"Object: " + rightText,-33}{right}"""
    printfn $"""{"Left.Equals( Object )",-33}{left.Equals right}"""
        
    printf "%-33s" "Left.CompareTo( Object )"

    // Catch the exception if CompareTo( ) throws one.
    try
        printfn $"{left.CompareTo right}\n" 
    with ex ->
        printfn $"Error: {ex.Message}\n"

let left = TimeSpan(0, 5, 0)

printfn "This example of the TimeSpan.Equals( Object ) and \nTimeSpan.CompareTo( Object ) methods generates the \nfollowing output by creating several different TimeSpan \nobjects and comparing them with a 5-minute TimeSpan.\n" 
printfn $"""{"Left: TimeSpan( 0, 5, 0 )",-33}{left}\n"""

// Create objects to compare with a 5-minute TimeSpan.
compTimeSpanToObject left (TimeSpan(0, 0, 300)) 
    "TimeSpan( 0, 0, 300 )"
compTimeSpanToObject left (TimeSpan(0, 5, 1)) 
    "TimeSpan( 0, 5, 1 )"
compTimeSpanToObject left (TimeSpan(0, 5, -1)) 
    "TimeSpan( 0, 5, -1 )"
compTimeSpanToObject left (TimeSpan 3000000000L ) 
    "TimeSpan( 3000000000 )"
compTimeSpanToObject left 3000000000L "long 3000000000L"
compTimeSpanToObject left "00:05:00" "string \"00:05:00\""

(*
This example of the TimeSpan.Equals( Object ) and
TimeSpan.CompareTo( Object ) methods generates the
following output by creating several different TimeSpan
objects and comparing them with a 5-minute TimeSpan.

Left: TimeSpan( 0, 5, 0 )        00:05:00

Object: TimeSpan( 0, 0, 300 )    00:05:00
Left.Equals( Object )            True
Left.CompareTo( Object )         0

Object: TimeSpan( 0, 5, 1 )      00:05:01
Left.Equals( Object )            False
Left.CompareTo( Object )         -1

Object: TimeSpan( 0, 5, -1 )     00:04:59
Left.Equals( Object )            False
Left.CompareTo( Object )         1

Object: TimeSpan( 3000000000 )   00:05:00
Left.Equals( Object )            True
Left.CompareTo( Object )         0

Object: long 3000000000L         3000000000
Left.Equals( Object )            False
Left.CompareTo( Object )         Error: Object must be of type TimeSpan.

Object: string "00:05:00"        00:05:00
Left.Equals( Object )            False
Left.CompareTo( Object )         Error: Object must be of type TimeSpan.
*)

' Example of the TimeSpan.CompareTo( Object ) and 
' TimeSpan.Equals( Object ) methods.
Module TSCompToEqualsObjDemo
    
    ' Compare the TimeSpan to the Object parameters, 
    ' and display the Object parameters with the results.
    Sub CompTimeSpanToObject( Left as TimeSpan, Right as Object, _
        RightText as String )

        Console.WriteLine( "{0,-33}{1}", "Object: " & RightText, _
            Right )
        Console.WriteLine( "{0,-33}{1}", "Left.Equals( Object )", _
            Left.Equals( Right ) )
        Console.Write( "{0,-33}", "Left.CompareTo( Object )" )

        ' Catch the exception if CompareTo( ) throws one.
        Try
            Console.WriteLine( "{0}" & vbCrLf, _
                Left.CompareTo( Right ) )
        Catch ex As Exception
            Console.WriteLine( "Error: {0}" & vbCrLf, ex.Message )
        End Try
    End Sub

    Sub Main( )
        Dim Left as new TimeSpan( 0, 5, 0 )

        Console.WriteLine( _
            "This example of the TimeSpan.Equals( Object ) " & _
            "and " & vbCrLf & "TimeSpan.CompareTo( Object ) " & _
            "methods generates the " & vbCrLf & _
            "following output by creating several " & _
            "different TimeSpan " & vbCrLf & "objects and " & _
            "comparing them with a 5-minute TimeSpan." & vbCrLf )
        Console.WriteLine( "{0,-33}{1}" & vbCrLf, _
            "Left: TimeSpan( 0, 5, 0 )", Left )

        ' Create objects to compare with a 5-minute TimeSpan.
        CompTimeSpanToObject( Left, new TimeSpan( 0, 0, 300 ), _
            "TimeSpan( 0, 0, 300 )" )
        CompTimeSpanToObject( Left, new TimeSpan( 0, 5, 1 ), _
            "TimeSpan( 0, 5, 1 )" )
        CompTimeSpanToObject( Left, new TimeSpan( 0, 5, -1 ), _
            "TimeSpan( 0, 5, -1 )" )
        CompTimeSpanToObject( Left, new TimeSpan( 3000000000 ), _
            "TimeSpan( 3000000000 )" )
        CompTimeSpanToObject( Left, 3000000000L, "Long 3000000000L" )
        CompTimeSpanToObject( Left, "00:05:00", _
            "String ""00:05:00""" )
    End Sub
End Module 

' This example of the TimeSpan.Equals( Object ) and
' TimeSpan.CompareTo( Object ) methods generates the
' following output by creating several different TimeSpan
' objects and comparing them with a 5-minute TimeSpan.
' 
' Left: TimeSpan( 0, 5, 0 )        00:05:00
' 
' Object: TimeSpan( 0, 0, 300 )    00:05:00
' Left.Equals( Object )            True
' Left.CompareTo( Object )         0
' 
' Object: TimeSpan( 0, 5, 1 )      00:05:01
' Left.Equals( Object )            False
' Left.CompareTo( Object )         -1
' 
' Object: TimeSpan( 0, 5, -1 )     00:04:59
' Left.Equals( Object )            False
' Left.CompareTo( Object )         1
' 
' Object: TimeSpan( 3000000000 )   00:05:00
' Left.Equals( Object )            True
' Left.CompareTo( Object )         0
' 
' Object: Long 3000000000L         3000000000
' Left.Equals( Object )            False
' Left.CompareTo( Object )         Error: Object must be of type TimeSpan.
' 
' Object: String "00:05:00"        00:05:00
' Left.Equals( Object )            False
' Left.CompareTo( Object )         Error: Object must be of type TimeSpan.

注解

的任何实例 TimeSpan，无论其值如何，都被视为大于 null。

参数value必须是或 null的TimeSpan实例;否则将引发异常。

另请参阅

适用于

CompareTo(TimeSpan)

Source:: TimeSpan.cs

Source:: TimeSpan.cs

Source:: TimeSpan.cs

将此实例与指定的 TimeSpan 对象进行比较，并返回一个整数，该整数指示此实例是短于、等于还是长于 TimeSpan 对象。

public:
 virtual int CompareTo(TimeSpan value);

public int CompareTo (TimeSpan value);

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

Public Function CompareTo (value As TimeSpan) As Integer

参数

value: TimeSpan

要与此实例进行比较的对象。

Int32

一个带符号数字，指示此实例和 value 的相对值。

值	说明
负整数	此实例短于 `value`。
零	此实例等于 `value`。
正整数	此实例长于 `value`。

实现

CompareTo(T)

示例

以下示例演示方法的 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.IComparable<T> 接口，其性能略好于方法， TimeSpan.CompareTo 因为它不必将参数转换为 value 对象。

适用于

通过

TimeSpan.CompareTo 方法

定义

重载

注解

CompareTo(Object)

参数

返回

实现

例外

示例

注解

另请参阅

适用于

CompareTo(TimeSpan)

参数

返回

实现

示例

注解

适用于

其他资源