UInt64.Equals Metodo

Riferimento

Definizione

Spazio dei nomi:: System

Assembly:: System.Runtime.dll

Assembly:: netstandard.dll

Assembly:: mscorlib.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Restituisce un valore che indica se l'istanza è uguale a un oggetto specificato o a un oggetto UInt64.

Overload

Equals(Object)	Restituisce un valore che indica se questa istanza è uguale a un oggetto specificato.
Equals(UInt64)	Restituisce un valore che indica se l'istanza è uguale a un valore UInt64 specificato.

Equals(Object)

Restituisce un valore che indica se questa istanza è uguale a un oggetto specificato.

public:
 override bool Equals(System::Object ^ obj);

public override bool Equals (object obj);

public override bool Equals (object? obj);

override this.Equals : obj -> bool

Public Overrides Function Equals (obj As Object) As Boolean

Parametri

obj: Object

Oggetto da confrontare con questa istanza.

Restituisce

Boolean

true se obj è un'istanza di UInt64 ed è uguale al valore dell'istanza; in caso contrario, false.

Esempio

Nell'esempio seguente viene illustrato il Equals metodo.

using System;

public class Example
{
   public static void Main()
   {
      object[] values = { (short) 10, (short) 20, 10, 20,
                          10L, 20L, 10D, 20D, (ushort) 10,
                          (ushort) 20, 10U, 20U,
                          10ul, 20ul };
      UInt64 baseValue = 20;
      String baseType = baseValue.GetType().Name;
      
      foreach (var value in values)
         Console.WriteLine("{0} ({1}) = {2} ({3}): {4}",
                           baseValue, baseType,
                           value, value.GetType().Name,
                           baseValue.Equals(value));
   }
}
// The example displays the following output:
//       20 (UInt64) = 10 (Int16): False
//       20 (UInt64) = 20 (Int16): False
//       20 (UInt64) = 10 (Int32): False
//       20 (UInt64) = 20 (Int32): False
//       20 (UInt64) = 10 (Int64): False
//       20 (UInt64) = 20 (Int64): False
//       20 (UInt64) = 10 (Double): False
//       20 (UInt64) = 20 (Double): False
//       20 (UInt64) = 10 (UInt16): False
//       20 (UInt64) = 20 (UInt16): False
//       20 (UInt64) = 10 (UInt32): False
//       20 (UInt64) = 20 (UInt32): False
//       20 (UInt64) = 10 (UInt64): False
//       20 (UInt64) = 20 (UInt64): True

Module Example
   Public Sub Main()
      Dim values() As Object = { 10S, 20S, 10I, 20I, 10L, 20L,
                                 10R, 20R, 10US, 20US, 10UI, 20UI,
                                 10UL, 20UL }
      Dim baseValue As UInt64 = 20
      Dim baseType As String = baseValue.GetType().Name
      
      For Each value In values
         Console.WriteLine("{0} ({1}) = {2} ({3}): {4}",
                           baseValue, baseType,
                           value, value.GetType().Name,
                           baseValue.Equals(value))
      Next
   End Sub
End Module
' The example displays the following output:
'       20 (UInt64) = 10 (Int16): False
'       20 (UInt64) = 20 (Int16): False
'       20 (UInt64) = 10 (Int32): False
'       20 (UInt64) = 20 (Int32): False
'       20 (UInt64) = 10 (Int64): False
'       20 (UInt64) = 20 (Int64): False
'       20 (UInt64) = 10 (Double): False
'       20 (UInt64) = 20 (Double): False
'       20 (UInt64) = 10 (UInt16): False
'       20 (UInt64) = 20 (UInt16): False
'       20 (UInt64) = 10 (UInt32): False
'       20 (UInt64) = 20 (UInt32): False
'       20 (UInt64) = 10 (UInt64): False
'       20 (UInt64) = 20 (UInt64): True

Note per i chiamanti

La risoluzione dell'overload del compilatore può essere la causa di una differenza apparente nel comportamento dei due Equals(UInt64) overload del metodo. Se viene definita una conversione implicita tra l'argomento e e l'argomento non è tipizzazione come , i compilatori eseguono una obj UInt64 Object conversione implicita e chiamano il Equals(UInt64) metodo . In caso contrario, chiamano Equals(Object) il metodo , che restituisce sempre se false obj l'argomento non è un UInt64 valore. Nell'esempio seguente viene illustrata la differenza di comportamento tra i due overload del metodo . Nel caso dei valori , e , il primo confronto viene restituito perché il compilatore esegue automaticamente una conversione di ampliamento e chiama il metodo , mentre il secondo confronto restituisce perché il compilatore chiama Byte UInt16 il metodo UInt32 true Equals(UInt64) false Equals(Object) .

using System;

public class Example
{
   static ulong value = 112;
   
   public static void Main()
   {
      byte byte1= 112;
      Console.WriteLine("value = byte1: {0,16}", value.Equals(byte1));
      TestObjectForEquality(byte1);

      short short1 = 112;
      Console.WriteLine("value = short1: {0,17}", value.Equals(short1));
      TestObjectForEquality(short1);

      int int1 = 112;
      Console.WriteLine("value = int1: {0,19}", value.Equals(int1));
      TestObjectForEquality(int1);

      sbyte sbyte1 = 112;
      Console.WriteLine("value = sbyte1: {0,17}", value.Equals(sbyte1));
      TestObjectForEquality(sbyte1);

      ushort ushort1 = 112;
      Console.WriteLine("value = ushort1: {0,16}", value.Equals(ushort1));
      TestObjectForEquality(ushort1);

      uint uint1 = 112;
      Console.WriteLine("value = uint1: {0,18}", value.Equals(uint1));
      TestObjectForEquality(uint1);

      decimal dec1 = 112m;
      Console.WriteLine("value = dec1: {0,21}", value.Equals(dec1));
      TestObjectForEquality(dec1);

      double dbl1 = 112;
      Console.WriteLine("value = dbl1: {0,20}", value.Equals(dbl1));
      TestObjectForEquality(dbl1);
   }

   private static void TestObjectForEquality(Object obj)
   {
      Console.WriteLine("{0} ({1}) = {2} ({3}): {4}\n",
                        value, value.GetType().Name,
                        obj, obj.GetType().Name,
                        value.Equals(obj));
   }
}
// The example displays the following output:
//       value = byte1:             True
//       112 (UInt64) = 112 (Byte): False
//
//       value = short1:             False
//       112 (UInt64) = 112 (Int16): False
//
//       value = int1:               False
//       112 (UInt64) = 112 (Int32): False
//
//       value = sbyte1:             False
//       112 (UInt64) = 112 (SByte): False
//
//       value = ushort1:             True
//       112 (UInt64) = 112 (UInt16): False
//
//       value = uint1:               True
//       112 (UInt64) = 112 (UInt32): False
//
//       value = dec1:                 False
//       112 (UInt64) = 112 (Decimal): False
//
//       value = dbl1:                False
//       112 (UInt64) = 112 (Double): False

Vedi anche

CompareTo(Object)

Si applica a

Equals(UInt64)

Restituisce un valore che indica se l'istanza è uguale a un valore UInt64 specificato.

public:
 virtual bool Equals(System::UInt64 obj);

public bool Equals (ulong obj);

override this.Equals : uint64 -> bool

Public Function Equals (obj As ULong) As Boolean

Parametri

obj: UInt64

Valore UInt64 da confrontare con questa istanza.

Restituisce

Boolean

true se obj ha lo stesso valore di questa istanza; in caso contrario, false.

Implementazioni

Equals(T)

Esempio

Nell'esempio seguente viene illustrato il Equals metodo.

using namespace System;

int main()
{
      UInt64 value1 = 50;
      UInt64 value2 = 50;

      // Display the values.
        Console::WriteLine("value1:   Type: {0}   Value: {1}",
                           value1.GetType()->Name, value1);
        Console::WriteLine("value2:   Type: {0}   Value: {1}",
                         value2.GetType()->Name, value2);

        // Compare the two values.
        Console::WriteLine("value1 and value2 are equal: {0}",
                           value1.Equals(value2));
}
// The example displays the following output:
//       value1:   Type: UInt64   Value: 50
//       value2:   Type: UInt64   Value: 50
//       value1 and value2 are equal: True

using System;

class Example
{
     public static void Main()
     {
         UInt64 value1 = 50;
         UInt64 value2 = 50;

         // Display the values.
        Console.WriteLine("value1:   Type: {0}   Value: {1}",
                          value1.GetType().Name, value1);
        Console.WriteLine("value2:   Type: {0}   Value: {1}",
                        value2.GetType().Name, value2);

        // Compare the two values.
        Console.WriteLine("value1 and value2 are equal: {0}",
                          value1.Equals(value2));
     }
}
// The example displays the following output:
//       value1:   Type: UInt64   Value: 50
//       value2:   Type: UInt64   Value: 50
//       value1 and value2 are equal: True

Class Example
   Public Shared Sub Main()
      Dim value1 As UInt64 = 50
      Dim value2 As UInt64 = 50
      
      'Display the values.
      Console.WriteLine("value1:   Type: {0}   Value: {1}",
                        value1.GetType().Name, value1)
      Console.WriteLine("value2:   Type: {0}   Value: {1}",
                        value2.GetType().Name, value2)

      ' Compare the two values.
      Console.WriteLine("value1 and value2 are equal: {0}",
                        value1.Equals(value2))
   End Sub
End Class 
' The example displays the following output:
'       value1:   Type: UInt64   Value: 50
'       value2:   Type: UInt64   Value: 50
'       value1 and value2 are equal: True

Commenti

Questo metodo implementa l'interfaccia e offre prestazioni leggermente migliori rispetto a perché non è System.IEquatable<T> necessario convertire il parametro in un oggetto Equals obj .

Note per i chiamanti

using System;

public class Example
{
   static ulong value = 112;
   
   public static void Main()
   {
      byte byte1= 112;
      Console.WriteLine("value = byte1: {0,16}", value.Equals(byte1));
      TestObjectForEquality(byte1);

      short short1 = 112;
      Console.WriteLine("value = short1: {0,17}", value.Equals(short1));
      TestObjectForEquality(short1);

      int int1 = 112;
      Console.WriteLine("value = int1: {0,19}", value.Equals(int1));
      TestObjectForEquality(int1);

      sbyte sbyte1 = 112;
      Console.WriteLine("value = sbyte1: {0,17}", value.Equals(sbyte1));
      TestObjectForEquality(sbyte1);

      ushort ushort1 = 112;
      Console.WriteLine("value = ushort1: {0,16}", value.Equals(ushort1));
      TestObjectForEquality(ushort1);

      uint uint1 = 112;
      Console.WriteLine("value = uint1: {0,18}", value.Equals(uint1));
      TestObjectForEquality(uint1);

      decimal dec1 = 112m;
      Console.WriteLine("value = dec1: {0,21}", value.Equals(dec1));
      TestObjectForEquality(dec1);

      double dbl1 = 112;
      Console.WriteLine("value = dbl1: {0,20}", value.Equals(dbl1));
      TestObjectForEquality(dbl1);
   }

   private static void TestObjectForEquality(Object obj)
   {
      Console.WriteLine("{0} ({1}) = {2} ({3}): {4}\n",
                        value, value.GetType().Name,
                        obj, obj.GetType().Name,
                        value.Equals(obj));
   }
}
// The example displays the following output:
//       value = byte1:             True
//       112 (UInt64) = 112 (Byte): False
//
//       value = short1:             False
//       112 (UInt64) = 112 (Int16): False
//
//       value = int1:               False
//       112 (UInt64) = 112 (Int32): False
//
//       value = sbyte1:             False
//       112 (UInt64) = 112 (SByte): False
//
//       value = ushort1:             True
//       112 (UInt64) = 112 (UInt16): False
//
//       value = uint1:               True
//       112 (UInt64) = 112 (UInt32): False
//
//       value = dec1:                 False
//       112 (UInt64) = 112 (Decimal): False
//
//       value = dbl1:                False
//       112 (UInt64) = 112 (Double): False

Si applica a

UInt64.Equals Metodo

Definizione

Overload

Equals(Object)

Parametri

Restituisce

Esempio

Note per i chiamanti

Vedi anche

Si applica a

Equals(UInt64)

Parametri

Restituisce

Implementazioni

Esempio

Commenti

Note per i chiamanti

Si applica a

Risorse aggiuntive