Apprenez à programmer en C# sur .NET

Apprenez à programmer en C# sur .NET

Mis à jour le mardi 8 janvier 2013
  • 8 semaines
  • Facile

Une des questions qu'un débutant peut se poser est :

Que fait un programmeur quand il écrit du code ?

En fait, un programmeur manipule des variables.

Qu'est-ce que c'est ?

Comme son nom l'indique, une variable est quelque chose qui varie. Sa représentation la plus courante est une boîte qui contient des informations.

Les deux éléments essentiels d'une variable sont sa valeur (et donc son type) et son nom. Nous parlerons des types juste après.
Le nom, c'est vous qui le fixez ; il est unique et permet de n'identifier qu'une seule variable. La valeur, quant à elle, peut être à peu près n'importe quoi, et peut être modifiée autant que l'on veut. Pour schématiser, la variable est la boîte, son nom est écrit dessus, sa valeur est ce qu'elle contient, et son type est la forme de la boîte.

Donner un nom à ses variables

En C#,

  • le nom d'une variable est obligatoirement écrit avec des caractères alphanumériques (de préférence sans accent), ainsi que le underscore '_' (sans les apostrophes) : abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_0123456789 ;

  • le nom doit forcément commencer par une lettre (underscore '_' compris) ;

  • le nom ne doit pas être le nom d'un type ou d'une classe déjà définis, d'un mot-clef du langage, ...(il ne doit pas être déjà pris). Bref, il ne faut pas que la confusion soit possible.

Types de variables de base

En C#, les variables possèdent un type qui précise la nature des informations stockées.
L'inconvénient que remarquent surtout ceux qui ont l'habitude d'un langage sans typage (tel que le PHP) est le manque de "souplesse" : certaines choses peuvent être écrites plus simplement dans ce langage qu'en C#. Par exemple, le chiffre 2 et sa représentation en caractère '2' peuvent éventuellement être utilisés l'un à la place de l'autre, ce qui n'est pas le cas en C#.
L'avantage est que vous savez exactement ce que vous manipulez. Cela permet d'éviter certaines erreurs, de bien comprendre ce que votre code fait, et de pouvoir l'optimiser.
C'est une habitude à prendre ; ensuite vous redouterez le "laxisme" de certains langages !

Le C# dispose de types de base qui permettent de représenter des informations dont la nature est courante, comme des nombres, des caractères et des chaînes de caractères. Il existe un nombre infini de types étant donné que l'on peut construire un nouveau type à partir de ceux qui existent déjà. C'est ce que nous verrons quand nous étudierons les classes.

Voici un tableau exhaustif contenant les types de base du C# :

Type C#

Type .NET

Signification

Taille en mémoire (en octets)

Domaine de valeurs

char

Char

character (caractère)

2

caractère Unicode (UTF-16) allant de U+0000 à U+ffff

string

String

chaîne de caractères

variable

référence sur une séquence de caractères Unicode

int

Int32

integer (nombre entier)

4

[-231; 231-1]

uint

UInt32

unsigned integer (nombre entier non signé)

4

[0; 232-1]

long

Int64

nombre entier long

8

[-263; 263-1]

ulong

UInt64

unsigned long (nombre entier long non signé)

8

[0; 264-1]

sbyte

SByte

signed byte (octet signé)

1

[-27; 27-1]

byte

Byte

octet

1

[0; 28-1]

short

Int16

nombre entier court

2

[-215; 215-1]

ushort

UInt16

unsigned short (nombre entier court non signé)

2

[0; 216-1]

float

Single

flottant (nombre réel)

4

±1,5*10-45 à ±3,4*10+38 (7 chiffres de précision)

double

Double

double flottant (nombre réel)

8

±5,0*10-324 à ±1,7*10+308 (15 à 16 chiffres de précision)

decimal

Decimal

nombre décimal

16

±1,0*10-28 à ±7,9*1028 (28 à 29 chiffres significatifs)

bool

Boolean

booléen

1

true / false

object

Object

référence d'objet

variable

référence d'objet

Chacun des types C# présentés est un alias du type .NET associé, cela signifie que lorsque que vous écrivez par exemple int, c'est comme si vous aviez écrit System.Int32. Pour raccourcir et par habitude, on privilégie le type C# au type .NET.

Illustration avec sizeof et typeof

sizeof permet de connaître la taille (en octets) occupée en mémoire par une variable de type valeur. Nous verrons très bientôt ce que cela veut dire ; pour faire simple, il faut que la taille soit fixe. Par exemple, on ne peut pas écrire sizeof(string), car une chaîne de caractères peut être de la taille que l'on veut. D'autre part, multiplier le nombre de caractères par la taille d'un seul caractère ne suffit pas non-plus ; en effet l'objet string contient en mémoire plus d'informations qu'une simple chaîne de caractères (cf. ce site).

typeof permet de connaître le type d'une variable.

Par exemple, le code suivant...

int i = 10;
string s = "Hello world!";
char c = 'a';

Console.WriteLine("i est de type " + typeof(int) + " et occupe " + sizeof(int) + " octet(s) en mémoire.");
Console.WriteLine("s est de type " + typeof(string) + ".");
Console.WriteLine("c est de type " + typeof(char) + " et occupe " + sizeof(char) + " octet(s) en mémoire.");

...affichera :

i est de type System.Int32 et occupe 4 octet(s) en mémoire.
s est de type System.String.
c est de type System.Char et occupe 2 octet(s) en mémoire.

Conventions d'écriture pour le typage des données écrites "en dur" dans le code

Dans votre code, vous pouvez directement entrer des valeurs à affecter aux variables. La question qui se pose est : de quel type sont les données entrées ? En effet, par exemple le chiffre 2 doit-il être compris comme un int, un uint, un double, ... ? Pour pallier à ce problème, des conventions ont été établies.

Un nombre entier est considéré comme un int s'il tient dans la plage de valeurs d'un int (exemple : -123), et comme un long s'il ne tient pas dans la plage de valeurs d'un int mais dans celle d'un long (exemple : 5111222333).
Un nombre écrit avec un u à la fin symbolise un uint. Exemple : 2u (ou 2U).
Un nombre écrit avec un l à la fin symbolise un long. Exemple : 2l (ou 2L).
Un nombre écrit avec ul à la fin symbolise un ulong. Exemple : 2ul (ou 2UL).
Un nombre écrit avec une partie décimale, ou avec un d à la fin symbolise un double. Exemple : 2.0 ou 2d (ou 2D).
Un nombre écrit avec un f à la fin symbolise un float. Exemple : 2.0f ou 2f (ou 2F).
Un nombre écrit avec un m à la fin symbolise un decimal. Exemple : 2.0m ou 2m (ou 2M).

D'autre part, les guillemets (") servent à encadrer une chaîne de caractères et les apostrophes (') servent à encadrer un caractère.
Exemple : "Bonjour tout le monde" et 'B'.

Utiliser des variables

Déclaration

Pour utiliser une variable, il faut d'abord la déclarer (la créer) : on réserve une partie de la mémoire pour cette variable. On spécifie ce qu'elle représentera (un entier, un caractère, une image, ...) en indiquant son type.
La syntaxe est : type nom;

Valeur par défaut

Une fois que cette ligne est exécutée, de la place est allouée en mémoire pour stocker une valeur.

Par exemple, le code suivant causera une erreur :

static void Main(string[] args)
{
	int myInt;
	Console.WriteLine(myInt);
}

Le compilateur vous dit "Use of unassigned local variable 'myInt'". En fait, le compilateur crie parce qu'il ne sait pas ce que doit valoir notre entier. Il faut donc que vous lui donniez une valeur, par exemple :

static void Main(string[] args)
{
	int myInt = 255;
	Console.WriteLine(myInt);
}

Comme je vous le disais, vous n'êtes pas toujours contraints à spécifier de valeur : dans certains cas, c'est la valeur par défaut qui est automatiquement utilisée. Nous étudierons cela dans le chapitre sur les classes, mais ça ne fait pas de mal d'apprendre dès maintenant les valeurs par défaut :

  • la valeur par défaut de tout type numérique est 0, adapté au type (0.0 pour un float ou un double) ;

  • la valeur par défaut d'une chaîne de caractères (string) est null, et non pas la chaîne vide, qui est représentée par string.Empty ou encore "" ;

  • la valeur par défaut d'un caractère (char) est '\0'.

Attribuer une valeur

Voici comment créer un entier nommé myInteger et ayant la valeur 3 :

int myInteger;
myInteger = 3;

Pour raccourcir, écrivez : int myInteger = 3;.
Cela revient exactement au même : on rassemble la déclaration et l'initialisation. Vous conviendrez que c'est mieux car c'est plus concis.

Voici comment créer une chaîne de caractères valant "Hello world!" et un caractère ("char" signifie "caractère" en anglais) valant 'a' :

string myString = "Hello world!";
char myChar = 'a';

Type valeur ou référence ?

Il existe deux sortes de types : les types valeur (notamment les structures) et les types référence (notamment les classes).

Type valeur

Une variable de type valeurcontient directement l'information. Cela signifie que lorsque cette variable est modifiée, la valeur qu'elle contenait est aussi modifiée.

Cela ne m'a pas paru indispensable de vous apprendre à créer des structures, par contre il faut que vous connaissiez des structures élémentaires. Les types numériques de base sont des structures, donc se comportent comme des types valeur. Le type string est un peu spécial : c'est une classe, mais elle se comporte comme un type valeur.

Type référence

Une variable de type référencecontient l'adresse de l'emplacement mémoire où se trouve l'information. Du coup, une variable qui a la même référence qu'une seconde variable peut être automatiquement changée quand la seconde variable est modifiée.

Nous verrons tout cela bien plus en détail avec les classes. Je voulais juste introduire cette notion car c'est quelque chose de fondamental et je pense que plus c'est pris tôt, plus vous aurez le temps d'y revenir petit à petit pour bien cerner le concept.

Les énumérations

Une énumération est une liste de valeurs qui a un type unique. Ce type est le nom de l'énumération.

Un exemple vaut toujours plus qu'un long discours donc voyez plutôt comment déclarer une énumération désignant les différents temps (dans l'ordre : inconnu, ensoleillé, nuageux, pluvieux) :

enum Weather
{
	Unknown,
	Sunny,
	Cloudy,
	Rainy
}

Chaque valeur doit être suivie d'une virgule, sauf la dernière pour laquelle ce n'est pas obligé (mais vous pouvez quand même le faire ; par contre, c'est moche :p ).
Vous pouvez aussi mettre un point-virgule après l'accolade fermante, mais ce n'est pas nécessaire pour la compilation.

Une fois que cela est fait, vous pouvez déclarer une variable de type Weather comme suit :

Weather todaysWeather = Weather.Sunny;

La variable todaysWeather est ici initialisée à la valeur Sunny.

Si vous ne faites que déclarer la variable, sans l'initialiser, elle prendra automatiquement la première valeur.
Ainsi, Weather todaysWeather; correspond ici à Weather todaysWeather = Weather.Unknown;.

Ce n'est pas dit que vous ayez toujours besoin des énumérations, mais sachez qu'elles sont très utiles quand même. Vous verrez des exemples dans la 2e partie.

namespace ConsoleApplication1
{
	class Program
	{
		enum Weather
		{
			Unknown,
			Sunny,
			Cloudy,
			Rainy
		}
		
		static void Main(string[] args)
		{
			Weather todaysWeather = Weather.Sunny;
		}
	}
}

Ça y est, vous savez ce que sont les variables. Retenez bien qu'il faut d'abord les déclarer, puis les initialiser, pour les utiliser.

L'auteur

Découvrez aussi ce cours en...

Exemple de certificat de réussite
Exemple de certificat de réussite