Exporter (0) Imprimer
Développer tout

Object, classe

Prend en charge toutes les classes de la hiérarchie des classes du .NET Framework 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 Framework. Elle constitue la racine de la hiérarchie des types.

Espace de noms : System
Assembly : mscorlib (dans 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

Les langages n'exigent généralement pas qu'une classe déclare l'héritage de Object, car l'héritage est implicite.

Comme toutes les classes du .NET Framework sont dérivées de Object, toutes les méthodes définies dans la classe Object sont disponibles dans la totalité des objets du système. Les classes dérivées peuvent substituer certaines de ces méthodes, notamment :

  • Equals - Prend en charge les comparaisons entre 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 sur les performances

Si vous concevez une classe, une collection par exemple, qui doit gérer tout type d'objet, vous pouvez créer des membres de classe qui acceptent des instances de la classe Object. Toutefois, le processus de conversion boxing et de conversion unboxing d'un type a une incidence sur les performances. Si vous savez que votre nouvelle classe devra souvent gérer certains types valeur, vous pouvez utiliser l'une de deux solutions suivante pour réduire l'impact sur les performances.

La première consiste à créer une méthode générale qui accepte un type Object, et un ensemble de surcharges de méthodes spécifiques au type qui acceptent chaque type valeur que votre classe est appelée à gérer souvent. S'il existe une méthode spécifique au type qui accepte le type de paramètre appelant, la conversion boxing n'est pas effectuée et la méthode spécifique au type est appelée. En l'absence d'un argument de méthode correspondant au type de paramètre appelant, le paramètre est converti (boxing) et la méthode générale appelée. Cette solution permet de créer des méthodes conformes CLS.

L'autre solution consiste à concevoir votre classe et ses méthodes de telle sorte qu'elles utilisent des génériques. Le Common Language Runtime crée un type générique fermé lorsque vous créez une instance de votre classe et que vous 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 convertir (boxing) le paramètre appelant. Cette solution donne des méthodes non conformes CLS dans le .NET Framework version 2.0.

L'exemple suivant définit un type Point dérivé de la classe Object et substitue un grand nombre des méthodes virtuelles de la classe Object. Par ailleurs, l'exemple montre comment appeler la plupart des méthodes statiques et d'instance de la 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)

Les membres statiques publics (Shared en Visual Basic) de ce type sont sécurisés pour les opérations multithread. Il n'est pas garanti que les membres d'instance soient thread-safe.

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile pour Pocket PC, Windows Mobile pour Smartphone, Windows Server 2003, Windows XP Édition Media Center, Windows XP Professionnel Édition x64, Windows XP SP2, Windows XP Starter Edition

Le .NET Framework ne prend pas en charge toutes les versions de chaque plate-forme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise.

.NET Framework

Prise en charge dans : 2.0, 1.1, 1.0

.NET Compact Framework

Prise en charge dans : 2.0, 1.0

Ajouts de la communauté

AJOUTER
Afficher:
© 2014 Microsoft