Classes (Guide de programmation C#)Classes (C# Programming Guide)

Types référenceReference types

Un type défini comme class est un type référence.A type that is defined as a class is a reference type. Au moment de l’exécution, quand vous déclarez une variable de type référence, celle-ci contient la valeur Null tant que vous n’avez pas explicitement créé une instance de la classe à l’aide de l’opérateur new, ou que vous ne lui avez pas assigné un objet existant d’un type compatible, comme indiqué dans l’exemple suivant :At run time, when you declare a variable of a reference type, the variable contains the value null until you explicitly create an instance of the class by using the new operator, or assign it an object of a compatible type that may have been created elsewhere, as shown in the following example:

//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.When the object is created, enough memory is allocated on the managed heap for that specific object, and the variable holds only a reference to the location of said object. 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).Types on the managed heap require overhead both when they are allocated and when they are reclaimed by the automatic memory management functionality of the CLR, which is known as garbage collection. Toutefois, le garbage collection est également optimisé et, dans la plupart des cas, ne nuit pas aux performances.However, garbage collection is also highly optimized and in most scenarios, it does not create a performance issue. Pour plus d’informations sur le garbage collection, consultez Gestion automatique de la mémoire et garbage collection.For more information about garbage collection, see Automatic memory management and garbage collection.

Déclaration de classesDeclaring Classes

Les classes sont déclarées à l’aide du mot clé class suivi d’un identificateur unique, comme l’illustre l’exemple suivant :Classes are declared by using the class keyword followed by a unique identifier, as shown in the following example:

//[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.The class keyword is preceded by the access level. Comme public est utilisé dans ce cas, n’importe qui peut créer des instances de cette classe.Because public is used in this case, anyone can create instances of this class. Le nom de la classe suit le mot clé class.The name of the class follows the class keyword. Le nom de la classe doit être un nom d’identificateur C# valide.The name of the class must be a valid C# identifier name. Le reste de la définition est le corps de la classe, où le comportement et les données sont définis.The remainder of the definition is the class body, where the behavior and data are defined. Les champs, propriétés, méthodes et événements d’une classe sont désignés collectivement par le terme « membres de classe ».Fields, properties, methods, and events on a class are collectively referred to as class members.

Création d’objetsCreating objects

Bien qu’ils soient parfois employés indifféremment, une classe et un objet sont deux choses différentes.Although they are sometimes used interchangeably, a class and an object are different things. Une classe définit un type d’objet, mais il ne s’agit pas d’un objet en soi.A class defines a type of object, but it is not an object itself. Un objet, qui est une entité concrète basée sur une classe, est parfois désigné par le terme « instance de classe ».An object is a concrete entity based on a class, and is sometimes referred to as an instance of a class.

Vous pouvez créer des objets en utilisant le mot clé new suivi du nom de la classe sur laquelle l’objet est basé, comme suit :Objects can be created by using the new keyword followed by the name of the class that the object will be based on, like this:

Customer object1 = new Customer();

Quand une instance d’une classe est créée, une référence à l’objet est repassée au programmeur.When an instance of a class is created, a reference to the object is passed back to the programmer. Dans l’exemple précédent, object1 est une référence à un objet basé sur Customer.In the previous example, object1 is a reference to an object that is based on Customer. Cette référence fait référence au nouvel objet, mais elle ne contient pas ses données.This reference refers to the new object but does not contain the object data itself. En fait, vous pouvez créer une référence d’objet sans créer d’objet :In fact, you can create an object reference without creating an object at all:

 Customer object2;

Nous vous déconseillons de créer des références d’objet comme celle-ci, sans référence à un objet, car toute tentative d’accès à un objet à l’aide d’une telle référence échoue au moment de l’exécution.We don't recommend creating object references such as this one that don't refer to an object because trying to access an object through such a reference will fail at run time. Vous pouvez toutefois créer une telle référence pour faire référence à un objet : soit en créant un objet, soit en l’assignant à un objet existant, comme suit :However, such a reference can be made to refer to an object, either by creating a new object, or by assigning it to an existing object, such as this:

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.This code creates two object references that both refer to the same object. Toute modification apportée à l’objet par le biais de object3 est donc reflétée dans les utilisations suivantes de object4.Therefore, any changes to the object made through object3 are reflected in subsequent uses of 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 ».Because objects that are based on classes are referred to by reference, classes are known as reference types.

Héritage de classeClass inheritance

Les classes prennent entièrement en charge l’héritage, caractéristique fondamentale de la programmation orientée objet.Classes fully support inheritance, a fundamental characteristic of object-oriented programming. Quand vous créez une classe, vous pouvez hériter de toute autre interface ou classe qui n’est pas définie comme sealed, et d’autres classes peuvent hériter de votre classe et substituer des méthodes virtuelles de la classe.When you create a class, you can inherit from any other interface or class that is not defined as sealed, and other classes can inherit from your class and override class virtual methods.

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.Inheritance is accomplished by using a derivation, which means a class is declared by using a base class from which it inherits data and behavior. 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 :A base class is specified by appending a colon and the name of the base class following the derived class name, like this:

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.When a class declares a base class, it inherits all the members of the base class except the constructors. Pour plus d’informations, consultez Héritage.For more information, see Inheritance.

Contrairement à C++, une classe en C# ne peut hériter directement que d’une classe de base.Unlike C++, a class in C# can only directly inherit from one base class. 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.However, because a base class may itself inherit from another class, a class may indirectly inherit multiple base classes. En outre, une classe peut implémenter directement plusieurs interfaces.Furthermore, a class can directly implement more than one interface. Pour plus d’informations, consultez Interfaces.For more information, see Interfaces.

Une classe peut être déclarée abstract.A class can be declared abstract. Une classe abstraite contient des méthodes abstraites qui ont une définition de signature, mais aucune implémentation.An abstract class contains abstract methods that have a signature definition but no implementation. Les classes abstraites ne peuvent pas être instanciées.Abstract classes cannot be instantiated. Elles peuvent être utilisées uniquement à travers des classes dérivées qui implémentent les méthodes abstraites.They can only be used through derived classes that implement the abstract methods. En revanche, une classe sealed ne permet pas à d’autres classes de dériver d’elle.By contrast, a sealed class does not allow other classes to derive from it. Pour plus d’informations, consultez la page Classes abstraites et scellées et membres de classe.For more information, see Abstract and Sealed Classes and Class Members.

Les définitions de classe peuvent être fractionnées entre différents fichiers sources.Class definitions can be split between different source files. Pour plus d’informations, consultez Classes et méthodes partielles.For more information, see Partial Classes and Methods.

ExempleExample

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.The following example defines a public class that contains an auto-implemented property, a method, and a special method called a constructor. Pour plus d’informations, consultez les rubriques Propriétés, Méthodes et Constructeurs.For more information, see Properties, Methods, and Constructors topics. Les instances de la classe sont ensuite instanciées à l’aide du mot clé new.The instances of the class are then instantiated with the new keyword.

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);

        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }
}
// Output:
// unknown
// Sarah Jones
// Sarah Jones

Spécification du langage C#C# Language Specification

Pour plus d'informations, voir la spécification du langage C#.For more information, see the C# Language Specification. La spécification du langage est la source de référence pour la syntaxe C# et son utilisation.The language specification is the definitive source for C# syntax and usage.

Voir aussiSee also