Classes C#

Une classe est un type de référence qui définit un blueprint pour les objets. Lorsque vous créez une variable d’un type de classe, la variable contient une référence à un objet sur le tas managé. La variable ne contient pas les données d’objet elle-même. L’affectation d’une variable de classe à une autre variable copie la référence, de sorte que les deux variables pointent vers le même objet. Les classes sont la façon la plus courante de définir des types personnalisés en C#. Utilisez-les lorsque vous avez besoin d’un comportement complexe, d’un héritage ou d’une identité partagée entre des références.

Quand utiliser des classes

Utilisez une classe quand :

• Le type a un comportement complexe ou gère l’état mutable.
• Vous avez besoin d’héritage pour créer une classe de base avec des spécialisations dérivées ou pour créer un type dérivé qui étend une classe existante.
• Les instances représentent une identité partagée, et non des objets qui contiennent des valeurs égales. Deux références au même objet doivent rester synchronisées.
• Le type est volumineux ou de longue durée et bénéficie de l’allocation de tas et de la sémantique de référence.

Déclarer une classe

Définissez une classe avec le class mot clé suivi du nom de type. Un modificateur d’accès facultatif contrôle la visibilité. La valeur par défaut est internal. Spécifiez public pour autoriser les appelants d’autres assemblys à utiliser vos types.

public class Customer
{
    public string Name { get; set; }

    public Customer(string name) => Name = name;
}

Le corps de classe contient des champs, des propriétés, des méthodes et des événements, collectivement appelés membres de classe. Le nom doit être un nom d’identificateur C# valide.

Créer des objets

Une classe définit un type, mais n’est pas un objet lui-même. Vous créez un objet ( instance de la classe) avec le new mot clé :

var customer = new Customer("Allison");
Console.WriteLine(customer.Name); // Allison

La variable customer contient une référence à l’objet, et non à l’objet lui-même. Vous pouvez affecter plusieurs variables au même objet. Les modifications par le biais d’une référence sont visibles par l’autre :

var c1 = new Customer("Grace");
var c2 = c1; // both variables reference the same object

c2.Name = "Hopper";
Console.WriteLine(c1.Name); // Hopper — c1 sees the change made through c2

Ce comportement de partage de référence est une distinction entre les classes et les structs. Avec des structures, l’affectation copie les données. Plus important encore, les classes prennent en charge l’héritage. Vous pouvez créer des hiérarchies où les types dérivés réutilisent et spécialisent le comportement à partir d’une classe de base. Les structures ne peuvent pas participer aux hiérarchies d’héritage. Pour plus d’informations sur la distinction, consultez Types valeur et types de référence.

Constructeurs et initialisation

Lorsque vous créez une instance, vous souhaitez que ses champs et propriétés soient initialisés à des valeurs utiles. C# offre plusieurs approches : initialiseurs de champ, paramètres de constructeur, constructeurs principaux et propriétés requises.

Les initialiseurs de champs définissent une valeur par défaut directement sur la déclaration de champ :

public class Container
{
    private int _capacity = 10;
}

Les initialiseurs de champs attribuent une valeur par défaut raisonnable à un champ ou à une propriété. Cela le distingue des approches suivantes où les appelants peuvent fournir la valeur initiale.

Les paramètres du constructeur nécessitent que les appelants fournissent des valeurs :

public class Container
{
    private int _capacity;

    public Container(int capacity) => _capacity = capacity;
}

Les constructeurs principaux (C# 12+) ajoutent des paramètres directement à la déclaration de classe. Ces paramètres sont disponibles dans le corps de la classe :

public class Container(int capacity)
{
    private int _capacity = capacity;
}

Les constructeurs principaux et les initialiseurs de champs peuvent fonctionner ensemble : l’initialiseur _capacity = capacity de champ utilise le paramètre du constructeur principal comme valeur. Ce modèle vous permet de capturer des arguments de constructeur dans des champs avec une déclaration unique et concise.

Les propriétés requises appliquent que les appelants définissent des propriétés spécifiques via un initialiseur d’objet :

public class Person
{
    public required string FirstName { get; set; }
    public required string LastName { get; set; }
}

// var missing = new Person(); // Error: required properties not set
var person = new Person { FirstName = "Grace", LastName = "Hopper" };
Console.WriteLine($"{person.FirstName} {person.LastName}"); // Grace Hopper

Pour plus d’informations sur les modèles de constructeur, notamment la validation des paramètres et le chaînage des constructeurs, consultez Constructeurs.

Classes statiques

Une static classe ne peut pas être instanciée et ne contient que des membres statiques. Utilisez des classes statiques pour organiser les méthodes utilitaires qui ne fonctionnent pas sur les données d’instance :

static class MathHelpers
{
    public static double CircleCircumference(double radius) =>
        2 * Math.PI * radius;
}

double circumference = MathHelpers.CircleCircumference(5.0);
Console.WriteLine($"Circumference: {circumference:F2}"); // Circumference: 31.42

La bibliothèque de classes .NET comprend de nombreuses classes statiques, telles que Math et Console. Une classe statique est implicitement scellée. Vous ne pouvez pas en dériver ou l’instancier.

Initialiseurs d’objet

Les initialiseurs d’objets vous permettent de définir des propriétés lorsque vous créez un objet, sans écrire de constructeur pour chaque combinaison de valeurs :

class ConnectionOptions
{
    public string Host { get; init; } = "localhost";
    public int Port { get; init; } = 80;
    public bool UseSsl { get; init; }
}

var options = new ConnectionOptions
{
    Host = "db.example.com",
    Port = 5432,
    UseSsl = true
};
Console.WriteLine($"{options.Host}:{options.Port} (SSL: {options.UseSsl})");
// db.example.com:5432 (SSL: True)

Les initialiseurs d'objets fonctionnent avec n'importe quelle propriété accessible qui dispose d'un accesseur set ou init. Ils se combinent naturellement avec les propriétés de required et avec les constructeurs qui acceptent certains paramètres tout en permettant à l'appelant d'en définir d'autres.

Lorsque la propriété est une collection, vous pouvez utiliser une expression Collection (référence C#) pour initialiser cet objet.

Héritage

Les classes prennent en charge l’héritage. Vous pouvez définir une nouvelle classe qui réutilise, étend ou modifie le comportement d’une classe existante. La classe dont vous héritez est la classe de base et la nouvelle classe est la classe dérivée :

var manager = new Manager("Satya", "Engineering");
Console.WriteLine($"{manager.Name} manages {manager.Department}");
// Satya manages Engineering

Une classe peut hériter d’une classe de base et implémenter plusieurs interfaces. Les classes dérivées héritent de tous les membres de la classe de base, à l’exception des constructeurs. Pour plus d’informations, consultez Héritage et interfaces.

Voir également

• Vue d’ensemble du système de type
• Structures
• Enregistrements
• Interfaces
• Héritage