Questa documentazione è stata archiviata e non viene gestita.

Classe Object

Supporta tutte classi della gerarchia di classi .NET Framework e fornisce servizi di basso livello alle classi derivate. Questa è la principale classe base di tutte le classi di .NET Framework e rappresenta il primo livello della gerarchia dei tipi.

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

[SerializableAttribute] 
[ComVisibleAttribute(true)] 
[ClassInterfaceAttribute(ClassInterfaceType.AutoDual)] 
public class Object
/** @attribute SerializableAttribute() */ 
/** @attribute ComVisibleAttribute(true) */ 
/** @attribute ClassInterfaceAttribute(ClassInterfaceType.AutoDual) */ 
public class Object
SerializableAttribute 
ComVisibleAttribute(true) 
ClassInterfaceAttribute(ClassInterfaceType.AutoDual) 
public class Object

In genere, nei linguaggi non è necessario che una classe dichiari l'eredità da Object, perché questa è implicita.

Poiché tutte le classi di .NET Framework derivano da Object, ogni metodo definito nella classe Object è disponibile in tutti gli oggetti del sistema. Le classi derivate possono eseguire ed eseguono l'override di alcuni dei seguenti metodi:

  • Equals - consente il confronto tra oggetti.

  • Finalize - esegue operazioni di pulitura prima che un oggetto venga recuperato automaticamente.

  • GetHashCode - genera un numero corrispondente al valore dell'oggetto con il quale supportare la tabella hash.

  • ToString - produce una stringa di testo in formato leggibile che descrive un'istanza della classe.

Considerazioni sulle prestazioni

Se si progetta una classe, quale ad esempio un insieme in grado di gestire qualsiasi tipo di oggetto, è possibile creare membri della classe che accettano istanze della classe Object. I processi di boxing e unboxing di un tipo incidono tuttavia sulle prestazioni. Se si è certi che la classe dovrà gestire frequentemente determinati tipi di valore, si può adottare una delle due soluzioni illustrate di seguito per ridurre al minimo l'incidenza del boxing.

La prima soluzione consiste nella creazione di un metodo generale che accetta un tipo Object e di un gruppo di overload del metodo, specifico per il tipo, che accetta ogni tipo di valore di cui si prevede la gestione frequente da parte della classe. Se esiste un metodo specifico per il tipo che accetta il tipo di parametro della chiamata, non si verifica il boxing e viene richiamato il metodo specifico per il tipo. Se non esiste un argomento del metodo che corrisponde al tipo di parametro della chiamata, viene eseguito il boxing del parametro e viene invocato il metodo generale. Adottando questa soluzione vengono prodotti metodi conformi CLS.

La seconda soluzione consiste nella progettazione della classe e dei relativi metodi per l'utilizzo di generics. In Common Language Runtime, quando si crea un'istanza della classe e si specifica un argomento di tipo generico, viene creato un tipo generico chiuso. Il metodo generico è specifico per il tipo e può essere richiamato senza procedere al boxing del parametro della chiamata. Adottando questa soluzione vengono prodotti metodi non conformi CLS in .NET Framework versione 2.0.

Nell'esempio riportato di seguito viene definito un tipo Point derivato dalla classe Object e viene eseguito l'override di molti dei metodi virtuali della classe Object. Nell'esempio viene illustrata inoltre la procedura di chiamata per molti metodi statici e istanze della classe Object.

using System;

// The Point class is derived from System.Object.
class Point 
{
    public int x, y;

    public Point(int x, int y) 
    {
        this.x = x;
        this.y = y;
    }
    
    public override bool Equals(object obj) 
    {
        // If this and obj do not refer to the same type, then they are not equal.
        if (obj.GetType() != this.GetType()) return false;

        // Return true if  x and y fields match.
        Point other = (Point) obj;
        return (this.x == other.x) && (this.y == other.y);
    }

    // Return the XOR of the x and y fields.
    public override int GetHashCode() 
    {
        return x ^ y;
    }

    // Return the point's value as a string.
    public override String ToString() 
    {
        return String.Format("({0}, {1})", x, y);
    }

    // Return a copy of this point object by making a simple field copy.
    public Point Copy() 
    {
        return (Point) this.MemberwiseClone();
    }
}

public sealed class App {
    static void Main() 
    {
        // Construct a Point object.
        Point p1 = new Point(1,2);

        // Make another Point object that is a copy of the first.
        Point p2 = p1.Copy();

        // Make another variable that references the first Point object.
        Point p3 = p1;

        // The line below displays false because p1 and p2 refer to two different objects.
        Console.WriteLine(Object.ReferenceEquals(p1, p2));

        // The line below displays true because p1 and p2 refer to two different objects that have the same value.
        Console.WriteLine(Object.Equals(p1, p2));
      
        // The line below displays true because p1 and p3 refer to one object.
        Console.WriteLine(Object.ReferenceEquals(p1, p3));
        
        // The line below displays: p1's value is: (1, 2)
        Console.WriteLine("p1's value is: {0}", p1.ToString());
    }
}

// This code produces the following output.
//
// False
// True
// True
// p1's value is: (1, 2)

I membri public static, Shared in Visual Basic, di questo tipo sono sicuri per le operazioni con multithreading. I membri di istanza, invece, non sono necessariamente thread-safe.

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
Mostra: