Object Classe

Définition

Prend en charge toutes les classes de la hiérarchie des classes du .NET et fournit des services de bas niveau à des classes dérivées. Il s'agit de la classe de base fondamentale parmi toutes les classes du .NET. Elle constitue la racine de la hiérarchie des types.

public ref class System::Object
public class Object
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.AutoDual)]
[System.Serializable]
public class Object
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.AutoDual)]
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public class Object
type obj = class
[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.AutoDual)>]
[<System.Serializable>]
type obj = class
[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.AutoDual)>]
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type obj = class
Public Class Object
Attributs

Exemples

L’exemple suivant définit un type point dérivé de la Object classe et substitue la plupart des méthodes virtuelles de la Object classe. En outre, l’exemple montre comment appeler la plupart des méthodes statiques et d’instance de la Object classe.

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.
        var 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 $"({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.
        var p1 = new Point(1,2);

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

        // Make another variable that references the first Point object.
        var 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: {p1.ToString()}");
    }
}

// This code example produces the following output:
//
// False
// True
// True
// p1's value is: (1, 2)
//
using namespace System;

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

public:
    Point(int x, int y)
    {
        this->x = x;
        this->y = y;
    }

public:
    virtual bool Equals(Object^ obj) override
    {
        // 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:
    virtual int GetHashCode() override 
    {
        return x ^ y;
    }

    // Return the point's value as a string.
public:
    virtual String^ ToString() override 
    {
        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();
    }
};

int main()
{
    // Construct a Point object.
    Point^ p1 = gcnew 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)
' The Point class is derived from System.Object.
Class Point
    Public x, y As Integer
    
    Public Sub New(ByVal x As Integer, ByVal y As Integer) 
        Me.x = x
        Me.y = y
    End Sub
    
    Public Overrides Function Equals(ByVal obj As Object) As Boolean 
        ' If Me and obj do not refer to the same type, then they are not equal.
        Dim objType As Type = obj.GetType()
        Dim meType  As Type = Me.GetType()
        If Not objType.Equals(meType) Then
            Return False
        End If 
        ' Return true if  x and y fields match.
        Dim other As Point = CType(obj, Point)
        Return Me.x = other.x AndAlso Me.y = other.y
    End Function 

    ' Return the XOR of the x and y fields.
    Public Overrides Function GetHashCode() As Integer 
        Return (x << 1) XOR y
    End Function 

    ' Return the point's value as a string.
    Public Overrides Function ToString() As String 
        Return $"({x}, {y})"
    End Function

    ' Return a copy of this point object by making a simple field copy.
    Public Function Copy() As Point 
        Return CType(Me.MemberwiseClone(), Point)
    End Function
End Class  

NotInheritable Public Class App
    Shared Sub Main() 
        ' Construct a Point object.
        Dim p1 As New Point(1, 2)
        
        ' Make another Point object that is a copy of the first.
        Dim p2 As Point = p1.Copy()
        
        ' Make another variable that references the first Point object.
        Dim p3 As Point = 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: {p1.ToString()}")
    
    End Sub
End Class
' This example produces the following output:
'
' False
' True
' True
' p1's value is: (1, 2)
'

Remarques

En général, les langages ne requièrent pas une classe pour déclarer l’héritage Object , car l’héritage est implicite.

Étant donné que toutes les classes dans .NET sont dérivées de Object , chaque méthode définie dans la Object classe est disponible dans tous les objets du système. Les classes dérivées peuvent et substituent certaines de ces méthodes, notamment :

  • Equals -Prend en charge les comparaisons entre les objets.

  • Finalize -Effectue des opérations de nettoyage avant qu’un objet soit automatiquement récupéré.

  • GetHashCode -Génère un nombre correspondant à la valeur de l’objet pour prendre en charge l’utilisation d’une table de hachage.

  • ToString : Fabrique une chaîne de texte explicite qui décrit une instance de la classe.

Considérations relatives aux performances

Si vous concevez une classe, telle qu’une collection, qui doit gérer tout type d’objet, vous pouvez créer des membres de classe qui acceptent des instances de la Object classe. Toutefois, le processus de boxing et d’unboxing d’un type entraîne un coût de performance. Si vous savez que votre nouvelle classe gère fréquemment certains types de valeur, vous pouvez utiliser l’une des deux tactiques pour réduire le coût de la conversion boxing.

  • Créez une méthode générale qui accepte un Object type et un ensemble de surcharges de méthode spécifiques au type qui acceptent chaque type de valeur que votre classe doit fréquemment gérer. S’il existe une méthode spécifique au type qui accepte le type de paramètre appelant, aucune conversion boxing ne se produit et la méthode spécifique au type est appelée. S’il n’existe aucun argument de méthode qui correspond au type de paramètre appelant, le paramètre est boxed et la méthode générale est appelée.

  • Concevez votre type et ses membres pour utiliser des génériques. L’common language runtime crée un type générique fermé lorsque vous créez une instance de votre classe et spécifiez un argument de type générique. La méthode générique est spécifique au type et peut être appelée sans Boxing le paramètre appelant.

Bien qu’il soit parfois nécessaire de développer des classes à usage général qui acceptent et retournent des Object types, vous pouvez améliorer les performances en fournissant également une classe spécifique au type pour gérer un type fréquemment utilisé. Par exemple, si vous fournissez une classe spécifique à la définition et à l’obtention de valeurs booléennes, vous éliminez le coût des valeurs booléennes de boxing et unboxing.

Constructeurs

Object()

Initialise une nouvelle instance de la classe Object.

Méthodes

Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.

Equals(Object, Object)

Détermine si les instances d'objet spécifiées sont considérées comme égales.

Finalize()

Autorise un objet à tenter de libérer des ressources et à exécuter d'autres opérations de nettoyage avant qu'il ne soit récupéré par une opération garbage collection.

GetHashCode()

Fait office de fonction de hachage par défaut.

GetType()

Obtient le Type de l'instance actuelle.

MemberwiseClone()

Crée une copie superficielle du Object actuel.

ReferenceEquals(Object, Object)

Détermine si les instances de Object spécifiées sont identiques.

ToString()

Retourne une chaîne qui représente l'objet actuel.

S’applique à

Cohérence de thread

les membres statiques publics ( Shared dans Visual Basic) de ce type sont thread-safe. Il n’est pas garanti que les membres d’instance soient thread-safe.