2. Les éléments de base  en C#
 

Tout est  objet dans C#, en outre C# est un langage fortement typé. Comme en Delphi et en Java vous devez déclarer un objet C# ou une variable C# avec son type avant de l'utiliser. C# dispose de types valeurs intrinsèques qui sont définis à partir des types de base du CLS  (Common Language Specification).
 

2.1 Les types valeurs du CLS dans .NET Framework

Struct

Les classes encapsulant les types élémentaires dans .NET Framework sont des classes de type valeur du genre structures. Dans le CLS  une classe de type valeur est telle que les allocations d'objets de cette classe se font directement dans la pile et non dans le tas, il n'y a donc pas de référence pour un objet de type valeur et lorsqu'un objet de type valeur est passé comme paramètre il est passé par valeur.

Dans .NET Framework les classes-structures de type valeur sont déclarées comme structures et ne sont pas dérivables, les classes de type référence sont déclarées comme des classes classiques et sont dérivables.

Afin d'éclairer le lecteur prenons par exemple un objet x instancié à partir d'une classe de type référence et un objet y instancié à partir d'un classe de type valeur contenant les mêmes membres que la classe par référence. Ci-dessous le schéma d'allocation de chacun des deux objets :

En C# on aurait le genre de syntaxe suivant :
 

Déclaration de classe-structure : struct StructAmoi  {     int b;     void meth(int a){         b = 1000+a;     }  }	instanciation :   StructAmoi y = new StructAmoi ( ) ;
Déclaration de classe : class ClassAmoi  {      int b;      void meth(int a) {        b = 1000+a;      } }	instanciation :   ClassAmoi x = new ClassAmoi ( ) ;

Les classes-structures de type valeur peuvent comme les autres classes posséder un constructeur explicite, qui comme pour tout classe C#  doit porter le même nom que celui de la classe-structure. Exemple ci-desssous d'une classe-structure dénommée Menulang:

public struct Menulang
{
    public String MenuTexte;
    public String Filtre;
    public Menulang(String M, String s)
    {
        MenuTexte = M;
        Filtre = s;
    }
}

On instancie alors un objet de type valeur comme un objet de type référence. En reprenant l'exemple de la classe précédente on instancie et on utilise  un objet Rec :

Menulang Rec = new Menulang ( Nomlang , FiltreLang );
Rec.MenuTexte = "Entrez" ;
Rec.Filtre = "*.ent" ; 

Classe-structure	intervalle de variation	nombre de bits
Boolean	false , true	1 bit
SByte	octet signé -128 ... +127	8 bits
Byte	octet non signé 0 ... 255	8 bits
Char	caractères unicode (valeurs de 0 à 65536)	16 bits
Double	Virgule flottante double précision ~ 15 décimales	64 bits
Single	Virgule flottante simple précision ~ 7 décimales	32 bits
Int16	entier signé court -2^15-1...+2^15	16 bits
Int32	entier signé -2^31-1...+2^31	32 bits
Int64	entier signé long -2^63-1...+2^63	64 bits
UInt16	entier non signé court  0...+2^16-1	16 bits
UInt32	entier non signé 0...+2^32-1	32 bits
UInt64	entier non signé long 0...+2^64-1	64 bits
Decimal	réeel = entier* 10^n (au maximum 28 décimales exactes)	128 bits

 

Compatibilité des types de .NET Framework
 

Le type System.Int32 qui le type valeur entier signé sur 32 bits dans le CLS.  Voici selon 4 langages de .NET Framework  ( VB, C#, C++, J# ) la déclaration syntaxique du type Int32 : [Visual Basic] Public Structure Int32    Implements IComparable, IFormattable, IConvertible [C#] public struct Int32 : IComparable, IFormattable, IConvertible [C++] public __value struct Int32 : public IComparable, IFormattable,    IConvertible [J#] public class Int32 extends System.ValueType implements System.IComparable, System.IFormattable, System.IConvertible

Les trois premières déclarations comportent syntaxiquement le mot clef struct ou Structure  indiquant le mode de gestion par valeur donc sur la pile des objets de ce type. La dernière déclaration en J# compatible syntaxiquement avec Java, utilise une classe qui par contre gère ses objets par référence dans le tas. C'est le CLR qui va se charger de maintenir une cohérence interne entre ces différentes variantes; ici on peut raisonnablement supposer que grâce au mécanisme d'emboîtage (Boxing) le CLR allouera un objet par référence encapsulant l'objet par valeur, mais cet objet encapsulé sera marqué comme objet-valeur.
  

Un type enum est un type valeur qui permet de déclarer un ensemble de constantes de base comme en pascal. En C#, chaque énumération de type enum, possède un type sous-jacent, qui peut être de n'importe quel type entier : byte, sbyte, short, ushort, int, uint, long ou ulong.

Le type int est le type sous-jacent par défaut des éléments de l'énumération. Par défaut, le premier énumérateur a la valeur 0, et l'énumérateur de rang n a la valeur n-1. 

Soit par exemple un type énuméré jour :

1°) Il est possible de déclarer  classiquement une variable du type jour comme un objet de type jour, de l'instancier et de l'affecter :

2°) Il est possible de déclarer  d'une manière plus courte la même variable du type jour et de l'affecter :

2.2 Syntaxe des types valeurs de C# et transtypage

Les types servent à déterminer la nature du contenu d'une variable, du résultat d'une opération, d'un retour de résultat de fonction. Ci-dessous le tableau de correspondance syntaxique entre les types élémentaires du C# et les classes de .NET Framework (table appelée aussi, table des alias) :
 

Types valeurs C#	Classe-structure de .NET Framework	nombre de bits
bool	Boolean	1 bit
sbyte	SByte	8 bits
byte	Byte	8 bits
char	Char	16 bits
double	Double	64 bits
float	Single	32 bits
short	Int16	16 bits
int	Int32	32 bits
long	Int64	64 bits
ushort	UInt16	16 bits
uint	UInt32	32 bits
ulong	UInt64	64 bits
decimal	Decimal	128 bits

Rappellons qu'en C# toute variable qui sert de conteneur à une valeur d'un type élémentaire précis doit préalablement avoir été déclarée sous ce type.

Remarque importante

Une variable de type élémentaire en C# est (pour des raisons de compatibilité CLS) automatiquement un objet de type valeur (Par exemple une variable de type float peut être considérée comme un objet de classe Single).

Il est possible d'indiquer au compilateur le type d'une valeur numérique en utilisant un suffixe :
 

l ou L pour désigner un entier du type long f ou F pour désigner un réel du type float d ou D pour désigner un réel du type double.

Exemples :

45l  ou 45L représente la valeur 45 en entier signé sur 64 bits. 45f  ou 45F représente la valeur 45 en virgule flottante simple précision sur 32 bits. 45d  ou 45D représente la valeur 45 en virgule flottante double précision sur 64 bits. 5.27e-2f  ou 5.27e-2F représente la valeur 0.0527 en virgule flottante simple précision sur 32 bits.

Transtypage opérateur (  )

Les conversions de type en C# sont identiques pour les types numériques aux conversions utilisées dans un langage fortement typé comme Delphi par exemple. Toutefois C# pratique la  conversion implicite lorsque celle-ci est possible. Si vous voulez malgré tout, convertir explicitement une valeur immédiate ou une valeur contenue dans une variable il faut utiliser  l'opérateur de transtypage noté ( ). Nous nous sommes déjà servi de la fonctionnalité de transtypage explicite au paragraphe précédent dans l'instruction  : int rang = (int)unJour;  et dans l'instruction if ( (jour)repos == unJour )...

Transtypage implicte en C# :

• int n = 1234;
• float x1 = n ;
• double x2 = n ;
• double x3 = x1 ;
• long p = n ;

.....

Transtypage explicite en C# :

• Tous les types élémentaires peuvent être transtypés à l'exception du type boolean qui ne peut pas être converti en un autre type (différence avec le C).

• Les conversions peuvent être restrictives quant au résultat; par exemple le transtypage du réel 5.27e-2 en entier ( x = (int)5.27e-2)  mettra l'entier zéro dans x.

2.3 Variables, valeurs, constantes en C#
 

Identificateurs de variables Déclarations et affectation de variables Les constantes en C# Base de représentation des entiers

Comme en Java, une variable C# peut contenir soit une valeur d'un type élémentaire, soit une référence à un objet. Les variables jouent le même rôle que dans les langages de programmation classiques impératifs, leur visibilité est étudié dans le prochain chapitre.

Les identificateurs de variables en C# se décrivent comme ceux de tous les langages de programmation :

Identificateur C# :

Attention C#  fait une différence entre majuscules et minuscules, c'est à dire que la variable BonJour n'est pas la même que la variable bonjour ou encore la variable Bonjour. En plus des lettres, les caractères suivants sont autorisés pour construire une identificateur C# : "$" , "_" , "µ" et les lettres accentuées.

Exemples de déclaration de variables :

int Bonjour ;  int µEnumération_fin$;
float Valeur ;
char UnCar ;
boolean Test ;

etc ...

Exemples d'affectation de valeurs à ces variables :

Affectation	Déclaration avec initialisation
Bonjour = 2587 ; Valeur = -123.5687 UnCar =  'K' ; Test = false ;	int Bonjour = 2587 ; float Valeur = -123.5687 char UnCar =  'K' ; boolean Test = false ;

Exemple avec transtypage :
int Valeur ;
char car = '8' ;
Valeur = (int)car - (int)'0';
 

fonctionnement de l'exemple :

Lorsque la variable car est l'un des caractères '0', '1', ... ,'9', la variable Valeur est égale à la valeur numérique associée (il s'agit d'une conversion car = '0' ---> Valeur = 0, car = '1' ---> Valeur = 1, ... , car = '9' ---> Valeur = 9).
 

Les constantes en C#

C# dispose de deux mots clefs pour qualifier des variables dont le contenu ne peut pas être modifié : const et readonly sont des qualificateurs de déclaration qui se rajoutent devant les autres qualificateurs de déclaration..

- Les constantes qualifiées par const doivent être initialisées lors de leur déclaration. Une variable membre de classe ou une variable locale à une méthode peut être qualifiée en constante const. Lorsque de telles variables sont déclarées comme variables membre de classe, elles sont considérées comme des variables de classe statiques :
 

• const int x ; // erreur , le compilateur n'accepte pas une constante non initialisée.

• const int x = 1000 ; // x est déclarée comme constante entière initialisée à 1000.
•  x = 8 ;  <------ provoquera une erreur de compilation interdisant la modification de la valeur de x.

- Les constantes qualifiées par readonly sont uniquement des variables membre de classes, elles peuvent être initialisées dans le constructeur de la classe (et uniquement dans le constructeur) :
 

• readonly int x ; // correct.

 
• readonly int x = 100 ; // correct.

Base de représentation des entiers

C# peut représenter les entiers dans 2 bases de numération différentes  : décimale (base 10), hexadécimale (base 16). La détermination de la base de représentation d'une valeur est d'ordre syntaxique grâce à un préfixe :
 

pas de préfixe  ----> base = 10  décimal.   préfixe 0x        ----> base = 16   hexadécimal

 
 

2.4 Priorité d'opérateurs en C#

Les  opérateurs du C# sont très semblables à ceux de Java et donc de C++, ils sont détaillés par famille, plus loin . Ils sont utilisés comme dans tous les langages impératifs pour manipuler, séparer, comparer ou stocker des valeurs. Les opérateurs ont soit un seul opérande, soit deux opérandes, il n'existe en C# qu'un seul opérateur à trois opérandes (comme en Java) l'opérateur conditionnel  " ? : ".

Dans le tableau ci-dessous les opérateurs de C# sont classés par ordre de priorité croissante (0 est le plus haut niveau, 13 le plus bas niveau). Ceci sert lorsqu'une expression contient plusieurs opérateurs à indiquer l'ordre dans lequel s'effectueront les opérations.
 

• Par exemple sur les entiers l'expression 2+3*4 vaut 14 car l'opérateur * est plus prioritaire que l'opérateur +, donc l'opérateur * est effectué en premier.

• Lorsqu'une expression contient des opérateurs de même priorité alors C# effectue les évaluations de gauche à droite. Par exemple l'expression 12/3*2 vaut 8 car C# effectue le parenthésage automatique de gauche à droite ((12/3)*2).

Tableau général de toutes les priorités
 

priorité	tous les opérateurs de C#
0	( )     [  ]      .  new
1	!     ~     ++    --
2	*     /    %
3	+    -
4	<<    >>
5	<     <=    >   >=    is
6	= =     !=
7	&
8	^
9	|
10	&&
11	||
12	? :
13	=  *=  /=  %=  +=  -=  ^=  &=  <<=  >>=  >>>=  |=

3. Les opérateurs en C# 

Opérateurs arithmétiques Opérateurs de comparaison Opérateurs booléens Opérateurs bit level

3.1 Opérateurs arithmétiques

opérateurs travaillant avec des opérandes à valeur immédiate ou variable

Opérateur	priorité	action	exemples
+	1	signe positif	+a;  +(a-b); +7 (unaire)
-	1	signe négatif	-a;  -(a-b); -7 (unaire)
*	2	multiplication	5*4;  12.7*(-8.31); 5*2.6
/	2	division	5 / 2;    5.0 / 2;   5.0 / 2.0
%	2	reste	5 % 2;    5.0 %2;   5.0 % 2.0
+	3	addition	a+b; -8.53 + 10; 2+3
-	3	soustraction	a-b; -8.53 - 10; 2-3

Ces opérateurs sont binaires (à deux opérandes) exceptés les opérateurs de signe positif ou négatif. Ils travaillent tous avec des opérandes de types entiers ou réels. Le résultat de l'opération est converti automatiquement en valeur du type des opérandes.

L'opérateur " % " de reste n'est intéressant que pour des calculs sur les entiers longs, courts, signés ou non signés : il renvoie le reste de la division euclidienne de 2 entiers.

Exemples d'utilisation de l'opérateur de division selon les types des opérandes et du résultat :
 

programme C#	résultat obtenu	commentaire
int x = 5 , y  ;	x = 5 , y =???	déclaration
float a , b = 5 ;	b = 5 , a =???	déclaration
y = x / 2 ;	y = 2  // type int	int x et int 2  résultat : int
y = b / 2 ;	erreur de conversion	conversion implicite impossible (float b --> int y)
y = b / 2.0 ;	erreur de conversion	conversion implicite impossible (float b --> int y)
a = b / 2 ;	a = 2.5  // type float	float b et int 2  résultat : float
a = x / 2 ;	a = 2.0  // type float	int x et int 2  résultat : int conversion automatique int 2 --> float  2.0
a = x / 2f ;	a = 2.5  // type float	int x et float 2f  résultat : float

Pour l'instruction précédente " y = b / 2 " engendrant une erreur de conversion voici deux corrections possibles utilisant le transtypage explicite :

y = (int)b / 2 ;    // b est converti en int avant la division qui s'effectue sur deux int.
y = (int)(b / 2) ; // c'est le résultat de la division qui est converti en int.
 

opérateurs travaillant avec une  unique variable comme opérande

Opérateur	priorité	action	exemples
++	1	post ou pré incrémentation : incrémente de 1 son opérande numérique : short, int, long, char, float, double.	++a;  a++; (unaire)
--	1	post ou pré décrémentation : décrémente de 1 son opérande numérique : short, int, long, char, float, double.	--a;  a--; (unaire)

L'objectif de ces opérateurs est l'optimisation de la vitesse d'exécution du bytecode MSIL dans le CLR et surtout la reprise aisée de code source C#et C++.

post-incrémentation : k++
la valeur de k est d'abord utilisée telle quelle dans l'instruction, puis elle est augmentée de un à la fin. Etudiez bien les exemples ci-après qui vont vous permettre de bien comprendre le fonctionnement de cet opérateur.

Nous avons mis à côté de l'instruction C#  les résultats des contenus des variables après exécution de l'instruction de déclaration et de la post incrémentation.

Exemple 1 :

int k = 5 , n ;  n = k++ ;

n = 5

k = 6

Exemple 2 :

int k = 5 , n ;   n = k++ - k ;

n = -1

k = 6

Dans l'instruction k++ - k nous avons le calcul suivant : la valeur de k (k=5) est utilisée comme premier opérande de la soustraction, puis elle est incrémentée (k=6), la nouvelle valeur de k est maintenant utilisée comme second opérande de la soustraction ce qui revient à calculer n = 5-6 et donne n = -1 et k = 6.

Exemple 3 :

int k = 5 , n ;   n = k - k++  ;

n = 0

k = 6

Dans l'instruction k - k++ nous avons le calcul suivant : la valeur de k (k=5) est utilisée comme premier opérande de la soustraction, le second opérande de la soustraction est k++ c'est la valeur actuelle de k qui est utilisée (k=5) avant incrémentation de k, ce qui revient à calculer n = 5-5 et donne n = 0 et k = 6.

Exemple 4 :Utilisation de l'opérateur de post-incrémentation en combinaison avec un autre opérateur unaire.
int nbr1, z , t , u , v  ;

nbr1 = 10 ;   v = nbr1++	v = 10	nbr1 = 11
nbr1 = 10 ;   z = ~ nbr1 ;	z = -11	nbr1 = 10
nbr1 = 10 ;   t = ~ nbr1 ++ ;	t = -11	nbr1 = 11
nbr1 = 10 ;   u = ~ (nbr1 ++) ;	u = -11	nbr1 = 11

  La notation " (~ nbr1) ++ " est refusée par C#
remarquons que les expressions "~nbr1 ++  " et  "~ (nbr1 ++)" produisent les mêmes effets, ce qui est logique puisque lorsque deux opérateurs (ici ~ et ++ )ont la même priorité, l'évaluation a lieu de gauche à droite.
 

pré-incrémentation : ++k
la valeur de k est d'abord augmentée de un ensuite utilisée dans l'instruction.

Exemple1 :
int k = 5 , n ;

n = ++k ;

n = 6

k = 6

Exemple 2 :

int k = 5 , n ;   n = ++k - k ;

n = 0

k = 6

Dans l'instruction ++k - k nous avons le calcul suivant : le premier opérande de la soustraction étant ++k c'est donc la valeur incrémentée de k (k=6) qui est utilisée, cette même valeur sert de second opérande à la soustraction ce qui revient à calculer n = 6-6 et donne n = 0 et k = 6.

Exemple 3 :

int k = 5 , n ;   n = k - ++k  ;

n = -1

k = 6

Dans l'instruction k - ++k nous avons le calcul suivant : le premier opérande de la soustraction est k (k=5), le second opérande de la soustraction est ++k, k est immédiatement incrémenté  (k=6) et c'est sa nouvelle valeur incrémentée qui est utilisée, ce qui revient à calculer n = 5-6 et donne n = -1 et k = 6.
 
 

post-décrémentation : k--
la valeur de k est d'abord utilisée telle quelle dans l'instruction, puis elle est diminuée de un à la fin.

Exemple1 :
int k = 5 , n ;

n = k-- ;

n = 5

k = 4

 

pré-décrémentation : --k
la valeur de k est d'abord diminuée de un, puis utilisée avec sa nouvelle valeur. 

Exemple1 :
int k = 5 , n ;

n = --k ;

n = 4

k = 4

Reprenez avec l'opérateur - - des exemples semblables à ceux fournis pour l'opérateur ++ afin d'étudier le fonctionnement de cet opérateur (étudiez (- -k - k) et (k -  - -k)).
 
 

3.2 Opérateurs de comparaison

Ces opérateurs employés dans une expression renvoient un résultat de type booléen (false ou true). Nous en donnons la liste sans autre commentaire car ils sont strictement identiques à tous les opérateurs classiques de comparaison de n'importe quel langage algorithmique (C, pascal, etc...). Ce sont des opérateurs à deux opérandes.
 

Opérateur	priorité	action	exemples
<	5	strictement inférieur	5 < 2 ;  x+1 < 3 ;   y-2 < x*4
<=	5	inférieur ou égal	-5 <= 2 ;  x+1 <= 3 ;  etc...
>	5	strictement supérieur	5 > 2 ;  x+1 > 3 ;  etc...
>=	5	supérieur ou égal	5 >= 2 ;    etc...
= =	6	égal	5 = = 2 ;  x+1 = = 3 ; etc...
!=	6	différent	5 != 2 ;  x+1 != 3 ; etc...

 
 

3.3 Opérateurs booléens

Ce sont les opérateurs classiques de l'algèbre de boole { { V, F }, ! , & , | } où { V, F } représente l'ensemble {Vrai,Faux}. Les connecteurs logiques ont pour syntaxe en C#  :  ! , & , | , ^ :

&  : { V, F } x { V, F } ®{ V, F } (opérateur binaire qui se lit " et ")
|    : { V, F } x { V, F } ®{ V, F } (opérateur binaire qui se lit " ou ")
!    : { V, F } ¾®{ V, F } (opérateur unaire qui se lit " non ")
^    : { V, F } x { V, F } ®{ V, F } (opérateur binaire qui se lit " ou exclusif ")

Table de vérité des opérateurs ( p et q étant des expressions booléennes)

Remarque :

"p Î { V, F } , "q Î { V, F }  , p &q est toujours évalué en entier ( p et q sont toujours évalués). "p Î { V, F } , "q Î { V, F }  , p |q  est toujours évalué en entier ( p et q sont toujours évalués).

C# dispose de 2 clones des opérateurs binaires & et | . Ce sont les opérateurs && et || qui se différentient de leurs originaux & et | par leur mode d'exécution optimisé (application de théorèmes de l'algèbre de boole) :
 

Opérateur  et optimisé : &&

Théorème "q Î { V, F }  ,  F &q = F

Donc si p est faux (p = F)  , il est inutile d'évaluer q car l'expression p &q est fausse (p &q = F), comme l'opérateur & évalue toujours l'expression q, C#  à des fin d'optimisation de la vitesse d'exécution du bytecode MSIL dans le CLR , propose un opérateur ou noté && qui a la même table de vérité que l'opérateur & mais qui applique ce théorème.

"p Î { V, F } , "qÎ { V, F }  , p &&q = p &q Mais dans p&&q  ,  q n'est évalué que si p = V.

 

Opérateur ou optimisé : | |

Théorème "q Î { V, F }  ,  V |q = V

Donc si p est vrai (p = V)  , il est inutile d'évaluer q car l'expression p |q est vraie (p |q = V), comme l'opérateur |  évalue toujours l'expression q, C# à des fin d'optimisation de la vitesse d'exécution du bytecode dans la machine virtuelle C# propose un opérateur ou noté ||  qui applique ce théorème et qui a la même table de vérité que l'opérateur | .

"p Î { V, F } , "q Î { V, F }  , p ||q = p |q Mais dans p||q  ,  q n'est évalué que si p = F.

En résumé:

Opérateur	priorité	action	exemples
!	1	non booléen	! (5 < 2) ;  !(x+1 < 3) ; etc...
&	7	et booléen complet	(5 = = 2) & (x+1 < 3) ;   etc...
|	9	ou booléen complet	(5 != 2) | (x+1 >= 3) ;   etc...
&&	10	et booléen optimisé	(5 = = 2) && (x+1 < 3) ;   etc...
||	11	ou booléen optimisé	(5 != 2) || (x+1 >= 3) ;   etc...

Nous allons voir ci-après une autre utilisation des opérateurs &et | sur des variables ou des valeurs immédiates en tant qu'opérateur bit-level.