Introduction aux classes

Types référence

Un type défini en tant que class est un type référence. Au moment de l’exécution, quand vous déclarez une variable d’un type référence, celle-ci contient la valeur null jusqu’à ce que vous créez explicitement une instance de la classe à l’aide de l' new opérateur, ou que vous lui assignez un objet d’un type compatible qui peut avoir été créé ailleurs, comme illustré dans l’exemple suivant :

//Declaring an object of type MyClass.
MyClass mc = new MyClass();

//Declaring another object of the same type, assigning it the value of the first object.
MyClass mc2 = mc;

Quand l’objet est créé, une quantité de mémoire suffisante est allouée sur le tas managé de l’objet spécifié, et la variable contient uniquement une référence à l’emplacement de cet objet. Les types sur le tas managé entraînent une surcharge quand ils sont alloués et récupérés par la fonctionnalité de gestion automatique de la mémoire du CLR (appelée garbage collection). Toutefois, le garbage collection est également optimisé et, dans la plupart des cas, ne nuit pas aux performances. Pour plus d’informations sur le garbage collection, consultez Gestion automatique de la mémoire et garbage collection.

Déclaration de classes

Les classes sont déclarées à l’aide du class mot clé suivi d’un identificateur unique, comme indiqué dans l’exemple suivant :

//[access modifier] - [class] - [identifier]
public class Customer
{
   // Fields, properties, methods and events go here...
}

Le mot clé class est précédé du niveau d’accès. Étant donné que public est utilisé dans ce cas, n’importe qui peut créer des instances de cette classe. Le nom de la classe suit le mot clé class. Le nom de la classe doit être un nom d’identificateur C# valide. Le reste de la définition est le corps de la classe, où le comportement et les données sont définis. Les champs, propriétés, méthodes et événements d’une classe sont désignés collectivement par le terme « membres de classe ».

Création d'objets

Bien qu’ils soient parfois employés indifféremment, une classe et un objet sont deux choses différentes. Une classe définit un type d’objet, mais il ne s’agit pas d’un objet en soi. Un objet, qui est une entité concrète basée sur une classe, est parfois désigné par le terme « instance de classe ».

Les objets peuvent être créés à l’aide du new mot clé, suivi du nom de la classe sur laquelle l’objet sera basé, comme suit :

Customer object1 = new Customer();

Quand une instance d’une classe est créée, une référence à l’objet est repassée au programmeur. Dans l’exemple précédent, object1 est une référence à un objet basé sur Customer. Cette référence fait référence au nouvel objet, mais elle ne contient pas ses données. En fait, vous pouvez créer une référence d’objet sans créer d’objet :

 Customer object2;

Nous vous déconseillons de créer des références d’objet telles que le précédent qui ne fait pas référence à un objet, car toute tentative d’accès à un objet via une telle référence échoue au moment de l’exécution. Toutefois, une telle référence peut être faite pour faire référence à un objet, soit en créant un nouvel objet, soit en lui assignant un objet existant, tel que celui-ci :

Customer object3 = new Customer();
Customer object4 = object3;

Ce code crée deux références d’objet qui font toutes deux référence au même objet. Toute modification apportée à l’objet par le biais de object3 est donc reflétée dans les utilisations suivantes de object4. Les objets qui sont basés sur des classes étant désignés par référence, les classes sont appelées des « types référence ».

Héritage de classe

Les classes prennent entièrement en charge l’héritage, caractéristique fondamentale de la programmation orientée objet. Quand vous créez une classe, vous pouvez hériter de toute autre classe qui n’est pas définie comme sealed , et les autres classes peuvent hériter de votre classe et remplacer les méthodes virtuelles de la classe. En outre, vous pouvez implémenter une ou plusieurs interfaces.

L’héritage se fait par le biais d’une dérivation, ce qui signifie qu’une classe est déclarée à l’aide d’une classe de base dont elle hérite les données et le comportement. Pour spécifier une classe de base, ajoutez deux-points et le nom de la classe de base après le nom de la classe dérivée, comme suit :

public class Manager : Employee
{
    // Employee fields, properties, methods and events are inherited
    // New Manager fields, properties, methods and events go here...
}

Quand une classe déclare une classe de base, elle hérite de tous les membres de la classe de base à l’exception des constructeurs. Pour plus d’informations, consultez Héritage.

Une classe en C# peut uniquement hériter directement d’une classe de base. Toutefois, une classe de base pouvant elle-même hériter d’une autre classe, une classe peut hériter indirectement de plusieurs classes de base. En outre, une classe peut implémenter directement une ou plusieurs interfaces. Pour plus d'informations, consultez Interfaces.

Une classe peut être déclarée abstract . Une classe abstraite contient des méthodes abstraites qui ont une définition de signature, mais aucune implémentation. Les classes abstraites ne peuvent pas être instanciées. Elles peuvent être utilisées uniquement à travers des classes dérivées qui implémentent les méthodes abstraites. En revanche, une classe sealed ne permet pas à d’autres classes de dériver d’elle. Pour plus d’informations, consultez Classes abstract et sealed, et membres de classe.

Les définitions de classe peuvent être fractionnées entre différents fichiers sources. Pour plus d’informations, consultez la page Classes et méthodes partielles.

Exemple

L’exemple suivant définit une classe publique qui contient une propriété implémentée automatiquement, une méthode et une méthode spéciale appelée un constructeur. Pour plus d’informations, consultez les articles sur les Propriétés, les méthodeset les constructeurs . Les instances de la classe sont ensuite instanciées à l’aide du mot clé new.

using System;

public class Person
{
    // Constructor that takes no arguments:
    public Person()
    {
        Name = "unknown";
    }

    // Constructor that takes one argument:
    public Person(string name)
    {
        Name = name;
    }

    // Auto-implemented readonly property:
    public string Name { get; }

    // Method that overrides the base class (System.Object) implementation.
    public override string ToString()
    {
        return Name;
    }
}
class TestPerson
{
    static void Main()
    {
        // Call the constructor that has no parameters.
        var person1 = new Person();
        Console.WriteLine(person1.Name);

        // Call the constructor that has one parameter.
        var person2 = new Person("Sarah Jones");
        Console.WriteLine(person2.Name);
        // Get the string representation of the person2 instance.
        Console.WriteLine(person2);
    }
}
// Output:
// unknown
// Sarah Jones
// Sarah Jones

Spécification du langage C#

Pour plus d'informations, voir la spécification du langage C#. La spécification du langage est la source de référence pour la syntaxe C# et son utilisation.