Programmation C sharp/Les types de base et les déclarations
En C#, il existe deux catégories de type :
- Les types valeurs qui stockent directement la valeur des données (un entier, une structure),
- Les types références qui stockent une référence vers la valeur des données (un tableau, une chaîne de caractère, un objet, une interface). Les variables de ce type se distinguent par le fait qu'elles valent initialement
null
et qu'il faut explicitement leur allouer de l'espace mémoire avecnew
. Les données référencées par ces variables sont donc soumises au garbage collector quand plus aucune référence n'existe, afin de libérer la place mémoire occupée.
Un type de base est un type simple valeur.
Liste des types de base
modifierType | Classe | Description | Exemples |
---|---|---|---|
bool | System.Bool | Booléen (vrai ou faux : true ou false )
|
true
|
char | System.Char | Caractère Unicode (16 bits) (ou plus précisément, une unité de code (code unit) Unicode [1]). | 'A' 'λ' 'ω'
|
sbyte | System.SByte | Entier signé sur 8 bits (1 octet) | -128
|
byte | System.Byte | Entier non signé sur 8 bits (1 octet) | 255
|
short | System.Int16 | Entier signé sur 16 bits | -129
|
ushort | System.UInt16 | Entier non signé sur 16 bits | 1450
|
int | System.Int32 | Entier signé sur 32 bits | -100000
|
uint | System.UInt32 | Entier non signé sur 32 bits | 8000000
|
long | System.Int64 | Entier signé sur 64 bits | -2565018947302L
|
ulong | System.UInt64 | Entier non signé sur 64 bits | 8000000000000L
|
float | System.Single | Nombre à virgule flottante sur 32 bits | 3.14F
|
double | System.Double | Nombre à virgule flottante sur 64 bits | 3.14159
|
decimal | System.Decimal | Nombre à virgule flottante sur 128 bits | 3.1415926M
|
string | System.String | Chaîne de caractères unicode[1] | "C♯ ≈ C#"
|
Syntaxe des chaînes de caractères
modifierComme illustré par l'exemple du tableau ci-dessus, une chaîne de caractères peut avoir deux syntaxes différentes :
- Syntaxe avec caractères d'échappement : La chaîne est entourée par les guillemets et l'anti-slash introduit un caractère spécial (
\n
,\t
...) ou empêche son interprétation (guillemet\"
et anti-slash\\
) - Syntaxe verbatim : La chaîne est précédée d'un caractère arobase, et l'anti-slash n'est pas interprété. Si un guillemet doit faire partie de la chaîne de caractère, il faut le doubler
""
.
Exemples :
"un guillemet \", un anti-slash \\, un retour à la ligne\n"
@"un guillemet "", un anti-slash \, un retour à la ligne
"
La syntaxe verbatim simplifie la frappe des chemins de fichiers qui utilisent le caractère anti-slash comme séparateur :
@"C:\program files\monapp\monfichier.txt"
Auto-boxing/unboxing
modifierChaque type de données correspond à une classe de l'espace de nom System
.
La conversion entre le type et une instance de cette classe est implicite et invisible.
Ainsi, on peut appeler des méthodes sur les types simples, affecter une constante où une classe de type est attendue (et vice versa), ...
Exemple :
int a = 25;
string message = 36.ToString(); // convertit 36 en chaîne de caractères,
// méthode définie dans la classe System.Int32
UInt32 b = 50;
Types nullable
modifierLe langage C#2.0 introduit la possibilité pour les types simples de valoir null
. Cette fonctionnalité permet une meilleure interopérabilité avec les bases de données qui utilisent ce type de données.
Pour qu'une variable puisse valoir null
(nullable), il faut que le type soit suivi d'un point d'interrogation. Par exemple :
int? numero = null;
Il est donc possible de tester qu'une variable de ce type vaut null
:
if (numero==null) numero = 50;
else numero++;
Le nouvel opérateur ??
(double point d'interrogation) permet de sélectionner l'opérande de gauche s'il ne vaut pas null
, ou l'opérande de droite sinon :
valeur_ou_null??valeur_si_null
Cet opérateur est donc pratique à utiliser avec les types nullables pour obtenir une valeur par défaut :
Console.WriteLine("Numéro : "+( numero??50 ));
Valeur par défaut
modifierL'opérateur default
retourne la valeur par défaut du type spécifié. Il s'agit de la valeur quand une variable de ce type n'est pas initialisée (0
pour les nombres, null
pour les types références).
Exemple :
public int absolu(int? valeur)
{
if (valeur==null) return default(int);
else return (valeur<0) ? -valeur : valeur;
}
L'utilité de cet opérateur est plus évident avec l'utilisation de types génériques.
Obtenir le type
modifierL'opérateur typeof
retourne une instance de la classe System.Type pour le type spécifié entre parenthèses.
Exemple :
Type t=typeof(int);
L'utilité de cet opérateur est plus évident avec l'utilisation de types génériques.
Obtenir le nom
modifier(C#6.0)
L'opérateur nameof
retourne le nom d'une variable ou d'une méthode sous la forme d'une chaîne de caractères déterminée à la compilation.
Exemple :
var nombres = new List<int> { 1, 2, 3 };
Console.WriteLine(nameof(nombres)); // nombres
Console.WriteLine(nameof(nombres.Count)); // Count
Exemple d'utilisation dans la génération d'exception en cas d'échec de vérification des arguments :
public string Name
{
get => name;
set => name = value ?? throw new ArgumentNullException(nameof(value), $"{nameof(Name)} cannot be null");
}
Type variable
modifierLe langage C#3.0 introduit la possibilité de détecter le type des variables locales selon le type de la valeur ou du résultat d'une expression affecté à cette variable. Il s'agit d'un typage implicite, et cela demeure un typage fort. Ce qui signifie qu'il n'est pas possible ensuite d'affecter une valeur d'un type incompatible.
Exemple 1 :
var n = 50; // Typage implicite équivalent à : int n = 50;
n = 100; // OK
n = "Autre"; // Erreur, n'est pas un entier
n = 1.23; // Erreur, n'est pas un entier
Exemple 2 :
var nom = "Exemple"; // Typage implicite équivalent à : string nom = "Exemple";
nom = "Autre"; // OK
nom = 100; // Erreur, n'est pas une chaîne de caractères
nom = 1.23; // Erreur, n'est pas une chaîne de caractères
Une variable déclarée avec le mot-clé var
doit obligatoirement être affectée à une valeur ou une expression afin que le compilateur puisse déterminer son type.
var x; // Erreur
Notes de bas de page
modifier- ↑ 1,0 et 1,1 Unicode différencie l'unité de code (occupant un nombre déterminé de bit), du caractère lui-même (pouvant être composé de plusieurs points de code, et de plusieurs unités de code). Ces notions sont décrites de manière détaillée dans le livre À la découverte d'Unicode