Les bases du langage

Les variables

Les données utilisables dans un programme C# sont représentées par des variables. Une variable est un espace mémoire réservé auquel on assigne arbitrairement un nom et dont le contenu est une valeur dont le type est fixé. On peut manipuler ce contenu dans le code en utilisant le nom de la variable.

Les opérateurs

Les opérateurs sont des mots-clés du langage permettant l’exécution de traitements sur des variables, valeurs de retour de fonctions ou valeurs littérales (les opérandes).

La combinaison d’un opérateur et d’un ou plusieurs opérandes constitue une expression qui sera évaluée à l’exécution et retournera un résultat dépendant des différents éléments qui la composent.

Nous avons déjà vu l’opérateur d’affectation = qui permet d’assigner une valeur à une variable. Celle-ci peut être une variable, une valeur littérale, le résultat d’une fonction ou le résultat d’une expression.

Les différents autres opérateurs peuvent être classés en six familles relatives au type de traitement qu’ils permettent d’effectuer.

//Ici, on utilise l'opérateur . pour accéder  
//au membre "Nom" de la variable "personne"  
 
string nomEleve = personne.Nom;  

int[] tableau = new int[10]; 
tableau[0] = 123 ; 

Les structures de contrôle

Les structures de contrôle permettent de créer un flux de traitements complexe. Il existe deux types de structures de contrôle :

if (<expression de condition>) 
{ 
    //Placer ici le code à exécuter si l'expression renvoie true 
} 
[ else if (<expression de condition 2>) 
{ 
    //Placer ici le code à exécuter si la première expression  
    //renvoie false et la seconde expression renvoie true 
}] 
[else if...] 
[ else 
{ 
    //Placer ici le code à exécuter si aucune des expressions  
    //des blocs if et else if ne renvoie true 
}] 

Les fonctions

Les fonctions sont un élément central dans le développement avec C#. En effet, toutes les instructions d’une application écrite en C# doivent être placées dans des fonctions.

Chaque fonction représente une unité de traitement réutilisable pouvant avoir un ou plusieurs paramètres et retournant une valeur.

L’écriture de fonctions permet de structurer le code en découpant de manière logique les fonctionnalités développées. Il est recommandé, pour une bonne lisibilité et une bonne maintenabilité, de limiter la longueur des fonctions.

Nombre de développeurs préconisent ainsi une longueur permettant de voir le code complet d’une fonction dans un écran. Cette longueur est toute relative, mais peut ainsi convenir à chacun. Cette règle n’est évidemment pas absolue mais elle peut aider, notamment dans le cas d’un travail en équipe, à la relecture et au débogage.

Pour tenir cet objectif, il est nécessaire de limiter les responsabilités des fonctions : chacune effectue un type de tâche uniquement.

<modificateur d'accès> <type de retour> <Nom de fonction>(  
[paramètre 1, [paramètre 2]...]) 
{ 
    //Traitements 
    return <valeur>; 
} 

public int CalculerAgeDuCapitaine() 
{ 
    int ageDuCapitaine = 0; 
 
    //Traitements... 
 
    return ageDuCapitaine; 
}  
 
public string RecupererTypeJour() 
{ 
    if (DateTime.Today.Day % 2 == 0) ...

Les tuples

Lorsqu’une fonction doit renvoyer plusieurs valeurs, l’utilisation de paramètres en écriture est une solution tout à fait fonctionnelle. En revanche, elle peut s’avérer rapidement fastidieuse en raison des lourdeurs d’écriture qu’elle implique. Pour éviter cela, la solution la plus cohérente est de renvoyer les différentes valeurs attendues sous la forme d’un ensemble. En C#, ces regroupements de données sont appelés objets : ceci sera abordé en détail au chapitre suivant. La septième mouture du langage intègre la création et l’utilisation d’objets simplistes qui peuvent être utilisés pour retourner plusieurs valeurs : les tuples.

Un tuple est décrit sous la forme d’une suite de types englobée par des parenthèses. Chacun des types correspond à une donnée qui pourra être intégrée dans le groupement de données. La ligne suivante permet de déclarer un tuple contenant deux valeurs entières.

(int, int) maVariable; 

Les tuples peuvent agréger plus de deux valeurs, et même un nombre virtuellement illimité de données. Il n’est toutefois pas recommandé de les utiliser pour regrouper un nombre élevé d’éléments. La déclaration de variable ci-dessous regroupe...

Les attributs

Les attributs sont des éléments de code qui permettent de fournir des informations relatives à d’autres éléments d’une application.

Ils sont enregistrés dans les métadonnées d’un assembly pendant l’étape de compilation et peuvent être lus une fois la compilation terminée. Ils peuvent décrire un assembly, fournir des informations au débogueur ou donner une indication sur l’utilisation d’un élément de code. Il est possible de placer des attributs sur bon nombre d’éléments de code. Ceux-ci sont listés dans l’énumération System.AttributeTargets et incluent notamment les assemblies, les classes et les méthodes.

Un attribut est défini en plaçant dans le code le nom de son type entre les symboles [ et ]. Par convention, les types d’attributs ont un nom terminant par Attribute, mais il est possible, au moment de leur utilisation, de raccourcir ce nom en omettant le suffixe. Les deux déclarations de classe ci-dessous ont donc exactement les mêmes effets.

[ObsoleteAttribute]  
public class Client 
{ 
} 

[Obsolete]  
public class Client 
{ 
} 

La réflexion

La plateforme .NET inclut un jeu de classes et de méthodes permettant de lire les métadonnées des assemblies, dont...