Classes et structs (Guide de programmation C#)
Les classes et structs sont deux des constructions de base du système de type commun dans le .NET Framework. Chacun est essentiellement une structure de données qui encapsule un groupe de données et des comportements qui ensemble constituent une unité logique. Les données et comportements sont les membres de la classe ou du struct, et ils incluent ses méthodes, propriétés, événements, et ainsi de suite, comme répertorié ultérieurement dans cette rubrique.
Une déclaration de classe ou de struct est comme un plan utilisé pour créer des instances ou des objets au moment de l'exécution. Si vous définissez une classe ou un struct nommé Person, Person est le nom du type. Si vous déclarez et initialisez une variable p de type Person, on dit que p est un objet ou une instance de Person. Vous pouvez créer plusieurs instances du même type Person et chaque instance peut avoir des valeurs différentes dans ses propriétés et champs.
Une classe est un type référence. Lorsqu'un objet de la classe est créé, la variable à laquelle l'objet est assigné contient uniquement une référence à cette mémoire. Lorsque la référence d'objet est assignée à une nouvelle variable, la nouvelle variable fait référence à l'objet d'origine. Les modifications effectuées par le biais d'une variable sont répercutées dans l'autre variable car toutes deux font référence aux mêmes données.
Un struct est un type valeur. Lorsqu'un struct est créé, la variable à laquelle le struct est assigné contient les données réelles du struct. Lorsque le struct est assigné à une nouvelle variable, il est copié. La nouvelle variable et la variable d'origine contiennent par conséquent deux copies distinctes des mêmes données. Les modifications apportées à une copie n'affectent pas l'autre copie.
En général, les classes sont utilisées pour modeler un comportement plus complexe ou des données censées être modifiées après la création d'un objet de classe. Les structs conviennent mieux aux petites structures de données contenant principalement des données qui ne sont pas censées être modifiées après la création du struct.
Pour plus d'informations, consultez Classes (guide de programmation C#), Objets (Guide de programmation C#) et Structures (Guide de programmation C#).
Exemple
Dans l'exemple suivant, MyCustomClass est défini avec trois membres au niveau supérieur de l'espace de noms ProgrammingGuide. Une instance (objet) de MyCustomClass est créée dans la méthode Main dans la classe Program, et les méthodes et propriétés de l'objet sont accessibles à l'aide de la notation par point.
namespace ProgrammingGuide
{
// Class definition.
public class MyCustomClass
{
// Class members:
// Property.
public int Number { get; set; }
// Method.
public int Multiply(int num)
{
return num * Number;
}
// Instance Constructor.
public MyCustomClass()
{
Number = 0;
}
}
// Another class definition. This one contains
// the Main method, the entry point for the program.
class Program
{
static void Main(string[] args)
{
// Create an object of type MyCustomClass.
MyCustomClass myClass = new MyCustomClass();
// Set the value of a public property.
myClass.Number = 27;
// Call a public method.
int result = myClass.Multiply(4);
}
}
}
Encapsulation
L'encapsulation est parfois connu sous le nom de premier pilier ou principe de la programmation orientée objet. D'après le principe d'encapsulation, une classe ou un struct peut spécifier le degré d'accessibilité de chacun de ses membres au code situé en dehors de la classe ou du struct. Les méthodes et variables qui ne sont pas censées être utilisées depuis l'extérieur de la classe ou de l'assembly peuvent être masquées afin de limiter le risque d'erreurs de codage ou d'utilisation malveillante.
Pour plus d'informations sur les classes, consultez Classes (guide de programmation C#) et Objets (Guide de programmation C#). Pour plus d'informations sur le mode de création des classes, consultez Instructions de conception de types.
Membres
Tous les champs, méthodes, constantes, propriétés et événements doivent être déclarés dans un type ; ils portent le nom de membres de la classe ou du struct. En C#, il n'y a pas de variables ou méthodes globales comme dans certains autres langages. Même le point d'entrée d'un programme, la méthode Main, doit être déclaré dans une classe ou un struct. La liste suivante inclut tous les types de membres qui peuvent être déclarés dans une classe ou un struct.
Accessibilité
Certaines méthodes et propriétés sont censées être appelées ou accédées à partir de code à l'extérieur de votre classe ou struct, connu sous le terme de code client. D'autres méthodes et propriétés peuvent être destinées uniquement à une utilisation dans la classe ou le struct lui-même. Il est important de limiter l'accessibilité de votre code afin que seul le code client prévu puisse y accéder. Vous pouvez spécifier le degré d'accessibilité de vos types et de leurs membres au code client en utilisant les modificateurs d'accès public, protected, internal, protected internal et private. L'accessibilité par défaut est private. Pour plus d'informations, consultez Modificateurs d'accès (Guide de programmation C#).
Héritage
Les classes (mais pas les structs) prennent en charge le concept d'héritage. Une classe qui dérive d'une autre classe (la classe de base) contient automatiquement tous les membres publics, protégés et internes de la classe de base, sauf ses constructeurs et destructeurs. Pour plus d'informations, consultez Héritage (Guide de programmation C#) et Polymorphisme (Guide de programmation C#).
Les classes peuvent être déclarées comme abstraites, ce qui signifie qu'une ou plusieurs de leurs méthodes n'a aucune implémentation. Bien que les classes abstraites ne puissent pas être instanciées directement, elles peuvent servir de classes de base à d'autres classes qui fournissent l'implémentation manquante. Les classes peuvent également être déclarées comme sealed pour empêcher d'autres classes d'hériter d'elles. Pour plus d'informations, consultez Classes abstract et sealed et membres de classe (Guide de programmation C#).
Interfaces
Les classes et structs peuvent hériter de plusieurs interfaces. Hériter de l'interface signifie que le type implémente toutes les méthodes définies dans cette interface. Pour plus d'informations, consultez Interfaces (Guide de programmation C#).
Types génériques
Les classes et structs peuvent être définis avec un ou plusieurs paramètres de type. Le code client fournit le type lorsqu'il crée une instance du type. Par exemple, la classe List<T> dans l'espace de noms System.Collections.Generic est définie avec un paramètre de type. Le code client crée une instance d'un List<string> ou List<int> pour spécifier le type que la liste contiendra. Pour plus d'informations, consultez Génériques (guide de programmation C#).
Types statiques
Les classes (mais pas les structs) peuvent être déclarées comme statiques. Une classe statique peut contenir des membres statiques uniquement et ne peut pas être instanciée avec le mot clé New. Une copie de la classe est chargée dans la mémoire lorsque le programme charge, et ses membres sont accessibles via le nom de classe. Les classes et les structs peuvent contenir des membres statiques. Pour plus d'informations, consultez Classes statiques et membres de classe statique (Guide de programmation C#).
Types imbriqués
Une classe ou un struct peut être imbriqué dans une autre classe ou struct. Pour plus d'informations, consultez Types imbriqués.
Types partiels
Vous pouvez définir une partie de classe, struct ou méthode dans un fichier de code et une autre partie dans un fichier de code séparé. Pour plus d'informations, consultez Classes et méthodes partielles.
Initialiseurs d'objets
Vous pouvez instancier et initialiser des objets de classe et de struct, ainsi que des collections d'objets, sans appeler explicitement leur constructeur. Pour plus d'informations, consultez Initialiseurs d'objets et de collection (Guide de programmation C#).
Types anonymes
Dans les situations où ce n'est pas commode ou nécessaire de créer une classe nommée, par exemple lorsque vous remplissez une liste avec des structures de données que vous n'avez pas à rendre persistant ni à passer à une autre méthode, vous utilisez des types anonymes. Pour plus d'informations, consultez Types anonymes (Guide de programmation C#).
Méthodes d'extension
Vous pouvez étendre une classe sans créer de classe dérivée mais en créant un type séparé dont les méthodes peuvent être appelées comme si elles appartenaient au type d'origine. Pour plus d'informations, consultez Méthodes d'extension (Guide de programmation C#).
Variables locales implicitement typées
Dans une méthode de classe ou de struct, vous pouvez utiliser le type implicite pour indiquer au compilateur de déterminer le type approprié au moment de la compilation. Pour plus d'informations, consultez Variables locales implicitement typées (Guide de programmation C#).
Spécification du langage C#
Pour plus d'informations, consultez 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.