Esporta (0) Stampa
Espandi tutto

Metodo Object.Equals (Object)

Consente di determinare se l'oggetto Object specificato è uguale all'oggetto Object corrente.

Spazio dei nomi: System
Assembly: mscorlib (in mscorlib.dll)

public virtual bool Equals (
	Object obj
)
public boolean Equals (
	Object obj
)
public function Equals (
	obj : Object
) : boolean

Parametri

obj

Oggetto Object da confrontare con l'oggetto Object corrente.

Valore restituito

true se l'oggetto Object specificato è uguale all'oggetto Object corrente; in caso contrario, false.

L'implementazione predefinita del metodo Equals supporta soltanto l'uguaglianza dei riferimenti; per supportare l'uguaglianza dei valori, le classi derivate possono eseguire l'override di questo metodo.

Nel caso dei tipi di riferimento, l'uguaglianza viene definita come uguaglianza degli oggetti, cioè i riferimenti riguardano lo stesso oggetto. Nel caso dei tipi di valore l'uguaglianza è definita come uguaglianza bit per bit. La classe ValueType supporta i tipi di valore.

Note per gli implementatori: Il metodo può essere sottoposto a override da una classe derivata. Molti tipi di dati di base restituiscono, ad esempio, true se entrambi gli oggetti rappresentano lo stesso valore; in caso contrario, false. Il metodo confronta soltanto tipi primitivi e oggetti. Per confrontare strutture più complesse, come ad esempio le matrici di oggetti, deve essere sottoposto a override. Le seguenti istruzioni devono essere true per tutte le implementazioni del metodo Equals. Nell'elenco, x, y e z rappresentano riferimenti a oggetti che non sono riferimento null (Nothing in Visual Basic).

  • x.Equals(x) restituisce true, eccetto nei casi in cui sono compresi tipi a virgola mobile. Vedere IEC 60559:1989, Binary Floating-point Arithmetic for Microprocessor Systems.

  • x.Equals(y) restituisce lo stesso valore di y.Equals(x).

  • x.Equals(y) restituisce true se x e y sono NaN.

  • (x.Equals(y) && y.Equals(z)) restituisce true se e soltanto se x.Equals(z) restituisce true .

  • Le chiamate successive a x.Equals(y) restituiscono lo stesso valore finché non vengono modificati gli oggetti a cui fanno riferimento x e y.

  • x.Equals( riferimento null (Nothing in Visual Basic) ) restituisce false.

Vedere GetHashCode per le ulteriori funzionalità richieste che riguardano il metodo Equals. Le implementazioni di Equals non devono generare eccezioni. Per alcuni tipi di oggetti è preferibile che il metodo Equals esegua il test di uguaglianza dei valori anziché dei riferimenti. Tali implementazioni di Equals restituiscono true se i due oggetti hanno lo stesso "valore", anche se non sono della stessa istanza. L'implementatore del tipo stabilisce ciò che costituirà il "valore" di un oggetto, ma in genere si tratta di parte o di tutti i dati memorizzati nelle variabili di istanza dell'oggetto. Il valore, ad esempio, di un oggetto String si basa sui caratteri della stringa; il metodo Equals della classe String restituisce true ogni due istanze di stringa contenenti esattamente gli stessi caratteri nello stesso ordine. I tipi che implementano l'interfaccia IComparable devono eseguire l'ovveride del metodo Equals. I tipi che eseguono l'override del metodo Equals devono eseguire anche l'override del metodo GetHashCode. In caso contrario, Hashtable potrebbe non funzionare correttamente. Se il linguaggio di programmazione utilizzato supporta l'overload dell'operatore e si sceglie di eseguire l'overload dell'operatore di uguaglianza per un determinato tipo, questo tipo deve eseguire l'override del metodo Equals. Tali implementazioni del metodo Equals devono restituire lo stesso risultato dell'operatore di uguaglianza. L'applicazione di queste indicazioni garantisce che il codice della libreria di classi che utilizza il metodo Equals, ad esempio ArrayList e Hashtable, agisca conformemente al modo in cui il codice dell'applicazione utilizza l'operatore di uguaglianza. Le seguenti indicazioni sono applicabili all'implementazione di un tipo di valore:
  • Considerare l'override del metodo Equals per ottenere prestazioni superiori rispetto a quelle offerte dall'implementazione predefinita di Equals su ValueType.

  • Se si esegue l'override di Equals e il linguaggio supporta l'overload dell'operatore, eseguire l'overload dell'operatore di uguaglianza del tipo di valore utilizzato.

Le seguenti indicazioni sono applicabili per l'implementazione di un tipo di riferimento:
  • Considerare l'override del metodo Equals su un tipo di riferimento se la semantica del tipo si basa sul fatto che il tipo rappresenta dei valori.

  • La maggior parte dei tipi di riferimento non deve eseguire l'overload dell'operatore di uguaglianza, anche se esegue l'override di Equals. Se tuttavia si implementa un tipo di riferimento che presumibilmente dispone di una semantica di valori, come ad esempio un tipo di numero complesso, è necessario eseguire l'override dell'operatore di uguaglianza.

Nell'esempio di codice che segue viene confrontata l'istanza corrente con un altro oggetto.

using System;

public class Sample {
    void Method() {
    Object Obj1 = new Object();
    Object Obj2 = new Object();
    Console.WriteLine(Obj1.Equals(Obj2)); //===> false
    Obj2 = Obj1;
    Console.WriteLine(Obj1.Equals(Obj2)); //===> true
    }
}

import System.*;

public class Sample
{
    void Method()
    {
        Object obj1 = new Object();
        Object obj2 = new Object();
        Console.WriteLine(obj1.Equals(obj2)); //===> false
        obj2 = obj1;
        Console.WriteLine(obj1.Equals(obj2)); //===> true
    } //Method
} //Sample

Nell'esempio che segue viene descritta una classe Point che esegue l'override del metodo Equals per fornire l'uguaglianza di valori e una classe Point3D, derivata da Point. Poiché l'override di Point eseguito dal metodo Equals è il primo elemento nella catena di eredità a introdurre l'uguaglianza di valori, non viene richiamato il metodo Equals della classe base, che è ereditata dall'oggetto Object e utilizzata per ricercare l'uguaglianza referenziale. Ciononostante, Point3D.Equals chiama il metodo Point.Equals perché Point implementa Equals in un modo che consente l'uguaglianza di valori.

using System;

class Point: Object {
   protected int x, y;

   public Point() {
     this.x = 0;
     this.y = 0;
   }

   public Point(int X, int Y) {
      this.x = X;
      this.y = Y;
   }
 
   public override bool Equals(Object obj) {
      //Check for null and compare run-time types.
      if (obj == null || GetType() != obj.GetType()) return false;
      Point p = (Point)obj;
      return (x == p.x) && (y == p.y);
   }

   public override int GetHashCode() {
      return x ^ y;
   }
}


class Point3D: Point {
   int z;

   public Point3D(int X, int Y, int Z) {
      this.x = X;
      this.y = Y;
      this.z = Z; 
   }

   public override bool Equals(Object obj) {
      return base.Equals(obj) && z == ((Point3D)obj).z;
   }

   public override int GetHashCode() {
      return base.GetHashCode() ^ z;
   }
}

Il metodo Point.Equals verifica che l'argomento obj non sia riferimento null (Nothing in Visual Basic) e che faccia riferimento a un'istanza dello stesso tipo dell'oggetto. Se una di queste verifiche ha esito negativo, il metodo restituisce false .

Il metodo Equals si avvale di GetType per determinare se i tipi in fase di esecuzione dei due oggetti sono identici. In questo caso non viene utilizzato typeof, perché restituisce il tipo statico. Se il metodo ha utilizzato un controllo del formato obj is Point, il controllo restituirà true nei casi in cui obj è un'istanza di una classe derivata di Point, anche se obj e l'istanza corrente non sono dello stesso tipo di runtime. Una volta verificato che entrambi gli oggetti sono dello stesso tipo, il metodo esegue il cast di obj al tipo Point e restituisce il risultato del confronto tra variabili di istanza dei due oggetti.

In Point3D.Equals il metodo ereditato Equals viene chiamato prima dell'esecuzione di qualsiasi operazione; il metodo ereditato Equals verifica che obj non sia riferimento null (Nothing in Visual Basic), che obj sia un'istanza della stessa classe di questo oggetto e che le variabili di istanza ereditate corrispondano. Soltanto quando il metodo ereditato Equals restituisce true, vengono confrontate le variabili di istanza introdotte nella classe derivata. In particolare, il cast a Point3D non viene eseguito se non si è stabilito che obj è di tipo Point3D o una classe derivata di Point3D.

Nell'esempio precedente viene utilizzato operator ==, ossia l'operatore di uguaglianza, per confrontare le singole variabili di istanza. In alcuni casi è opportuno utilizzare il metodo Equals per confrontare le variabili di istanza in una implementazione di Equals, come descritto nell'esempio di codice che segue.

using System;

class Rectangle {
   Point a, b;

   public Rectangle(int upLeftX, int upLeftY, int downRightX, int downRightY) {
      this.a = new Point(upLeftX, upLeftY);
      this.b = new Point(downRightX, downRightY);
   }

   public override bool Equals(Object obj) {
     // Performs an equality check on two rectangles (Point object pairs).
      if (obj == null || GetType() != obj.GetType()) return false;
      Rectangle r = (Rectangle)obj;
      //Uses Equals to compare variables.
      return a.Equals(r.a) && b.Equals(r.b);
   }

   public override int GetHashCode() {
      return a.GetHashCode() ^ b.GetHashCode();
   }

}

In alcuni linguaggi, come ad esempio C#, è supportato l'overload dell'operatore. Quando un tipo esegue l'overload di operator == dovrà eseguire anche l'override del metodo Equals per fornire la stessa funzionalità. Questo risultato si ottiene generalmente descrivendo il metodo Equals in termini di operator == sottoposto a overload, come nell'esempio di codice che segue.

using System;

public struct Complex {
   public double re, im;

   public override bool Equals(Object obj) {
      return obj is Complex && this == (Complex)obj;
   }

   public override int GetHashCode() {
      return re.GetHashCode() ^ im.GetHashCode();
   }

   public static bool operator ==(Complex x, Complex y) {
      return x.re == y.re && x.im == y.im;
   }

   public static bool operator !=(Complex x, Complex y) {
      return !(x == y);
   }
}

Poiché Complex è una struttura C#, ossia un tipo di valore, non è possibile ottenere derivazioni; di conseguenza, è necessario che il metodo Equals non confronti i risultati di GetType per ciascun oggetto, ma che possa invece utilizzare l'operatore is per verificare il tipo del parametro obj.

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile per Pocket PC, Windows Mobile per Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework non supporta tutte le versioni di ciascuna piattaforma. Per un elenco delle versioni supportate, vedere Requisiti di sistema.

.NET Framework

Supportato in: 2.0 1.1 1.0

.NET Compact Framework

Supportato in: 2.0 1.0

Aggiunte alla community

AGGIUNGI
Mostra:
© 2015 Microsoft