Partager via

Système de type C#

Conseil / Astuce

Vous débutez avec le développement de logiciels ? Commencez par commencer par les didacticiels De prise en main . Ils vous guident dans l’écriture de programmes et introduisent les types au fur et à mesure.

Maîtrisez-vous une autre langue ? Si vous comprenez déjà les systèmes de type, parcourez la distinction entre valeur et référence et choisissez le type de guide, puis accédez aux articles sur des types spécifiques.

C# est un langage fortement typé. Chaque variable, constante et expression a un type. Le compilateur applique la sécurité des types en vérifiant que chaque opération de votre code est valide pour les types impliqués. Par exemple, vous pouvez ajouter deux int valeurs, mais vous ne pouvez pas ajouter un int et un bool:

int a = 5;
int b = a + 2; // OK

bool test = true;

// Error. Operator '+' cannot be applied to operands of type 'int' and 'bool'.
// int c = a + test;

Remarque

Contrairement à C et C++, en C#, bool n’est pas convertible en int.

La sécurité de type intercepte les erreurs au moment de la compilation, avant l’exécution de votre code. Le compilateur incorpore également des informations de type dans l’exécutable sous forme de métadonnées, que le Common Language Runtime (CLR) utilise pour des vérifications de sécurité supplémentaires au moment de l’exécution.

Déclarer des variables avec des types

Lorsque vous déclarez une variable, vous spécifiez son type explicitement ou utilisez var pour permettre au compilateur de déduire le type de la valeur affectée :

// Explicit type:
int count = 10;
double temperature = 36.6;

// Compiler-inferred type:
var name = "C#";
var items = new List<string> { "one", "two", "three" };

Les paramètres de méthode et les valeurs de retour ont également des types. La méthode suivante prend un string et un int, et retourne un string:

static string GetGreeting(string name, int visitCount)
{
    return visitCount switch
    {
        1 => $"Welcome, {name}!",
        _ => $"Welcome back, {name}! Visit #{visitCount}."
    };
}

Après avoir déclaré une variable, vous ne pouvez pas modifier son type ou affecter une valeur incompatible avec le type déclaré. Vous pouvez convertir des valeurs en d’autres types. Le compilateur effectue des conversions implicites qui ne perdent pas automatiquement les données. Les conversions explicites (casts) vous obligent à indiquer la conversion dans votre code. Pour plus d’informations, consultez Conversion et conversions de types.

Types intégrés et types personnalisés

C# fournit des types intégrés pour les données courantes : entiers, nombres à virgule flottante, boolcharet string. Chaque programme C# peut utiliser ces types intégrés sans références supplémentaires.

Au-delà des types intégrés, vous pouvez créer vos propres types à l’aide de plusieurs constructions :

  • Classes : types de référence pour la modélisation du comportement et des objets complexes. Prise en charge de l’héritage et du polymorphisme.
  • Structs : types de valeurs pour les données petites et légères. Chaque variable contient sa propre copie.
  • Enregistrements : classes ou structs avec égalité générée par le compilateur, ToString et mutation non destructrice via des expressions with.
  • Interfaces : contrats qui spécifient les membres qu'une classe ou une structure peut implémenter.
  • Énumérations : ensembles nommés de constantes intégrales, tels que les jours de la semaine ou les modes d’accès aux fichiers.
  • Tuples : types structurels légers qui regroupent les valeurs associées sans définir de type nommé.
  • Génériques : constructions paramétrables de type comme List<T> et Dictionary<TKey, TValue> qui fournissent une sécurité de type lors de la réutilisation de la même logique pour différents types.

Les types valeur et les types de référence

Chaque type en C# est soit un type valeur , soit un type référence. Cette distinction détermine le fonctionnement des variables dans le stockage des données et le fonctionnement de l’affectation.

Les types valeur contiennent leurs données directement. Lorsque vous affectez un type valeur à une nouvelle variable, le runtime copie les données. Les modifications apportées à une variable n’affectent pas l’autre. Les structures, les énumérations et les types numériques intégrés sont tous des types valeurs.

Les types de référence contiennent une référence à un objet sur le tas managé. Lorsque vous affectez un type de référence à une nouvelle variable, les deux variables pointent vers le même objet. Les modifications par le biais d’une variable sont visibles par l’autre. Les classes, les tableaux, les délégués et les chaînes sont des types de référence.

L’exemple suivant montre la différence. Le premier bloc affiche la définition du Coords struct d’enregistrement, qui est un type valeur. Le deuxième bloc montre le comportement différent pour les types valeur et les types de référence.

public readonly record struct Coords(int X, int Y);

// Value type: each variable holds its own copy
var point1 = new Coords(3, 4);
var point2 = point1;
Console.WriteLine($"point1: ({point1.X}, {point1.Y})");
Console.WriteLine($"point2: ({point2.X}, {point2.Y})");
// point1 and point2 are independent copies

// Reference type: both variables refer to the same object
var list1 = new List<int> { 1, 2, 3 };
var list2 = list1;
list2.Add(4);
Console.WriteLine($"list1 count: {list1.Count}"); // 4 — same object

Tous les types dérivent finalement de System.Object. Les types valeur dérivent de System.ValueType, qui dérive de object. Cette hiérarchie unifiée est appelée Common Type System (CTS). Pour plus d’informations sur l’héritage, consultez Héritage.

Choisir le type de type

Lorsque vous définissez un nouveau type, le type que vous choisissez est la façon dont votre code se comporte. Utilisez les instructions suivantes pour prendre une décision initiale :

  • Tuple : regroupement temporaire de valeurs qui n’ont pas besoin d’un type ou d’un comportement nommé.
  • struct ou record struct — Petites données (environ 64 octets ou moins), sémantiques de valeur ou immuabilité. Les structures d'enregistrement ajoutent l'égalité basée sur la valeur et with les expressions.
  • record class — Principalement des données, avec égalité basée sur la valeur ToString, et mutation non destructrice. Prend en charge l’héritage.
  • class — Comportement complexe, polymorphisme ou état mutable. La plupart des types personnalisés sont des classes.
  • interface — Contrat pouvant être implémenté par des types non liés. Définit les fonctionnalités plutôt que l’identité.
  • enum — Ensemble fixe de constantes nommées, telles que les codes d’état ou les options.

Plusieurs options sont souvent raisonnables.

Type de compilation et type d’exécution

Une variable peut avoir différents types au moment de la compilation et au moment de l’exécution. Le type de compilation est le type déclaré ou inféré dans le code source. Le type d’exécution est le type réel de l’instance à laquelle la variable fait référence. Le type d’exécution doit être identique au type au moment de la compilation, ou à un type qui dérive de celui-ci ou l’implémente. Une affectation est valide uniquement lorsqu’une conversion implicite existe du type d’exécution au type de compilation, tel qu’une identité, une référence, une boxe ou une conversion numérique.

// Compile-time and run-time types match:
string message = "Hello, world!";

// Compile-time type differs from run-time type:
object boxed = "This is a string at run time";
IEnumerable<char> characters = "abcdefghijklmnopqrstuvwxyz";

Dans l’exemple précédent, boxed a un type de compilation object mais un type d’exécution string. L’affectation fonctionne parce que string dérive de object. De même, characters a un type de compilation de IEnumerable<char>, et l’affectation fonctionne, car string implémente cette interface. Le type au moment de la compilation contrôle la résolution de surcharge et les conversions disponibles. Le type d’exécution contrôle l'envoi de méthodes virtuelles, ainsi que les expressions is et switch.

Voir également

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.

  • Last updated on