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 avec new. 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

Type	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 ).	'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	"C♯ ≈ C#" "€ ≠ ℕ" "Chaîne ♫ ♬ ♭ ♮" "συμβόλων" "C:\\windows\\system32" @"C:\windows\system32"

Syntaxe des chaînes de caractères

Comme 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

Chaque 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

Le 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

L'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

L'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

(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

Le 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