Mot clé
Description
abstract
spécifie qu'une classe est destinée seulement à être une classe de base d'autres classes et qu'une méthode ou une propriété ne contient pas d'implémentation.
objet = valeur as type_reference
convertit explicitement une valeur vers un type de référence spécifié.
base
permet d'accéder aux membres de la classe de base à partir d'une classe dérivée.
bool
déclare un type de valeur booléen.
break;
arrête l'exécution de boucles ou d'une structure conditionnellle.
byte
déclare un type de valeur octale.
case condition: ...
constitue un cas dans une structure conditionnelle switch case.
catch(System.Exception e){...}
constitue le bloc de traitement d'une exception dans une instruction try catch finally.
char
déclare un type de valeur caractère.
checked
contrôle le débordement d'une expression arithmétique.
class Nom {...}
crée une classe.
const NOM
déclare une constante.
continue;
arrête l'exécution d'une boucle tout en continuant celles des niveaux supérieurs.
decimal
déclare un type de valeur décimale.
default: ...
consititue le cas par défaut dans une structure conditionnelle switch case.
delegate
définit un type référence pouvant être utilisé pour encapsuler une méthode avec une signature spécifique.
do{...} while(i < 10)
crée une boucle faire tant qu'une condition n'est pas atteinte.
double
déclare un type de valeur à virgule flottante de double précision.
else {...}
constitue une alternative par défaut dans une structure conditionnelle if else.
enum Nom {...}
crée un type d'énumération (enum type).
event
déclare un événement.
explicit
déclare explicitement un opérateur de conversion de type utilisateur défini.
extern
indique qu'une méthode est implémentée extérieurement.
false
représente une valeur booléenne (0).
finally {...}
constitue le bloc de finalisation dans une instruction try catch finally.
fixed
empêche un changement de localisation d'une variable par le Garbage Collector.
float
déclare un type de valeur à virgule flottante.
for(int i = 0; i < 10; i++){...}
crée une boucle compacte à partir d'une initialisation, d'une condition et d'une incrémentation.
foreach(element in tableau){...}
crée une boucle parcourant chaque élément d'une structure tabulaire comme un tableau ou une chaîne de caractères.
goto
transfère le contrôle du programme directement à une déclaration labélisée.
if (arrivee == true) {...}
constitue la première alternative dans une structure conditionnelle if else.
implicit
déclare implicitement un opérateur de conversion de type défini par l'utilisateur.
element in struct_tab
permet, à partir d'une instruction foreach, l'extraction d'un élément dans une structure tabulaire.
int
déclare un type de valeur entier.
interface INom {...}
crée une interface.
internal
représente un modificateur d'accès pour les types et les membres types.
expression is type
vérifie la compatibilité entre une expression et un type spécifié.
lock(variable){...}
permet d'obtenir un verrou d'exclusion mutuelle, d'exécuter ses instructions puis de libérer ce verrou.
long
déclare un type de valeur entier long.
namespace
déclare un espace de noms.
new
créee une instance de classe, soit un objet.
null
représente la valeur spéciale nulle.
object
constitue un alias pour la classe System.Object dans le Framework.NET.
operator
déclare un opérateur dans une classe ou une déclaration struct.
out
affecte globalement une variable passée en argument à une méthode paramètrée.
override
fournit une nouvelle implémentation d'un membre virtuel hérité d'une classe de base.
params
permet de spécifier un paramètre de méthode qui prend un argument où le nombre d'arguments et variable.
private
représente un modificateur d'accès privé.
protected
représente un modificateur d'accès protégé.
public
représente un modificateur d'accès privé.
readonly
déclare un champ en lecture seule qui peut être assigné à une valeur directement dans la déclaration ou dans un constructeur.
ref
affecte globalement une variable, initialisée préalablement, passée en argument à une méthode paramètrée.
return
termine l'exécution d'une méthode et retourne éventuellement son résultat.
sbyte
constitue un type entier dont l'intervalle va de -128 à 127.
sealed
indique qu'une classe est scellée, c'est-à-dire qu'elle ne peut être héritée.
short
déclare un type de valeur entier court.
sizeof
détermine la taille
stackalloc
alloue un bloc mémoire sur la pile.
static
déclare un membre statique, qui appartient au type lui même plutôt quà un objet spécifique.
string
représente une chaîne de caractères encodée en Unicode.
struct Nom {...}
crée un type de structure.
switch(variable){...}
constitue une structure conditionnelle switch case.
this
se réfère à l'instance courante de la classe.
throw new Exception("Divide by zero");
lance une exception.
true
représente une valeur booléenne (1).
try {...}
constitue le bloc d'exécution d'un code susceptible d'émettre une exception dans une instruction try catch finally.
typeof
permet d'obtenir l'objet System.Type pour un type.
uint
déclare un type de valeur entier non-signé.
ulong
déclare un type de valeur entier long non-signé.
unchecked
contrôle le débordement d'un bloc d'instructions pour des opérations arithmétiques et de conversions.
unsafe
déclare un contexte de code non sécurisé, .NET ne gérant ni l'allocation, ni la libération mémoire.
ushort
déclare un type de valeur entier court non-signé.
using System;
déclare que le code doit utiliser l'espace de noms spécifié. Il permet également de créer un alias vers une classe utilisable dans le document source (using IO = System.io;).
virtual
déclare un membre virtuel dont l'implémentation peut être changée par un membre affublé du modificateur override.
void nom_methode(){...}
indique qu'une méthode ne renvoie aucun résultat.
volatile
spécifie qu'un champ peut être modifié dans le programme par quelquechose comme le système d'exploitation.
while(i < 10){...}
crée une boucle tant qu'une condition n'est pas atteinte.