Partager via

Types et littéraux intégrés

Conseil / Astuce

Vous débutez avec le développement de logiciels ? Commencez par commencer par les didacticiels De prise en main . Ils introduisent des types lorsque vous écrivez vos premiers programmes.

Maîtrisez-vous une autre langue ? Les types intégrés C# correspondent étroitement aux types dans Java, C++et d’autres langages. Parcourez la syntaxe littérale et les sections d’inférence de type pour les détails spécifiques à C#.

C# fournit un ensemble de types intégrés que vous pouvez utiliser dans n’importe quel programme sans références supplémentaires. Ces types couvrent les données les plus courantes avec lesquelles vous travaillez : nombres, valeurs true/false, caractères individuels et texte. Pour obtenir un tableau de référence complet mappant les mots clés C# vers des types .NET, consultez les types intégrés (référence C#).

Types numériques

C# a des types intégrés pour les entiers, les nombres à virgule flottante et les nombres décimaux. Les types les plus couramment utilisés sont int, doubleet decimal:

int population = 67_000_000;
long distance = 384_400_000L;
short temperature = -40;
byte red = 255;

double pi = 3.141592653589793;
float gravity = 9.81f;
decimal price = 19.99m;

Chaque type numérique a une taille et une plage fixes. int stocke des entiers 32 bits (à peu près ±2,1 milliards), long stocke des entiers 64 bits et shortbyte stocke des valeurs plus petites. Pour obtenir la liste complète des tailles et des plages, consultez types numériques intégraux et types numériques à virgule flottante.

Utilisez double les calculs mathématiques à virgule flottante générale, float lorsque la mémoire est limitée et decimal quand vous avez besoin d’une précision décimale exacte (par exemple, des calculs financiers). Ajoutez le suffixe f pour les littéraux float et m pour les littéraux decimal. Sans suffixe, le compilateur traite un nombre avec un point décimal comme double.

Types non signés

Chaque type entier signé a un équivalent non signé qui stocke uniquement les valeurs non négatives avec deux fois la plage positive :

uint fileSize = 4_294_967_295;
ulong totalBytes = 18_446_744_073_709_551_615;
ushort port = 443;

Vous pouvez utiliser des types non signés lorsque les valeurs négatives ne sont pas valides pour les données, telles que les tailles de fichier ou les ports réseau. Dans la pratique, de nombreuses applications utilisent int ou long même pour des valeurs positives uniquement, car les types signés sont la valeur par défaut dans les API .NET.

Entiers de taille native

Les types nint et nuint représentent des entiers dont la taille correspond à la taille du pointeur natif de la plateforme : 32 bits sur une plateforme 32 bits, 64 bits sur une plateforme 64 bits.

nint bufferSize = 1024;
nuint elementCount = 256;

Il est peu probable que vous ayez besoin nint ou nuint dans le code quotidien. Ils existent pour les scénarios d’interopérabilité et les opérations de mémoire de bas niveau où la mise en correspondance de la taille du pointeur de la plateforme est importante. Restez avec int ou long sauf si vous avez une raison spécifique d’utiliser des types de taille native. Pour plus d’informations, consultez nint et nuint.

bool, char et string

Au-delà des nombres, C# fournit trois autres types intégrés fréquemment utilisés :

bool isValid = true;
char grade = 'A';
string greeting = "Hello, world!";
  • bool — Stocke true ou false. Utilisez-le dans des conditions, des boucles et des expressions logiques.
  • char — Stocke un caractère Unicode unique (unité de code UTF-16), placé entre guillemets simples.
  • string — Stocke une séquence de caractères entre guillemets doubles. Les chaînes sont immuables. Une fois que vous avez créé une chaîne, vous ne pouvez pas modifier son contenu. Les opérations qui semblent modifier une chaîne en créent une nouvelle.

Les chaînes sont l’un des types les plus utilisés en C#. Pour une couverture approfondie des opérations de chaîne, notamment l’interpolation, les littéraux de chaîne bruts, la recherche, le fractionnement et la comparaison, consultez la section Chaînes .

Syntaxe littérale

Un littéral est une valeur que vous écrivez directement dans votre code. Le compilateur attribue à chaque littéral un type en fonction de son format et de tout suffixe que vous fournissez. C# prend en charge les types de littéraux suivants :

  • Littéraux entiers : décimal (42), hexadécimal (0x2A) et binaire (0b_0010_1010).
  • Littéraux à virgule flottante — double par défaut (3.14), float avec le suffixe f (3.14f), et decimal avec m (3.14m).
  • Littéraux de caractères : caractère unique entre guillemets simples ('A'y compris les séquences d’échappement ('\n').
  • Littéraux de chaîne — Normal ("hello"), littéral (@"C:\path"), brut (""" ... """) et interpolé ($"value: {x}").
  • Littéraux booléens — true et false.
  • Littéral null : représente l’absence d’une valeur pour les types référence et les types valeur pouvant être nuls.
  • Le default littéral — génère la valeur par défaut pour tout type (présenté dans les expressions default).

Les sections suivantes couvrent en détail les formes littérales les plus courantes.

Littéraux entiers

int dec = 42;
int hex = 0x2A;
int bin = 0b_0010_1010;
long big = 1_000_000_000L;

Utilisez le 0x préfixe pour hexadécimal et 0b pour le fichier binaire. Ajouter L pour long, U pour uintou UL pour ulong.

Placez le _ séparateur de chiffres n’importe où dans un nombre pour faciliter la lecture. Les modèles courants incluent des séparateurs de milliers dans des littéraux décimaux (1_000_000_000), des octets ou des limites de mots en hexadécimal (0xFF_FF) et des limites de nibble dans binaire (0b_0010_1010).

Littéraux à virgule flottante

double d = 3.14;
float f = 3.14f;
decimal m = 3.14m;
double scientific = 1.5e6; // 1,500,000

Sans suffixe, un littéral numérique avec un point décimal est double. Ajouter f pour float et m pour decimal. La notation scientifique (1.5e6) est également prise en charge.

Littéraux de caractères et de chaînes

char newline = '\n';
char unicode = '\u0041'; // 'A'

string message = $"Found {dec} items";            // interpolated string
string path = @"C:\Users\docs\file.txt";        // verbatim string
string json = """
    { "name": "Alice", "age": 30 }
    """;                                           // raw string literal
string raw = $"""
    Found {dec} items in "{greeting}"
    """;                                           // raw + interpolated

Les littéraux de caractères utilisent des guillemets simples et prennent en charge les séquences d’échappement (\n, \t, \u). Les littéraux de chaîne utilisent des guillemets doubles.

Chaînes de préfixe avec $ pour interpolation. Lorsqu’une chaîne contient des guillemets, des barres obliques inverses ou des données JSON ou XML incorporées, utilisez un littéral de chaîne brut (délimité par """) au lieu d’échapper à chaque caractère. Les littéraux de chaîne bruts s’associent également à l’interpolation ($""").

Les anciens codes utilisent @ (chaînes verbatim) pour éviter le traitement d'échappement. Les littéraux de chaîne brutes sont plus faciles à lire et à écrire. Pour le code nouveau, préférez-les.

default Expressions

L’expression default produit la valeur par défaut d’un type : 0 pour les types numériques, false pour boolet null pour les types référence :

int defaultInt = default;          // 0
bool defaultBool = default;        // false
string? defaultString = default;   // null

// Use default in a conditional:
var limit = (args.Length > 0) ? int.Parse(args[0]) : default(int);

L’expression est la plus utile dans le code générique default, où l'on ne connaît pas le type concret et ne pouvez pas inscrire en dur une valeur spécifique comme 0 ou null. Écrivez default (sans argument de type) lorsque le compilateur peut déduire le type à partir du contexte ou default(T) lorsque le type n’est pas évident. Pour obtenir la liste complète des valeurs par défaut par type, consultez Les valeurs par défaut des types C#.

Variables implicitement typées avec var

Le var mot clé indique au compilateur de déduire le type d’une variable locale de son initialiseur :

var count = 10;              // compiler infers int
var name = "C#";             // compiler infers string
var items = new List<int>(); // compiler infers List<int>

// var requires an initializer — the compiler needs a value to infer the type.
// The following line wouldn't compile:
// var unknown;

La variable est toujours fortement typée ; var ne la rend pas dynamique. Le compilateur détermine le type au moment de la compilation et applique la sécurité de type comme d’habitude. Utilisez var quand le type est évident du côté droit pour réduire le bruit visuel. Indiquez le type lorsqu’il rend le code plus clair. Pour plus d’informations, consultez Variables locales typées implicitement.

Expressions à typage cible new

Lorsque vous connaissez déjà le type cible à partir du contexte, tel qu’une déclaration de variable ou un paramètre de méthode, vous pouvez omettre le nom de type de l’expression new :

List<string> names = new() { "Alice", "Bob", "Charlie" };
Dictionary<string, int> scores = new()
{
    ["Alice"] = 95,
    ["Bob"] = 87
};

Le typage ciblé par new réduit la répétition lorsque le nom de type est long ou apparaît à gauche de l'affectation. Il fonctionne n’importe où le compilateur peut déterminer le type cible, y compris les arguments de méthode et les instructions return. Pour plus d’informations, consultez new l’opérateur — type cible new.

Le type dynamic

Le type dynamic contourne la vérification de type au moment de la compilation. Le compilateur résout les opérations sur une dynamic variable au moment de l’exécution à la place :

dynamic value = 42;
Console.WriteLine(value.GetType()); // System.Int32

value = "Now I'm a string";
Console.WriteLine(value.GetType()); // System.String

// The compiler doesn't check operations on dynamic at compile time.
// Errors surface at run time instead.

Utilisez dynamic lors de l’interaction avec les API COM, les langages dynamiques ou les scénarios de réflexion lourds où les types ne sont pas connus au moment de la compilation. Évitez dynamic dans la plupart des codes d'application, car cela vous fait perdre la sécurité offerte par la compilation. Erreurs que le compilateur intercepte normalement deviennent des exceptions au moment de l’exécution à la place. Pour plus d’informations, consultez Le type dynamique.

Voir également

  • Last updated on