Esporta (0) Stampa
Espandi tutto
Il presente articolo è stato tradotto automaticamente. Passare il puntatore sulle frasi nell'articolo per visualizzare il testo originale. Ulteriori informazioni.
Traduzione
Originale

Metodo Object.Equals (Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.

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

public virtual bool Equals(
	Object obj
)

Parametri

obj
Tipo: System.Object
Oggetto da confrontare con l'oggetto corrente.

Valore restituito

Tipo: System.Boolean
true se l'oggetto specificato è uguale all'oggetto corrente; in caso contrario, false.

Il tipo di confronto tra l'istanza corrente e il parametro obj dipende da se l'istanza corrente è un tipo di riferimento o un tipo di valore.

  • Se l'istanza corrente è un tipo di riferimento, il metodo Equals(Object) eseguirà un test sull'uguaglianza dei riferimenti e una chiamata al metodo Equals(Object) sarà equivalente a una chiamata al metodo ReferenceEquals. L'uguaglianza dei riferimenti significa che le variabili degli oggetti confrontati si riferiscono allo stesso oggetto. Nell'esempio seguente viene illustrato il risultato di tale confronto. Definisce una classe Person, che è un tipo di riferimento e chiama il costruttore di classe Person per istanziare due nuovi oggetti Person, person1a e person2, i quali hanno lo stesso valore. Viene inoltre assegnato person1a a un'altra variabile oggetto, person1b. Come mostrato nell'esempio, person1a e person1b risultano uguali perché fanno riferimento allo stesso oggetto. Comunque, person1a e person2 non sono uguali, anche se hanno lo stesso valore.

    
    using System;
    
    // Define a reference type that does not override Equals.
    public class Person
    {
       private string personName;
    
       public Person(string name)
       {
          this.personName = name;
       }
    
       public override string ToString()
       {
          return this.personName;
       }
    }
    
    public class Example
    {
       public static void Main()
       {
          Person person1a = new Person("John");
          Person person1b = person1a;
          Person person2 = new Person(person1a.ToString());
    
          Console.WriteLine("Calling Equals:"); 
          Console.WriteLine("person1a and person1b: {0}", person1a.Equals(person1b));               
          Console.WriteLine("person1a and person2: {0}", person1a.Equals(person2));  
    
          Console.WriteLine("\nCasting to an Object and calling Equals:");
          Console.WriteLine("person1a and person1b: {0}", ((object) person1a).Equals((object) person1b));
          Console.WriteLine("person1a and person2: {0}", ((object) person1a).Equals((object) person2)); 
       }
    }
    // The example displays the following output:
    //       person1a and person1b: True
    //       person1a and person2: False
    //       
    //       Casting to an Object and calling Equals:
    //       person1a and person1b: True
    //       person1a and person2: False
    
    
    
  • Se l'istanza corrente è un tipo di valore, il metodo Equals(Object) eseguirà un test sull'uguaglianza dei valori. L'uguaglianza dei valori significa quanto segue:

    • I due oggetti sono dello stesso tipo. Come mostrato nell'esempio, un oggetto Byte che ha un valore 12 non equivale a un oggetto Int32 che ha un valore di 12, poiché i due oggetti hanno tipi di runtime diversi.

      
      using System;
      
      public class Example
      {
         public static void Main()
         {
            byte value1 = 12;
            int value2 = 12;
      
            object object1 = value1;
            object object2 = value2;
      
            Console.WriteLine("{0} ({1}) = {2} ({3}): {4}",
                              object1, object1.GetType().Name,
                              object2, object2.GetType().Name,
                              object1.Equals(object2));
         }
      }
      // The example displays the following output:
      //        12 (Byte) = 12 (Int32): False
      
      
      
    • I valori dei campi pubblici e privati dei due oggetti sono uguali. Il seguente esempio controlla l'uguaglianza di valori. Definisce una struttura Person, che è un tipo di valore e chiama il costruttore di classe Person per istanziare due nuovi oggetti Person, person1 e person2, i quali hanno lo stesso valore. Come mostra il risultato dell'esempio, sebbene le due variabili fanno riferimento a oggetti diversi, person1 e person2 risultano uguali in quanto hanno lo stesso valore nel campo privato personName.

      
      using System;
      
      // Define a value type that does not override Equals.
      public struct Person
      {
         private string personName;
      
         public Person(string name)
         {
            this.personName = name;
         }
      
         public override string ToString()
         {
            return this.personName;
         }
      }
      
      public struct Example
      {
         public static void Main()
         {
            Person person1 = new Person("John");
            Person person2 = new Person("John");
      
            Console.WriteLine("Calling Equals:"); 
            Console.WriteLine(person1.Equals(person2)); 
      
            Console.WriteLine("\nCasting to an Object and calling Equals:");
            Console.WriteLine(((object) person1).Equals((object) person2));  
         }
      }
      // The example displays the following output:
      //       Calling Equals:
      //       True
      //       
      //       Casting to an Object and calling Equals:
      //       True
      
      
      

Poiché la classe Object è la classe base per tutti i tipi in .NET Framework, il metodo Object.Equals(Object) fornisce il confronto di uguaglianza predefinito per tutti gli altri tipi. Tuttavia, i tipi spesso fanno l'override del metodo Equals per implementare l'uguaglianza di valori. Per ulteriori informazioni, vedere le Note per i chiamanti e Note per le sezioni degli eredi.

Note per il Windows Runtime

Quando si chiama l'overload del metodo Equals(Object) su una classe nel Windows Runtime, fornisce il comportamento predefinito per le classi che non superano Equals(Object). Ciò fa parte del supporto fornito da .NET Framework per Windows Runtime (vedere Supporto .NET Framework per applicazioni Windows Store e Windows Runtime. In Windows Runtime le classi non ereditano Object e attualmente non implementano un metodo Equals(Object). Tuttavia, sembrano avere i metodi ToString, Equals(Object) e GetHashCode quando vengono utilizzati nel codice C# o Visual Basic, e .NET Framework fornisce il comportamento predefinito per tali metodi.

NotaNota

Le classi Windows Runtime scritte in C# o in Visual Basic possono eseguire l'override dell'overload del metodo Equals(Object).

Note per i chiamanti

Le classi derivate eseguono di frequente l'override del metodo Object.Equals(Object) per implementare l'uguaglianza di valori. Inoltre, i tipi forniscono spesso un overload fortemente tipizzato aggiuntivo al metodo Equals, in genere implementando l'interfaccia IEquatable<T>. Quando si chiama il metodo Equals per verificare l'uguaglianza, è necessario sapere se l'istanza corrente esegue l'override del metodo Object.Equals e comprendere come una particolare chiamata a un metodo Equals viene risolta. In caso contrario, è possibile eseguire un test di uguaglianza che è diverso da quello desiderato e il metodo per restituire un valore imprevisto.

Nell'esempio seguente viene illustrato questo concetto. Crea un'istanza di tre oggetti StringBuilder con stringhe identiche e quindi esegue quattro chiamate ai metodi Equals. La prima chiamata al metodo restituisce truee le tre rimanenti false.


using System;
using System.Text;

public class Example
{
   public static void Main()
   {
      StringBuilder sb1 = new StringBuilder("building a string...");
      StringBuilder sb2 = new StringBuilder("building a string...");

      Console.WriteLine("sb1.Equals(sb2): {0}", sb1.Equals(sb2));
      Console.WriteLine("((Object) sb1).Equals(sb2): {0}", 
                        ((Object) sb1).Equals(sb2));
      Console.WriteLine("Object.Equals(sb1, sb2): {0}",
                        Object.Equals(sb1, sb2));      

      Object sb3 = new StringBuilder("building a string...");
      Console.WriteLine("\nsb3.Equals(sb2): {0}", sb3.Equals(sb2));                              
   }
}
// The example displays the following output:
//       sb1.Equals(sb2): True
//       ((Object) sb1).Equals(sb2): False
//       Object.Equals(sb1, sb2): False
//
//       sb3.Equals(sb2): False


Nel primo caso, viene chiamato l'overload del metodo fortemente tipizzato StringBuilder.Equals(StringBuilder), che testa l'uguaglianza di valori. Poiché le stringhe assegnate a due oggetti StringBuilder sono uguali, il metodo restituisce true. Tuttavia, StringBuilder non esegue l'override di Object.Equals(Object). Per questo motivo, quando viene eseguito il cast dell'oggetto StringBuilder a un Object, quando un'istanza di StringBuilder viene assegnata a una variabile di tipo Object e quando il metodo Object.Equals(Object, Object) e quando vengono passati due oggetti StringBuilder, il metodo predefinito Object.Equals(Object) viene chiamato. Poiché StringBuilder è un tipo di riferimento, questo è equivalente a passare i due oggetti StringBuilder al metodo ReferenceEquals. Sebbene tutti e tre gli oggetti StringBuilder contengano stringhe identiche, fanno riferimento a tre oggetti distinti. Di conseguenza, queste tre chiamate al metodo restituiscono false.

È possibile confrontare l'oggetto corrente con un altro oggetto per l'uguaglianza dei riferimenti chiamando il metodo ReferenceEquals. In Visual Basic è possibile utilizzare anche la parola chiave is (ad esempio If Me Is otherObject Then ...).

Note per gli eredi

Quando si definisce un tipo, il tipo eredita le funzionalità definite dal metodo Equals del suo tipo base. Nella tabella seguente è elencata l'implementazione predefinita del metodo Equals per le categorie principali dei tipi in .NET Framework.

Categoria del tipo

Uguaglianza definita da

Commenti

Classe derivata direttamente da Object

Object.Equals(Object)

Uguaglianza dei riferimenti; equivalente alla chiamata di Object.ReferenceEquals.

Struttura

ValueType.Equals

Uguaglianza di valori; confronto diretto byte per byte o campo per campo tramite reflection.

Enumerazione

Enum.Equals

I valori devono avere lo stesso tipo di enumerazione e lo stesso valore sottostante.

delegate

MulticastDelegate.Equals

I delegati devono avere lo stesso tipo con gli elenchi di invocazione identici.

Interfaccia

Object.Equals(Object)

Uguaglianza di riferimenti.

Per un tipo di valore, è sempre necessario eseguire l'override di Equals, perché verifica l'uguaglianza basata su reflection che offre scarse prestazioni. È inoltre possibile eseguire l'override dell'implementazione predefinita di Equals per i tipi di riferimento per verificare l'uguaglianza di valori anziché l'uguaglianza dei riferimenti e per definire il significato esatto dell'uguaglianza di valori. Tali implementazioni di Equals restituiscono true se i due oggetti hanno lo stesso valore, anche se non sono la stessa istanza. L'implementatore di tipo stabilisce ciò che costituirà il valore di un oggetto, ma in genere si tratta di una 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 String.Equals(Object) esegue l'override del metodo Object.Equals(Object) per restituire true per ogni due istanze di stringa contenenti esattamente gli stessi caratteri nello stesso ordine.

Di seguito viene illustrato come eseguire l'override del metodo Object.Equals(Object) per verificare l'uguaglianza di valori. Esegue l'override del metodo Equals per la classe Person. Se Person accetta la sua implementazione della classe base di uguaglianza, due oggetti Person sono uguali solo se fanno riferimento a un singolo oggetto. Tuttavia, in questo caso, due oggetti Person sono uguali se hanno lo stesso valore per la proprietà Person.Id.


public class Person
{
   private string idNumber;
   private string personName;

   public Person(string name, string id)
   {
      this.personName = name;
      this.idNumber = id;
   }

   public override bool Equals(Object obj)
   {
      Person personObj = obj as Person; 
      if (personObj == null)
         return false;
      else
         return idNumber.Equals(personObj.idNumber);
   }

   public override int GetHashCode()
   {
      return this.idNumber.GetHashCode(); 
   }
}

public class Example
{
   public static void Main()
   {
      Person p1 = new Person("John", "63412895");
      Person p2 = new Person("Jack", "63412895");
      Console.WriteLine(p1.Equals(p2));
      Console.WriteLine(Object.Equals(p1, p2));
   }
}
// The example displays the following output:
//       True
//       True


Oltre a eseguire l'override di Equals, è possibile implementare l'interfaccia IEquatable<T> per fornire un test fortemente tipizzato di uguaglianza.

Le seguenti istruzioni devono essere true per tutte le implementazioni del metodo Equals(Object). Nell'elenco, x, y e z rappresentano riferimenti ad oggetti che non sono null.

  • x.Equals(x) restituisce true, tranne nei casi in cui sono compresi tipi a virgola mobile. Vedere ISO/IEC/IEEE 60559:2011, Information technology -- Microprocessor Systems -- Floating-Point arithmetic.

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

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

  • Se (x.Equals(y) && y.Equals(z)) restituisce true, anche x.Equals(z) restituisce true.

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

  • Il metodo x.Equals(null) restituisce il valore false.

Le implementazioni di Equals non devono generare eccezioni; devono sempre restituire un valore. Ad esempio, se obj è null, il metodo Equals deve restituire false anziché generare un ArgumentNullException.

Seguire queste linee guida quando si esegue l'override di Equals(Object):

  • I tipi che implementano l'interfaccia IComparable devono eseguire l'override del metodo Equals(Object).

  • I tipi che eseguono l'override di Equals(Object) devono anche eseguire l'override di GetHashCode; altrimenti, le tabelle hash possono non funzionare correttamente.

  • Si consiglia di implementare l'interfaccia IEquatable<T> per supportare i test fortemente tipizzati per uguaglianza. L'implementazione di IEquatable<T>.Equals deve restituire risultati coerenti con Equals.

  • Se gli overload degli operatori sono supportati dal linguaggio di programmazione si esegue l'overload dell'operatore di uguaglianza per un tipo specificato, è anche necessario eseguire l'override del metodo Equals(Object) per ottenere lo stesso risultato dell'operatore di uguaglianza. Ciò consente di garantire che il codice della libreria di classi che utilizza Equals (come ArrayList e Hashtable) si comporti in modo coerente con la modalità in cui l'operatore di uguaglianza è utilizzato dal codice dell'applicazione.

bsc2ak47.collapse_all(it-it,VS.110).gifLinee guida per i tipi di riferimento

Le linee guida seguenti si applicano all'override di Equals(Object) per un tipo di riferimento:

  • Considerare l'override di Equals 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.

  • Non è necessario eseguire l'override di Equals su un tipo di riferimento modificabile. Questo perché eseguire l'override di Equals richiede che venga eseguito anche l'override del metodo GetHashCode, come descritto nella sezione precedente. Ciò significa che il codice hash di un'istanza di un tipo di riferimento modificabile può cambiare durante il suo tempo di vita, il che può far si che l'oggetto venga perduto in una tabella hash.

bsc2ak47.collapse_all(it-it,VS.110).gifLinee guida per i tipi di valore

Le linee guida seguenti si applicano per eseguire l'override di Equals(Object) per un tipo di valore:

  • Se si definisce un tipo di valore che include uno o più campi i cui valori sono tipi di riferimento, eseguire l'override di Equals(Object). L'implementazione Equals(Object) fornita da ValueType esegue un confronto byte per byte per i tipi di valore i cui campi sono tutti tipi di valore, ma utilizza reflection per eseguire un confronto campo per campo di tipi di valori i cui campi includono i tipi di riferimento.

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

  • Implementare l'interfaccia IEquatable<T>. La chiamata al metodo fortemente tipizzato IEquatable<T>.Equals evita il boxing dell'argomento obj.

L'esempio seguente mostra una classe Point che esegue l'override del metodo Equals per fornire l'uguaglianza di valore e una classe Point3D derivata da Point. Poiché Point esegue l'override di Object.Equals(Object) per verificare l'uguaglianza di valori, il metodo Object.Equals(Object) non viene chiamato. Ciononostante, Point3D.Equals chiama Point.Equals perché Point implementa Object.Equals(Object) in un modo che consente l'uguaglianza di valori.


using System;

class Point
{
   protected int x, y;

   public Point() : this(0, 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) || ! this.GetType().Equals(obj.GetType())) {
         return false;
      }
      else { 
         Point p = (Point) obj; 
         return (x == p.x) && (y == p.y);
      }   
   }

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

    public override string ToString()
    {
        return String.Format("Point({0}, {1})", x, y);
    }
}

sealed class Point3D: Point 
{
   int z;

   public Point3D(int x, int y, int z) : base(x, y) 
   {
      this.z = z; 
   }

   public override bool Equals(Object obj) 
   {
      Point3D pt3 = obj as Point3D;
      if (pt3 == null)
         return false;
      else
         return base.Equals((Point)obj) && z == pt3.z;
   }

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

   public override String ToString() 
   {
        return String.Format("Point({0}, {1}, {2})", x, y, z);
    }
}

class Example 
{
  public static void Main() 
  {
     Point point2D = new Point(5, 5);
     Point3D point3Da = new Point3D(5, 5, 2);
     Point3D point3Db = new Point3D(5, 5, 2);
     Point3D point3Dc = new Point3D(5, 5, -1);

     Console.WriteLine("{0} = {1}: {2}", 
                       point2D, point3Da, point2D.Equals(point3Da));
     Console.WriteLine("{0} = {1}: {2}", 
                       point2D, point3Db, point2D.Equals(point3Db));        
     Console.WriteLine("{0} = {1}: {2}", 
                       point3Da, point3Db, point3Da.Equals(point3Db));
     Console.WriteLine("{0} = {1}: {2}", 
                       point3Da, point3Dc, point3Da.Equals(point3Dc));
  } 
}
// The example displays the following output:
//       Point(5, 5) = Point(5, 5, 2): False
//       Point(5, 5) = Point(5, 5, 2): False
//       Point(5, 5, 2) = Point(5, 5, 2): True
//       Point(5, 5, 2) = Point(5, 5, -1): False


Il metodo Point.Equals controlla che l'argomento obj non sia null e che faccia riferimento a un'istanza dello stesso tipo dell'oggetto. Se il controllo ha esito negativo, il metodo restituisce false.

Il metodo Point.Equals chiama il metodo GetType per determinare se i tipi in fase di esecuzione dei due oggetti sono identici. Se il metodo ha utilizzato un controllo del formato obj is Point in C# o TryCast(obj, Point) in Visual Basic, 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 a 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 i campi di istanza dei due oggetti.

In Point3D.Equals, il metodo ereditato Point.Equals, che esegue l'override Object.Equals(Object), viene invocato prima che qualsiasi altra attività venga completata. Poiché Point3D è una classe sealed (NotInheritable in Visual Basic), un controllo nel form obj is Point in C# o TryCast(obj, Point) in Visual Basic è opportuno per garantire che obj è un oggetto Point3D. Se è un oggetto Point3D, esegue il cast a un oggetto Point e viene passato all'implementazione della classe base di Equals. Soltanto quando il metodo ereditato Point.Equals restituisce true, vengono confrontati i campi di istanza z introdotte nella classe derivata.

Nell'esempio seguente viene definita una classe Rectangle che internamente implementa un rettangolo come due oggetti Point. La classe Rectangle esegue l'override di Object.Equals(Object) per fornire l'uguaglianza di valori.


using System;

class Rectangle 
{
   private 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) {
      // Perform an equality check on two rectangles (Point object pairs).
      if (obj == null || GetType() != obj.GetType()) 
          return false;
      Rectangle r = (Rectangle)obj;
      return a.Equals(r.a) && b.Equals(r.b);
   }

   public override int GetHashCode() {
      return Tuple.Create(a, b).GetHashCode();
   }

    public override String ToString() 
    {
       return String.Format("Rectangle({0}, {1}, {2}, {3})",
                            a.x, a.y, b.x, b.y); 
    }
}

class Point 
{
  internal int x;
  internal int y;

  public Point(int X, int Y) {
     this.x = X;
     this.y = Y;
  }

  public override bool Equals (Object obj) {
     // Performs an equality check on two points (integer pairs).
     if (obj == null || GetType() != obj.GetType()) return false;
     Point p = (Point)obj;
     return (x == p.x) && (y == p.y);
  }

  public override int GetHashCode() {
     return Tuple.Create(x, y).GetHashCode();
  }
}

class Example 
{
   public static void Main() 
   {
      Rectangle r1 = new Rectangle(0, 0, 100, 200);
      Rectangle r2 = new Rectangle(0, 0, 100, 200);
      Rectangle r3 = new Rectangle(0, 0, 150, 200);

      Console.WriteLine("{0} = {1}: {2}", r1, r2, r1.Equals(r2));
      Console.WriteLine("{0} = {1}: {2}", r1, r3, r1.Equals(r3));
      Console.WriteLine("{0} = {1}: {2}", r2, r3, r2.Equals(r3));
   }
}
// The example displays the following output:
//    Rectangle(0, 0, 100, 200) = Rectangle(0, 0, 100, 200): True
//    Rectangle(0, 0, 100, 200) = Rectangle(0, 0, 150, 200): False
//    Rectangle(0, 0, 100, 200) = Rectangle(0, 0, 150, 200): False


Alcuni linguaggi come C# e Visual Basic supportano l'overload degli operatori. Quando un tipo esegue l'overload dell'operatore di uguaglianza, deve anche eseguire l'override del metodo Equals(Object) per fornire la stessa funzionalità. Questo risultato in genere si ottiene scrivendo il metodo Equals(Object) nei termini dell'operatore di uguaglianza sottoposto a overload, come nell'esempio riportato di seguito.


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 Tuple.Create(re, 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);
   }

    public override String ToString()
    {
       return String.Format("({0}, {1})", re, im);
    } 
}

class MyClass 
{
  public static void Main() 
  {
    Complex cmplx1, cmplx2;

    cmplx1.re = 4.0;
    cmplx1.im = 1.0;

    cmplx2.re = 2.0;
    cmplx2.im = 1.0;

    Console.WriteLine("{0} <> {1}: {2}", cmplx1, cmplx2, cmplx1 != cmplx2);        
    Console.WriteLine("{0} = {1}: {2}", cmplx1, cmplx2, cmplx1.Equals(cmplx2));        

    cmplx2.re = 4.0;

    Console.WriteLine("{0} = {1}: {2}", cmplx1, cmplx2, cmplx1 == cmplx2);        
    Console.WriteLine("{0} = {1}: {2}", cmplx1, cmplx2, cmplx1.Equals(cmplx2));          
  }
}
// The example displays the following output:
//       (4, 1) <> (2, 1): True
//       (4, 1) = (2, 1): False
//       (4, 1) = (4, 1): True
//       (4, 1) = (4, 1): True


Poiché Complex è un tipo di valore, non può essere derivato. Pertanto, un override del metodo Equals(Object) non necessita di chiamare GetType per determinare il tipo a runtime preciso di ogni oggetto, ma può invece utilizzare l'operatore is in C# o l'operatore TypeOf in Visual Basic per controllare il tipo del parametro obj.

.NET Framework

Supportato in: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Supportato in: 4, 3.5 SP1

Libreria di classi portabile

Supportato in: Libreria di classi portabile

.NET per applicazioni Windows Store

Supportato in: Windows 8

.NET per applicazioni Windows Phone

Supportato in: Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (ruoli di base del server non supportati), Windows Server 2008 R2 (ruoli di base del server supportati con SP1 o versione successiva, Itanium non supportato)

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

Aggiunte alla community

AGGIUNGI
Mostra:
© 2015 Microsoft