TimeSpan.Equals TimeSpan.Equals TimeSpan.Equals TimeSpan.Equals Method

Определение

Возвращает значение, указывающее, равны ли два экземпляра TimeSpan.Returns a value indicating whether two instances of TimeSpan are equal.

Перегрузки

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

Возвращает значение, показывающее, равен ли данный экземпляр заданному объекту.Returns a value indicating whether this instance is equal to a specified object.

Equals(TimeSpan) Equals(TimeSpan) Equals(TimeSpan) Equals(TimeSpan)

Возвращает значение, указывающее, равен ли данный экземпляр заданному объекту TimeSpan.Returns a value indicating whether this instance is equal to a specified TimeSpan object.

Equals(TimeSpan, TimeSpan) Equals(TimeSpan, TimeSpan) Equals(TimeSpan, TimeSpan) Equals(TimeSpan, TimeSpan)

Возвращает значение, указывающее, равны ли два заданных экземпляра TimeSpan.Returns a value that indicates whether two specified instances of TimeSpan are equal.

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

Возвращает значение, показывающее, равен ли данный экземпляр заданному объекту.Returns a value indicating whether this instance is equal to a specified object.

public:
 override bool Equals(System::Object ^ value);
public override bool Equals (object value);
override this.Equals : obj -> bool
Public Overrides Function Equals (value As Object) As Boolean

Параметры

value
Object Object Object Object

Объект для сравнения с данным экземпляром.An object to compare with this instance.

Возвраты

true, если параметр value является объектом TimeSpan и представляет тот же интервал времени, что и текущий объект TimeSpan; в противном случае — false.true if value is a TimeSpan object that represents the same time interval as the current TimeSpan structure; otherwise, false.

Примеры

В следующем примере несколько TimeSpan и другие объекты сравниваются со ссылкой TimeSpan с помощью Equals метода.The following example compares several TimeSpan and other objects to a reference TimeSpan using the Equals method.

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

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.
Дополнительно

Equals(TimeSpan) Equals(TimeSpan) Equals(TimeSpan) Equals(TimeSpan)

Возвращает значение, указывающее, равен ли данный экземпляр заданному объекту TimeSpan.Returns a value indicating whether this instance is equal to a specified TimeSpan object.

public:
 virtual bool Equals(TimeSpan obj);
public bool Equals (TimeSpan obj);
override this.Equals : TimeSpan -> bool
Public Function Equals (obj As TimeSpan) As Boolean

Параметры

obj
TimeSpan TimeSpan TimeSpan TimeSpan

Объект для сравнения с данным экземпляром.An object to compare with this instance.

Возвраты

true, если obj представляет то т же интервал времени, что и данный экземпляр; в противном случае — false.true if obj represents the same time interval as this instance; otherwise, false.

Реализации

Примеры

В следующем примере показаны универсальные и неуниверсальные версии CompareTo метода для нескольких ссылочных типов.The following example demonstrates generic and nongeneric versions of the CompareTo method for several value and reference types.

// 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.

Imports System

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 'Main
   
   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 'Show
End Class 'Sample
'
'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.IEquatable<T> интерфейс и работает немного лучше, чем Equals потому, что obj не требуется преобразовывать параметр в объект.This method implements the System.IEquatable<T> interface, and performs slightly better than Equals because it does not have to convert the obj parameter to an object.

Дополнительно

Equals(TimeSpan, TimeSpan) Equals(TimeSpan, TimeSpan) Equals(TimeSpan, TimeSpan) Equals(TimeSpan, TimeSpan)

Возвращает значение, указывающее, равны ли два заданных экземпляра TimeSpan.Returns a value that indicates whether two specified instances of TimeSpan are equal.

public:
 static bool Equals(TimeSpan t1, TimeSpan t2);
public static bool Equals (TimeSpan t1, TimeSpan t2);
static member Equals : TimeSpan * TimeSpan -> bool
Public Shared Function Equals (t1 As TimeSpan, t2 As TimeSpan) As Boolean

Параметры

t1
TimeSpan TimeSpan TimeSpan TimeSpan

Первый из сравниваемых интервалов времени.The first time interval to compare.

t2
TimeSpan TimeSpan TimeSpan TimeSpan

Второй из сравниваемых интервалов времени.The second time interval to compare.

Возвраты

Значение true, если значения параметров t1 и t2 равны; в противном случае — значение false.true if the values of t1 and t2 are equal; otherwise, false.

Примеры

В следующем примере несколько TimeSpan объектов сравниваются с ссылочным TimeSpan объектом с помощью статического Equals метода.The following example compares several TimeSpan objects to a reference TimeSpan object using the static Equals method.

// Example of the TimeSpan::Compare( TimeSpan, TimeSpan ) and 
// TimeSpan::Equals( TimeSpan, TimeSpan ) methods.
using namespace System;
const __wchar_t * protoFmt = L"{0,-38}{1}";

// Compare TimeSpan parameters, and display them with the results.
void CompareTimeSpans( TimeSpan Left, TimeSpan Right, String^ RightText )
{
   String^ dataFmt = gcnew String( protoFmt );
   Console::WriteLine();
   Console::WriteLine( dataFmt, String::Concat( "Right: ", RightText ), Right );
   Console::WriteLine( dataFmt, "TimeSpan::Equals( Left, Right )", TimeSpan::Equals( Left, Right ) );
   Console::WriteLine( dataFmt, "TimeSpan::Compare( Left, Right )", TimeSpan::Compare( Left, Right ) );
}

int main()
{
   TimeSpan Left = TimeSpan(2,0,0);
   Console::WriteLine( "This example of the TimeSpan::Equals( TimeSpan, TimeSpan "
   ") and \nTimeSpan::Compare( TimeSpan, TimeSpan ) "
   "methods generates the \nfollowing output by creating "
   "several different TimeSpan \nobjects and comparing "
   "them with a 2-hour TimeSpan.\n" );
   Console::WriteLine( gcnew String( protoFmt ), "Left: TimeSpan( 2, 0, 0 )", Left );
   
   // Create objects to compare with a 2-hour TimeSpan.
   CompareTimeSpans( Left, TimeSpan(0,120,0), "TimeSpan( 0, 120, 0 )" );
   CompareTimeSpans( Left, TimeSpan(2,0,1), "TimeSpan( 2, 0, 1 )" );
   CompareTimeSpans( Left, TimeSpan(2,0,-1), "TimeSpan( 2, 0, -1 )" );
   CompareTimeSpans( Left, TimeSpan(72000000000), "TimeSpan( 72000000000 )" );
   CompareTimeSpans( Left, TimeSpan::FromDays( 1.0 / 12. ), "TimeSpan::FromDays( 1 / 12 )" );
}

/*
This example of the TimeSpan::Equals( TimeSpan, TimeSpan ) and
TimeSpan::Compare( TimeSpan, TimeSpan ) methods generates the
following output by creating several different TimeSpan
objects and comparing them with a 2-hour TimeSpan.

Left: TimeSpan( 2, 0, 0 )             02:00:00

Right: TimeSpan( 0, 120, 0 )          02:00:00
TimeSpan::Equals( Left, Right )       True
TimeSpan::Compare( Left, Right )      0

Right: TimeSpan( 2, 0, 1 )            02:00:01
TimeSpan::Equals( Left, Right )       False
TimeSpan::Compare( Left, Right )      -1

Right: TimeSpan( 2, 0, -1 )           01:59:59
TimeSpan::Equals( Left, Right )       False
TimeSpan::Compare( Left, Right )      1

Right: TimeSpan( 72000000000 )        02:00:00
TimeSpan::Equals( Left, Right )       True
TimeSpan::Compare( Left, Right )      0

Right: TimeSpan::FromDays( 1 / 12 )   02:00:00
TimeSpan::Equals( Left, Right )       True
TimeSpan::Compare( Left, Right )      0
*/
// Example of the TimeSpan.Compare( TimeSpan, TimeSpan ) and 
// TimeSpan.Equals( TimeSpan, TimeSpan ) methods.
using System;

class TSCompareEqualsDemo
{
    const string dataFmt = "{0,-38}{1}" ;

    // Compare TimeSpan parameters, and display them with the results.
    static void CompareTimeSpans( TimeSpan Left, TimeSpan Right, 
        string RightText )
    {
        Console.WriteLine( );
        Console.WriteLine( dataFmt, "Right: " + RightText, Right );
        Console.WriteLine( dataFmt, "TimeSpan.Equals( Left, Right )", 
            TimeSpan.Equals( Left, Right ) );
        Console.WriteLine( dataFmt, 
            "TimeSpan.Compare( Left, Right )", 
            TimeSpan.Compare( Left, Right ) );
    }

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

        Console.WriteLine(
            "This example of the TimeSpan.Equals( TimeSpan, Time" +
            "Span ) and \nTimeSpan.Compare( TimeSpan, TimeSpan ) " +
            "methods generates the \nfollowing output by creating " +
            "several different TimeSpan \nobjects and comparing " +
            "them with a 2-hour TimeSpan.\n" );
        Console.WriteLine( dataFmt, "Left: TimeSpan( 2, 0, 0 )", 
            Left );

        // Create objects to compare with a 2-hour TimeSpan.
        CompareTimeSpans( Left, new TimeSpan( 0, 120, 0 ), 
            "TimeSpan( 0, 120, 0 )" );
        CompareTimeSpans( Left, new TimeSpan( 2, 0, 1 ), 
            "TimeSpan( 2, 0, 1 )" );
        CompareTimeSpans( Left, new TimeSpan( 2, 0, -1 ), 
            "TimeSpan( 2, 0, -1 )");
        CompareTimeSpans( Left, new TimeSpan( 72000000000 ), 
            "TimeSpan( 72000000000 )" );
        CompareTimeSpans( Left, TimeSpan.FromDays( 1.0 / 12D ), 
            "TimeSpan.FromDays( 1 / 12 )" );
    } 
} 

/*
This example of the TimeSpan.Equals( TimeSpan, TimeSpan ) and
TimeSpan.Compare( TimeSpan, TimeSpan ) methods generates the
following output by creating several different TimeSpan
objects and comparing them with a 2-hour TimeSpan.

Left: TimeSpan( 2, 0, 0 )             02:00:00

Right: TimeSpan( 0, 120, 0 )          02:00:00
TimeSpan.Equals( Left, Right )        True
TimeSpan.Compare( Left, Right )       0

Right: TimeSpan( 2, 0, 1 )            02:00:01
TimeSpan.Equals( Left, Right )        False
TimeSpan.Compare( Left, Right )       -1

Right: TimeSpan( 2, 0, -1 )           01:59:59
TimeSpan.Equals( Left, Right )        False
TimeSpan.Compare( Left, Right )       1

Right: TimeSpan( 72000000000 )        02:00:00
TimeSpan.Equals( Left, Right )        True
TimeSpan.Compare( Left, Right )       0

Right: TimeSpan.FromDays( 1 / 12 )    02:00:00
TimeSpan.Equals( Left, Right )        True
TimeSpan.Compare( Left, Right )       0
*/ 
' Example of the TimeSpan.Compare( TimeSpan, TimeSpan ) and 
' TimeSpan.Equals( TimeSpan, TimeSpan ) methods.
Imports System
Imports Microsoft.VisualBasic

Module TSCompareEqualsDemo
    
    Const dataFmt As String = "{0,-38}{1}"

    ' Compare TimeSpan parameters, and display them with the results.
    Sub CompareTimeSpans( Left as TimeSpan, Right as TimeSpan, _
        RightText as String )

        Console.WriteLine( )
        Console.WriteLine( dataFmt, "Right: " & RightText, Right )
        Console.WriteLine( dataFmt, "TimeSpan.Equals( Left, Right )", _
            TimeSpan.Equals( Left, Right ) )
        Console.WriteLine( dataFmt, _
            "TimeSpan.Compare( Left, Right )", _
            TimeSpan.Compare( Left, Right ) )
    End Sub

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

        Console.WriteLine( _
            "This example of the TimeSpan.Equals( TimeSpan, " & _
            "TimeSpan ) and " & vbCrLf & "TimeSpan.Compare( " & _
            "TimeSpan, TimeSpan ) methods generates the " & vbCrLf & _
            "following output by creating several " & _
            "different TimeSpan " & vbCrLf & "objects and " & _
            "comparing them with a 2-hour TimeSpan." & vbCrLf )
        Console.WriteLine( dataFmt, "Left: TimeSpan( 2, 0, 0 )", Left )

        ' Create objects to compare with a 2-hour TimeSpan.
        CompareTimeSpans( Left, new TimeSpan( 0, 120, 0 ), _
            "TimeSpan( 0, 120, 0 )" )
        CompareTimeSpans( Left, new TimeSpan( 2, 0, 1 ), _
            "TimeSpan( 2, 0, 1 )" )
        CompareTimeSpans( Left, new TimeSpan( 2, 0, -1 ), _
            "TimeSpan( 2, 0, -1 )" )
        CompareTimeSpans( Left, new TimeSpan( 72000000000 ), _
            "TimeSpan( 72000000000 )" )
        CompareTimeSpans( Left, TimeSpan.FromDays( 1.0 / 12R ), _
            "TimeSpan.FromDays( 1 / 12 )" )
    End Sub 
End Module 

' This example of the TimeSpan.Equals( TimeSpan, TimeSpan ) and
' TimeSpan.Compare( TimeSpan, TimeSpan ) methods generates the
' following output by creating several different TimeSpan
' objects and comparing them with a 2-hour TimeSpan.
' 
' Left: TimeSpan( 2, 0, 0 )             02:00:00
' 
' Right: TimeSpan( 0, 120, 0 )          02:00:00
' TimeSpan.Equals( Left, Right )        True
' TimeSpan.Compare( Left, Right )       0
' 
' Right: TimeSpan( 2, 0, 1 )            02:00:01
' TimeSpan.Equals( Left, Right )        False
' TimeSpan.Compare( Left, Right )       -1
' 
' Right: TimeSpan( 2, 0, -1 )           01:59:59
' TimeSpan.Equals( Left, Right )        False
' TimeSpan.Compare( Left, Right )       1
' 
' Right: TimeSpan( 72000000000 )        02:00:00
' TimeSpan.Equals( Left, Right )        True
' TimeSpan.Compare( Left, Right )       0
' 
' Right: TimeSpan.FromDays( 1 / 12 )    02:00:00
' TimeSpan.Equals( Left, Right )        True
' TimeSpan.Compare( Left, Right )       0
Дополнительно

Применяется к