LangagesDébutantSérie : C# / .NET

C# : Les types

Types primitifs, tableaux, collections, strings et conversions - le vocabulaire de base du langage C#.

4 min de lecture

Mis à jour il y a 4 mois

c#csharptypesstringcollectionsintbool

C# : Les types

Avant de manipuler des données, il faut savoir ce qu'on manipule. En C#, chaque variable a un type fixe défini à la compilation. C'est un langage fortement typé.

# Types numériques entiers

Type	Taille	Plage	Usage typique
`byte`	1 octet	0 à 255	Données brutes, pixels
`short`	2 octets	-32 768 à 32 767	Rarement utilisé
`int`	4 octets	-2.1 milliards à 2.1 milliards	Le plus courant
`long`	8 octets	±9.2 × 10¹⁸	Timestamps, gros compteurs

Chaque type entier a une variante non-signée (unsigned) qui ne stocke que des valeurs positives, mais avec une plage doublée :

Type	Taille	Plage	Équivalent signé
`byte`	1 octet	0 à 255	`sbyte` (-128 à 127)
`ushort`	2 octets	0 à 65 535	`short`
`uint`	4 octets	0 à 4.2 milliards	`int`
`ulong`	8 octets	0 à 18.4 × 10¹⁸	`long`

En pratique, uint et ulong sont rares en C# courant. On les croise surtout en interop (appels à des API C/C++) ou quand on a besoin de garantir qu'une valeur ne sera jamais négative.

# Types numériques décimaux

Type	Taille	Précision	Usage typique
`float`	4 octets	~7 chiffres	Graphisme, jeux (Unity)
`double`	8 octets	~15 chiffres	Calculs scientifiques
`decimal`	16 octets	28-29 chiffres	Argent, finance - précision exacte

Ne jamais utiliser float ou double pour de l'argent. 0.1 + 0.2 != 0.3 avec ces types. Utilise decimal.

Suffixes de déclaration

Par défaut, un nombre entier est un int et un nombre décimal est un double. Pour déclarer un autre type, il faut ajouter un suffixe au littéral :

float prix = 4.5f;          // f = float
double distance = 4.5;      // pas de suffixe = double (par défaut)
decimal salaire = 3500.50m;  // m = decimal
long population = 8000000L;  // L = long
uint positif = 42u;          // u = unsigned int
ulong grand = 42uL;          // uL = unsigned long

float prix = 4.5f;          // f = float

double distance = 4.5;      // pas de suffixe = double (par défaut)

decimal salaire = 3500.50m;  // m = decimal

long population = 8000000L;  // L = long

uint positif = 42u;          // u = unsigned int

ulong grand = 42uL;          // uL = unsigned long

Sans le suffixe, le compilateur refuse : float prix = 4.5; ne compile pas parce que 4.5 est un double, et un double ne rentre pas dans un float sans perte.

# Autres types de base

Type	Description	Exemple
`bool`	Vrai ou faux	`true`, `false`
`char`	Un seul caractère Unicode	`'A'`, `'€'`
`string`	Chaîne de caractères	`"Hello"`

# Tableaux & collections

Tableaux (taille fixe)

// Déclaration et initialisation
int[] nombres = { 1, 2, 3, 4, 5 };
string[] jours = new string[7];  // 7 cases vides

// Accès par index (commence à 0)
int premier = nombres[0];   // 1
int dernier = nombres[^1];  // 5 (index depuis la fin, C# 8+)

// Taille
int taille = nombres.Length;  // 5

// Déclaration et initialisation

int[] nombres = { 1, 2, 3, 4, 5 };

string[] jours = new string[7];  // 7 cases vides

// Accès par index (commence à 0)

int premier = nombres[0];   // 1

int dernier = nombres[^1];  // 5 (index depuis la fin, C# 8+)

// Taille

int taille = nombres.Length;  // 5

List<T> (taille dynamique)

// Le plus utilisé au quotidien
List<string> prenoms = new List<string>();
prenoms.Add("Alice");
prenoms.Add("Bob");
prenoms.Remove("Alice");
int count = prenoms.Count;       // 1
bool existe = prenoms.Contains("Bob");  // true

// Initialisation directe
var villes = new List<string> { "Paris", "Lyon", "Marseille" };

// Le plus utilisé au quotidien

List<string> prenoms = new List<string>();

prenoms.Add("Alice");

prenoms.Add("Bob");

prenoms.Remove("Alice");

int count = prenoms.Count;       // 1

bool existe = prenoms.Contains("Bob");  // true

// Initialisation directe

var villes = new List<string> { "Paris", "Lyon", "Marseille" };

Dictionary<K, V> (clé-valeur)

var ages = new Dictionary<string, int>
{
    ["Alice"] = 25,
    ["Bob"] = 30,
};

ages["Charlie"] = 22;            // ajouter
int ageAlice = ages["Alice"];    // 25
bool found = ages.TryGetValue("Dave", out int age);  // false

var ages = new Dictionary<string, int>

    ["Alice"] = 25,

    ["Bob"] = 30,

};

ages["Charlie"] = 22;            // ajouter

int ageAlice = ages["Alice"];    // 25

bool found = ages.TryGetValue("Dave", out int age);  // false

Array vs List ? Utilise List<T> par défaut. Les tableaux ([]) sont utiles quand la taille est connue et fixe (performances, interop).

# Strings

Les chaînes de caractères en C# sont immuables - chaque modification crée une nouvelle string.

Syntaxes

// Interpolation (le plus courant)
string msg = $"Bonjour, {prenom} ! Tu as {age} ans.";

// Verbatim  -  ignore les séquences d'échappement
string chemin = @"C:\Users\Baptiste\Documents";

// Raw string literal (C# 11+)  -  plus besoin d'échapper
// Délimité par 3 guillemets doubles :
// string json = """
//   { "nom": "Baptiste", "age": 22 }
// """;

// Combiné : interpolation + verbatim
string query = $@"SELECT * FROM users WHERE name = '{nom}'";

// Interpolation (le plus courant)

string msg = $"Bonjour, {prenom} ! Tu as {age} ans.";

// Verbatim  -  ignore les séquences d'échappement

string chemin = @"C:\Users\Baptiste\Documents";

// Raw string literal (C# 11+)  -  plus besoin d'échapper

// Délimité par 3 guillemets doubles :

// string json = """

//   { "nom": "Baptiste", "age": 22 }

// """;

// Combiné : interpolation + verbatim

string query = $@"SELECT * FROM users WHERE name = '{nom}'";

Méthodes courantes

string texte = "  Hello, World!  ";

texte.Trim()                // "Hello, World!"
texte.ToUpper()             // "  HELLO, WORLD!  "
texte.ToLower()             // "  hello, world!  "
texte.Contains("World")     // true
texte.StartsWith("  H")     // true
texte.Replace("World", "C#") // "  Hello, C#!  "
texte.Split(',')            // ["  Hello", " World!  "]
texte.Substring(2, 5)       // "Hello"

// String vide ou null ?
string s = "";
string.IsNullOrEmpty(s)      // true si null ou ""
string.IsNullOrWhiteSpace(s) // true si null, "" ou "   "

string texte = "  Hello, World!  ";

texte.Trim()                // "Hello, World!"

texte.ToUpper()             // "  HELLO, WORLD!  "

texte.ToLower()             // "  hello, world!  "

texte.Contains("World")     // true

texte.StartsWith("  H")     // true

texte.Replace("World", "C#") // "  Hello, C#!  "

texte.Split(',')            // ["  Hello", " World!  "]

texte.Substring(2, 5)       // "Hello"

// String vide ou null ?

string s = "";

string.IsNullOrEmpty(s)      // true si null ou ""

string.IsNullOrWhiteSpace(s) // true si null, "" ou "   "

# Conversions de types

Cast implicite et explicite

// Implicite (safe, pas de perte)
int entier = 42;
double grand = entier;  // 42.0  -  int -> double OK

// Explicite (risque de perte)
double pi = 3.14;
int arrondi = (int)pi;  // 3  -  la partie décimale est tronquée

// Implicite (safe, pas de perte)

int entier = 42;

double grand = entier;  // 42.0  -  int -> double OK

// Explicite (risque de perte)

double pi = 3.14;

int arrondi = (int)pi;  // 3  -  la partie décimale est tronquée

Parse et TryParse

// Parse  -  plante si le format est invalide
int n = int.Parse("42");         // 42
double d = double.Parse("3.14"); // 3.14

// TryParse  -  safe, retourne false si invalide
if (int.TryParse("abc", out int resultat))
{
    Console.WriteLine(resultat);
}
else
{
    Console.WriteLine("Format invalide");  // ← ici
}

// Parse  -  plante si le format est invalide

int n = int.Parse("42");         // 42

double d = double.Parse("3.14"); // 3.14

// TryParse  -  safe, retourne false si invalide

if (int.TryParse("abc", out int resultat))

    Console.WriteLine(resultat);

else

    Console.WriteLine("Format invalide");  // ← ici

Préfère toujours TryParse à Parse. Un crash à cause d'un FormatException sur une entrée utilisateur, c'est évitable.

Convert

// Conversion entre types de base
int i = Convert.ToInt32("42");
string s = Convert.ToString(42);
bool b = Convert.ToBoolean(1);  // true

// Conversion entre types de base

int i = Convert.ToInt32("42");

string s = Convert.ToString(42);

bool b = Convert.ToBoolean(1);  // true

is et as (pour les objets)

// is  -  vérifie le type
if (obj is string texte)
{
    Console.WriteLine(texte.Length);
}

// as  -  tente le cast, retourne null si impossible
string? result = obj as string;

// is  -  vérifie le type

if (obj is string texte)

    Console.WriteLine(texte.Length);

// as  -  tente le cast, retourne null si impossible

string? result = obj as string;

# La suite

Tu connais maintenant le vocabulaire du langage. Pour comprendre comment chaque type est stocké et géré en coulisses, rendez-vous dans l'article sur la mémoire (stack vs heap, value types vs reference types).

Le prochain article couvre comment manipuler tout ça :

La syntaxe - variables, opérateurs, structures de contrôle, méthodes