Librairie //Nous allons commencer par un petit programme nous permettant d'afficher un message.
using System;
class Prog
     {
     static void Main()
         {
         Console.WriteLine("coucou");
         }
     }

/* A première vue, on remarque qu'il n'y a aucune directive #include, eh oui, tout est inclu dans la librairie System.La première ligne(using System) signale que l'on fera appel à des fonctions de l'architecture.NET regroupées dans un espace de noms(namespace) appelé System(attention à la casse). Parmi ces fonctions on a la classe 'Console' qui permet de dialoguer avec l'utilisateur en mode console. Différentes fonctions encore appelées méthodes peuvent être appliquées à la classe Console.Dans cet exemple on a par exemple la méthode WriteLine.On aurait pu omettre la directive using, dans ce cas on aurait écrit:
*/
class Prog
     {
     static void Main()
       {
       System.Console.WriteLine("coucou");
       }
     }

Utilisation d'un alias dans la clause using


using Cout = System.Console;
class Prog
     {
     static void Main()
       {
       Cout.WriteLine("coucou");
       }
     }
/* Ici Cout est choisi librement et n'a aucun rapport avec cout du c++ , Cout est l'alias choisi. */

Mot réservés du langage c#

abstract as    
base bool break byte
case catch char checked
class const continue  
decimal default delegate do
double      
else enum event explicit
extern      
false finally fixed float
for foreach    
goto      
if implicit in int
interface internal is  
lock long    
namespace new null  
object operator out override
params private protected public
readonly ref return  
sbyte sealed short sizeof
stackalloc static string struct
switch      
this throw true try
typeof      
uint ulong unchecked unsafe
ushort using    
vitual void    
while      

Type de données du langage c#

entier réel char

byte
valeur comprise entre 0 et 255
codée sur 8 bits

float
entre 1.4*10^-45 et 3.4*10^38
codée sur 32 bits

char
codée sur 16 bits

sbyte
valeur comprise entre -128 et 127
codée sur 8 bits

double
entre 4.9*10^-324 et 1.8*10^308
codée sur 64 bits

  

byte
valeur comprise entre 0 et 255
codée sur 8 bits

decimal
codée sur 128 bits

  

short
valeur comprise entre -32768 et 32767
codée sur 16 bits
 

ushort
valeur comprise entre 0 et 65535
codée sur 16 bits

    

int
valeur comprise entre -2^31 et 2^31 - 1
codée sur 32 bits

    

uint
valeur comprise entre 0 et 2^32 - 1
codée sur 32 bits

    

long
valeur comprise entre -9.2*10^18 et 9.2*10^18
codée sur 64 bits

    

LES TABLEAUX

Par rapport au C/C++, il y a eu d'heureux changements, nettement plus simple et plus fiable qu'en C/C++.

Les tableaux à une dimension

se déclare comme suit:
int[] tata = new int[3]; //on a déclaré et alloué un tableau de trois entiers
On peut aussi déclarer et initialiser en même temps:

t = new int[] {12, 8, 17};
spécifier la taille du tableau n'est pas nécessaire ici, car elle découle automatiquement du nombre de valeurs initiales.

Il est possible de déclarer et de réserver un tableau à condition de l'initialiser(new ne doit plus être écrit bien qu'il soit effectué):
int[] tata = {1, 2, 3};
float[] titi = {3.5f, 1.4f, 15.5f};
string[] fifi ={"niki", "superman", "terror"};

Les tableaux à plusieurs dimensions

int [,] tata = new int[6, 9];
tata est un tableau de 6 lignes et 9 colonnes, on aura donc 54 cellules qui accueilleront un entier.
On peut aussi le déclaré et initialiser de la manière suivante:
int [,] tata = {{0, 1, 2}, {3, 4, 5}};

Les tableaux déchiquetés

Il est possible de créer un tableau de 2 lignes dont chaque ligne contiendrait un nombre différent d'entiers:on parle alors de tableau déchiqueté(jagged array):

int[][] titi; //déclaration du tableau
titi = new int[2][]; //on alloue 2 lignes
titi[0] = new int[3]; //trois entiers en première ligne.
//initialisation de la première ligne
titi[0][0] = 1;
titi[0][1] = 2;
titi[0][2] = 3;
//quatre entiers en seconde ligne(déclaration + initialisation)
titi[1] = new int[]{12, 14, 16, 18};

Ici pour accèder la troisième cellule de la première ligne c'est: titi[0][2]

LES INSTRUCTIONS DU LANGAGE C#

Bloc d'instructions

Plusieurs instructions peuvent être entourées d'accolades.Elles forment un bloc d'instructions.Les variables déclarées dans ce bloc cesseront d'éxister à la sortie du bloc.
N.B: toute instruction doit se trouver dans une fonction et toute fonction doit faire partie d'une classe.

Toute variable doit être initialisée

Le compilateur C# signale une erreur de syntaxe si l'on utilise une variable non initialisée ou si une variable pouvait ne pas être initialisée(par exemple parce que l'assignation a été effectuée dans une branche seulement d'une alternative).

Pas d'instructions séparées par une virgule en C#

On ne peut pas écrire:

i = 1, j = 4; //ça marche en C/C++ mais erreur de syntaxe en C#
Toutes instructions doit être terminées par un point-virgule.

Conversons automatiques et castings

Les castings permettent de forcer des conversions qui ne sont pas automatiquement réalisées par le compilateur. Parce que C# refuse les conversions qui n'ont pas de sens comme par exemple, passer d'une représentation sous forme d'une chaine de caractère à une représentation sous forme d'entier ou de réel,Il est impératif d'utiliser les méthodes des classes Double, long, Single ou Integer.

LES OPÉRATIONS D'ENTRÉE/SORTIE (E/S)

Lecture de données saisies au clavier

La lecture des données se fait par la fonction ReadLine(attention à la casse)une fonction statique de la classe Console.Illustrons cette fonction:

using System;
string t = Console.ReadLine();
int i = Int32.Parse(t);

Attention! les données entrées doivent être de type entier.

autre exemple:
string t = Console.ReadLine();
float v = float.Parse(t);

Lecture fiable d'un entier

int i;
...
try
  {
  string titi = Console.ReadLine();
  i = Int32.Parse(titi);
  Console.WriteLine("données saisies: + i);
  }
catch (Exception e)
  {
  Console.WriteLine("Erreur sur le nombre");
  }

Affichages des données
instructions; affichage
using System;  

Console.WriteLine("Bon");
Console.WriteLine("jour");

 Bon
jour

Console.Write("sa");
Console.WriteLine("lut");

 salut

int i=4;
Console.WriteLine(i);

 4

int i=4;
Console.WriteLine("valeur i:" + i);

 valeur i: 4

int i=4; int j=5;
Console.WriteLine("i = "+ i + "et j = "+ j);

 i = 4 et j = 5

int i=12; int j=3;
Console.WriteLine("i = {0} et j = {1}", i, j);

 i = 12 et j = 3

int i=12; int j=3;
Console.WriteLine(i + j);

 15

int i=12; int j=3;
Console.WriteLine("somme =" + i + j);

 123

int i=12; int j=3;
Console.WriteLine("somme =" + (i + j));

 15

int i=12; int j=3;
Console.WriteLine("somme = {0}", i + j);

 15

int i=12; int j=3;
Console.WriteLine("produit = " + i*j);

 36

int i=12; int j=3;
Console.WriteLine(i + j + "somme = ");

 15 somme =

LES CONDITIONS EN C#

L'instruction if

Rien de nouveau par rapport au C/C++. Tout se déroule suivant la logique de n'importe quel langage moderne. Pour ne pas présenter les choses connues, nous allons juste noter quelques petites différences.

instructions légales en C/C++ écriture en C#:
if (i) if (i != 0)
if (!i) if (i == 0)

if (i = j)
en c/c++, j est copié dans i, puis teste si i est différent de 0

i = j;
if (i != 0)
ou bien
if ((i=j) !=0)

LES BOUCLES

L'instruction foreach

L'instruction foreach permet de parcourir un tableau ainsi qu'une collection

string[] toto = new int[] {60, 18, 45, 5};
foreach (int i in toto) Console.WriteLine(i);

Dans le cas d'un tableau de chaîne de caractères:
string[] tab = {"niki", "terminator", "rambo"};
foreach (string s in tab) Console.Writeline(s);

Se lit: pour chaque cellules du tableau tab, il faut exécuter l'instruction Console.WriteLine.
On peut aussi spécifier plusieurs instructions, il faudra alors penser à les entourer d'accolades comme pour les autres boucles.

L'instruction for

les différentes formes
for (int i=0; i<10; i++)... pareil qu'en c/c++
for (int i=0, j=10; i++, j--) jusque là pas de problème

int i=0; int j=10;
for (;i<5; i++, j--)...

les variables i et j sont déclarées en dehors de la boucle et ne sont donc plus limitées à la boucle
for (;;i++, j--)...

l'initialisation et la condition sont absentes, donc la condition est toujours vraie; utiliser l'instruction break pour sortir de la boucle

for (;;) {...; i++; i--}  
for (; true;) {...; i++; i--} pareil que le précédent


Exemple de boucle for:

int[] tata = {56, 7, 31};
for (int i=0; i< tata.Length; i++)Console.WriteLine(tata[i]);


Les instructions goto, switch, break et continue

Pareil quand C/C++, mais nous devons faire attention car C# modifie le passage d'un case à l'autre(sauf dans le cas où case ne comporte aucune instruction) et accepte les chaînes de caractères dans le sélecteur. Si une clause case comporte au moins une instruction, le passage aux cases suivantes n'est possible qu'en exécutant goto case.Illustrons par un exemple:

ici var est de type entier
switch (var)

  {
   case 0 : une ou plusieurs instructions;
   break;
   case 1 :
   case 2 : une ou plusieurs instructions;
   break;
   case 3 : une ou plusieurs instructions;
   goto case 4;
   case 4 : une ou plusieurs instructions;
   break;
   default : une ou plusieurs instructions;
  }

LES FONCTIONS

Pas rapport au C/C++:
  • toutes les fonctions sont dépendantes d'une classe.
  • différence en ce qui concerne le passage d'argument par référence.
  • pas de différence en ce qui concerne le passage d'argument par valeur.
  • plus de passage d'argument par adresse.
  • pas de prototype ni de fichier à inclure.
  • facilité d'acceptation de tableau.
  • peut renvoyer un tableau.


Exemple de passage d'un tableau en argument:

class Prog {
static void Main()
     {
     int[] tab = {12, 13, 14, 15);
     f(tab);
     foreach (int i in tab) Console.WriteLine(i);
     }
     static void f(int [] titi)
     {
     for (int i=0; i < titi.Length; i++) titi[i]++ ;
     }
   }

Exemple de passage d'arguments par valeur

using System;
class Prog
{
  static void Main()
   {
   int a=6, b;
   f(a); //appel de la fonction f avec le contenu de a en argument
   b = g(a, 3); //b prend la valeur 18
   }
   static void f(int i)
   {
   Console.WriteLine(i); //affiche 6
   }
   static int g(int a1, int a2)
   {
   return a1*a2;
   }
}

Passage d'argument par référence

class Prog
{
   static void Main()
   {
   int a=6;
   f(ref a); //passer a de Main en argument
   Console.WriteLine("{0}", a); //affiche 13
   static void f(ref int a1)
   {
   a1 = 13; //modifie a de Main
   }
}