Apprentissage du langage C#

On notera les deux chaînes littérales : "c:\\chap1\\paragraph3" et @"c:\chap1\paragraph3". Dans les chaînes littérales, le caractère \ est interprété. Ainsi "\n" représente la marque de fin de ligne et non la succession des deux caractères \ et n. Si on voulait cette succession, il faudrait écrire "\\n" où la séquence \\ est interprétée comme un seul caractère \. On pourrait écrire aussi @"\n" pour avoir le même résultat. La syntaxe @"texte" demande que texte soit pris exactement comme il est écrit. On appelle parfois cela une chaîne verbatim.

IV-C-2-a. Rôle des déclarations▲

IV-C-2-b. Déclaration des constantes▲

    const type nom=valeur;          //définit constante nom=valeur

const float myPI=3.141592F;

    const  float taux_tva=0.186F;

    const float taux_tva=0.33F;

IV-C-2-c. Déclaration des variables▲

Identificateur_de_type variable1[=valeur1],variable2=[valeur2],...;

var variable1=valeur1,variable2=valeur2,...;

using System;

namespace Chap1 {
    class P00 {
        static void Main(string[] args) {
            int i=2;
            Console.WriteLine("Type de int i=2 : {0},{1}",i.GetType().Name,i.GetType().FullName);
            var j = 3;
            Console.WriteLine("Type de var j=3 : {0},{1}", j.GetType().Name, j.GetType().FullName);
            var aujourdhui = DateTime.Now;
            Console.WriteLine("Type de var aujourdhui : {0},{1}", aujourdhui.GetType().Name, aujourdhui.GetType().FullName);
        }
    }
}

Type de int i=2 : Int32,System.Int32
Type de var j=3 : Int32,System.Int32
Type de var aujourdhui : DateTime,System.DateTime

            var aujourdhui = "aujourd'hui";

La conversion d'une chaîne vers un nombre peut échouer si la chaîne ne représente pas un nombre valide. Il y a alors génération d'une erreur fatale appelée exception. Cette erreur peut être gérée par la clause try/catch suivante :

try{
    appel de la fonction susceptible de générer l'exception
} catch (Exception e){
    traiter l'exception e
}
instruction suivante

Si la fonction ne génère pas d'exception, on passe alors à instruction suivante, sinon on passe dans le corps de la clause catch puis à instruction suivante. Nous reviendrons ultérieurement sur la gestion des exceptions. Voici un programme présentant quelques techniques de conversion entre nombres et chaînes de caractères. Dans cet exemple la fonction affiche écrit à l'écran la valeur de son paramètre. Ainsi affiche(S) écrit la valeur de S à l'écran où S est de type string.

using System;

namespace Chap1 {
    class P01 {
        static void Main(string[] args) {

            // données
            const int i = 10;
            const long l = 100000;
            const float f = 45.78F;
            double d = -14.98;

            // nombre --> chaîne
            affiche(i.ToString());
            affiche(l.ToString());
            affiche(f.ToString());
            affiche(d.ToString());

            //boolean --> chaîne
            const bool b = false;
            affiche(b.ToString());

            // chaîne --> int
            int i1;
            i1 = int.Parse("10");
            affiche(i1.ToString());
            try {
                i1 = int.Parse("10.67");
                affiche(i1.ToString());
            } catch (Exception e) {
                affiche("Erreur : " + e.Message);
            }

            // chaîne --> long
            long l1;
            l1 = long.Parse("100");
            affiche(l1.ToString());
            try {
                l1 = long.Parse("10.675");
                affiche(l1.ToString());
            } catch (Exception e) {
                affiche("Erreur : " + e.Message);
            }

            // chaîne --> double
            double d1;
            d1 = double.Parse("100,87");
            affiche(d1.ToString());
            try {
                d1 = double.Parse("abcd");
                affiche(d1.ToString());
            } catch (Exception e) {
                affiche("Erreur : " + e.Message);
            }

            // chaîne --> float
            float f1;
            f1 = float.Parse("100,87");
            affiche(f1.ToString());
            try {
                d1 = float.Parse("abcd");
                affiche(f1.ToString());
            } catch (Exception e) {
                affiche("Erreur : " + e.Message);
            }

        }// fin main

        public static void affiche(string S) {
            Console.Out.WriteLine("S={0}",S);
        }
    }// fin classe
}

Lignes 30-32, on gère l'éventuelle exception qui peut se produire. e.Message est le message d'erreur lié à l'exception e.

Les résultats obtenus sont les suivants :

S=10
S=100000
S=45,78
S=-14,98
S=False
S=10
S=Erreur : Input string was not in a correct format.
S=100
S=Erreur : Input string was not in a correct format.
S=100,87
S=Erreur : Input string was not in a correct format.
S=100,87
S=Erreur : Input string was not in a correct format.

On remarquera que les nombres réels sous forme de chaîne de caractères doivent utiliser la virgule et non le point décimal. Ainsi on écrira

double d1=10.7;

mais

double d2=int.Parse("10,7");

Un tableau C# est un objet permettant de rassembler sous un même identificateur des données de même type. Sa déclaration est la suivante :

Type[] tableau[]=new Type[n]

n est le nombre de données que peut contenir le tableau. La syntaxe Tableau[i] désigne la donnée n° i où i appartient à l'intervalle [0,n-1]. Toute référence à la donnée Tableau[i] où i n'appartient pas à l'intervalle [0,n-1]provoquera une exception. Un tableau peut être initialisé en même temps que déclaré :

    int[] entiers=new int[] {0,10,20,30};

ou plus simplement :

    int[] entiers={0,10,20,30};

Les tableaux ont une propriété Length qui est le nombre d'éléments du tableau.

Un tableau à deux dimensions pourra être déclaré comme suit :

Type[,] tableau=new Type[n,m];

où n est le nombre de lignes, m le nombre de colonnes. La syntaxe Tableau[i,j] désigne l'élément j de la ligne i de tableau. Le tableau à deux dimensions peut lui aussi être initialisé en même temps qu'il est déclaré :

    double[,] réels=new double[,] { {0.5, 1.7}, {8.4, -6}};

ou plus simplement :

    double[,] réels={ {0.5, 1.7}, {8.4, -6}};

Le nombre d'éléments dans chacune des dimensions peut être obtenue par la méthode GetLength(i) où i=0 représente la dimension correspondant au 1er indice, i=1 la dimension correspondant au 2ième indice…

Le nombre total de dimensions est obtenu avec la propriété Rank, le nombre total d'éléments avec la propriété Length.

Un tableau de tableaux est déclaré comme suit :

Type[][] tableau=new Type[n][];

La déclaration ci-dessus crée un tableau de n lignes. Chaque élément tableau[i] est une référence de tableau à une dimension. Ces références tableau[i] ne sont pas initialisées lors de la déclaration ci-dessus. Elles ont pour valeur la référence null.

L'exemple ci-dessous illustre la création d'un tableau de tableaux :

            // un tableau de tableaux
            string[][] noms = new string[3][];
            for (int i = 0; i < noms.Length; i++) {
                noms[i] = new string[i + 1];
            }//for
            // initialisation
            for (int i = 0; i < noms.Length; i++) {
                for (int j = 0; j < noms[i].Length; j++) {
                    noms[i][j] = "nom" + i + j;
                }//for j
            }//for i

• ligne 2 : un tableau noms de 3 éléments de type string[][]. Chaque élément est un pointeur de tableau (une référence d'objet) dont les éléments sont de type string[].
• lignes 3-5 : les 3 éléments du tableau noms sont initialisés. Chacun "pointe" désormais sur un tableau d'éléments de type string[]. noms[i][j] est l'élément j du tableau de type string [] référencé par noms[i].
• ligne 9 : initialisation de l'éélment noms[i][j] à l'intérieur d'une double boucle. Ici noms[i] est un tableau de i+1 éléments. Comme noms[i] est un tableau, noms[i].Length est son nombre d'éléments.

Voici un exemple regroupant les trois types de tableaux que nous venons de présenter :

using System;

namespace Chap1 {
    // tableaux

    using System;

    // classe de test
    public class P02 {
        public static void Main() {
            // un tableau à 1 dimension initialisé
            int[] entiers = new int[] { 0, 10, 20, 30 };
            for (int i = 0; i < entiers.Length; i++) {
                Console.Out.WriteLine("entiers[{0}]={1}", i, entiers[i]);
            }//for

            // un tableau à 2 dimensions initialisé
            double[,] réels = new double[,] { { 0.5, 1.7 }, { 8.4, -6 } };
            for (int i = 0; i < réels.GetLength(0); i++) {
                for (int j = 0; j < réels.GetLength(1); j++) {
                    Console.Out.WriteLine("réels[{0},{1}]={2}", i, j, réels[i, j]);
                }//for j
            }//for i

            // un tableau de tableaux
            string[][] noms = new string[3][];
            for (int i = 0; i < noms.Length; i++) {
                noms[i] = new string[i + 1];
            }//for
            // initialisation
            for (int i = 0; i < noms.Length; i++) {
                for (int j = 0; j < noms[i].Length; j++) {
                    noms[i][j] = "nom" + i + j;
                }//for j
            }//for i
            // affichage
            for (int i = 0; i < noms.Length; i++) {
                for (int j = 0; j < noms[i].Length; j++) {
                    Console.Out.WriteLine("noms[{0}][{1}]={2}", i, j, noms[i][j]);
                }//for j
            }//for i
        }//Main
    }//class
}//namespace

A l'exécution, nous obtenons les résultats suivants :

entiers[0]=0
entiers[1]=10
entiers[2]=20
entiers[3]=30
réels[0,0]=0,5
réels[0,1]=1,7
réels[1,0]=8,4
réels[1,1]=-6
noms[0][0]=nom00
noms[1][0]=nom10
noms[1][1]=nom11
noms[2][0]=nom20
noms[2][1]=nom21
noms[2][2]=nom22

Il existe différentes instructions d'écriture à l'écran :

Console.Out.WriteLine(expression)

Console.WriteLine(expression)

Console.Error.WriteLine (expression)

où expression est tout type de donnée qui puisse être converti en chaîne de caractères pour être affiché à l'écran. Tous les objets de C# ou .NET ont une méthode ToString() qui est utilisée pour faire cette conversion.

La classe System.Console donne accès aux opérations d'écriture écran (Write, WriteLine). La classe Console a deux propriétés Out et Error qui sont des flux d'écriture de type TextWriter :

• Console.WriteLine() est équivalent à Console.Out.WriteLine() et écrit sur le flux Out associé habituellement à l'écran.
• Console.Error.WriteLine() écrit sur le flux Error, habituellement associé lui aussi à l'écran.

Les flux Out et Error peuvent être redirigés vers des fichiers texte au moment de l'exécution du programme comme nous le verrons prochainement.

Le flux de données provenant du clavier est désigné par l'objet Console.In de type TextReader. Ce type d'objets permet de lire une ligne de texte avec la méthode ReadLine :

    string ligne=Console.In.ReadLine();

La classe Console offre une méthode ReadLine associée par défaut au flux In. On peut donc écrire écrire :

    string ligne=Console.ReadLine();

La ligne tapée au clavier est rangée dans la variable ligne et peut ensuite être exploitée par le programme. Le flux In peut être redirigé vers un fichier, comme les flux Out et Error.

Voici un court programme d'illustration des opérations d'entrées-sorties clavier/écran :

using System;

namespace Chap1 {
    // classe de test
    public class P03 {
        public static void Main() {

            // écriture sur le flux Out
            object obj = new object();
            Console.Out.WriteLine(obj);

            // écriture sur le flux Error
            int i = 10;
            Console.Error.WriteLine("i=" + i);

            // lecture d'une ligne saisie au clavier
            Console.Write("Tapez une ligne : ");
            string ligne = Console.ReadLine();
            Console.WriteLine("ligne={0}", ligne);
        }//fin main
    }//fin classe
}

• ligne 9 : obj est une référence d'objet
• ligne 10 : obj est écrit à l'écran. Par défaut, c'est la méthode obj.ToString() qui est appelée.
• ligne 14 : on peut aussi écrire :

            Console.Error.WriteLine("i={0}",i);

Le 1er paramètre "i={0}" est le format d'affichage, les autres paramètres, les expressions à afficher. Les éléments {n} sont des paramètres "positionnels". A l'exécution, le paramètre {n} est remplacé par la valeur de l'expression n° n.

Le résultat de l'exécution est le suivant :

System.Object
i=10
Tapez une ligne : je suis là
ligne=je suis là

• ligne 1 : l'affichage produit par la ligne 10 du code. La méthode obj.ToString() a affiché le nom du type de la variable obj : System.Object. Le type object est un alias C# du type .NET System.Object.

Il existe sous DOS et UNIX trois périphériques standard appelés :

• périphérique d'entrée standard - désigne par défaut le clavier et porte le n° 0
• périphérique de sortie standard - désigne par défaut l'écran et porte le n° 1
• périphérique d'erreur standard - désigne par défaut l'écran et porte le n° 2

En C#, le flux d'écriture Console.Out écrit sur le périphérique 1, le flux d'écriture Console.Error écrit sur le périphérique 2 et le flux de lecture Console.In lit les données provenant du périphérique 0.

Lorsqu'on lance un programme sous Dos ou Unix, on peut fixer quels seront les périphériques 0, 1 et 2 pour le programme exécuté. Considérons la ligne de commande suivante :

pg arg1 arg2 .. argn

Derrière les arguments argi du programme pg, on peut rediriger les périphériques d'E/S standard vers des fichiers:

On notera que pour rediriger les flux d'E/S du programme pg vers des fichiers, le programme pg n'a pas besoin d'être modifié. C'est le système d'exploitation qui fixe la nature des périphériques 0,1 et 2. Considérons le programme suivant :

using System;

namespace Chap1 {

    // redirections
    public class P04 {
        public static void Main(string[] args) {
            // lecture flux In
            string data = Console.In.ReadLine();
            // écriture flux Out
            Console.Out.WriteLine("écriture dans flux Out : " + data);
            // écriture flux Error
            Console.Error.WriteLine("écriture dans flux Error : " + data);
        }//Main
    }//classe
}

Générons l'exécutable de ce code source :

• en [1] : l'exécutable est créé par clic droit sur le projet / Build
• en [2] : dans une fenêtre Dos, l'exécutable 04.exe a été créé dans le dossier bin/Release du projet.

Emettons les commandes suivantes dans la fenêtre Dos [2] :

...\04\bin\Release>echo test >in.txt
...\04\bin\Release>more in.txt
test
...\04\bin\Release>04 0<in.txt 1>out.txt 2>err.txt
...\04\bin\Release>more out.txt
écriture dans flux Out : test
...\04\bin\Release>more err.txt
écriture dans flux Error : test

• ligne 1 : on met la chaîne test dans le fichier in.txt
• lignes 2-3 : on affiche le contenu du fichier in.txt pour vérification
• ligne 4 : exécution du programme 04.exe. Le flux In est redirigé vers le fichier in.txt, le flux Out vers le fichier out.txt, le flux Error vers le fichier err.txt. L'exécution ne provoque aucun affichage.
• lignes 5-6 : contenu du fichier out.txt. Ce contenu nous montre que :
• le fichier in.txt a été lu
• l'affichage écran a été redirigé vers out.txt
• lignes 7-8 : vérification analogue pour le fichier err.txt

On voit clairement que les flux Out et In n'écrivent pas sur les mêmes périphériques puisqu'on a pu les rediriger séparément.

On s'intéresse ici à l'opération variable=expression;

L'expression peut être de type : arithmétique, relationnelle, booléenne, caractères

IV-D-5-a. Interprétation de l'opération d'affectation▲

IV-D-5-b. Expression arithmétique▲

Les opérateurs des expressions arithmétiques sont les suivants :

+addition

-soustraction

*multiplication

/division : le résultat est le quotient exact si l'un au moins des opérandes est réel. Si les deux opérandes sont entiers le résultat est le quotient entier. Ainsi 5/2 -> 2 et 5.0/2 ->2.5.

%division : le résultat est le reste quelque soit la nature des opérandes, le quotient étant lui entier. C'est donc l'opération modulo.

Il existe diverses fonctions mathématiques. En voici quelques-unes :

double Sqrt(double x)	racine carrée
double Cos(double x)	Cosinus
double Sin(double x)	Sinus
double Tan(double x)	Tangente
double Pow(double x,double y)	x à la puissance y (x>0)
double Exp(double x)	Exponentielle
double Log(double x)	Logarithme népérien
double Abs(double x)	valeur absolue

etc…

Toutes ces fonctions sont définies dans une classe C# appelée Math. Lorsqu'on les utilise, il faut les préfixer avec le nom de la classe où elles sont définies. Ainsi on écrira :

 

Cacher/Afficher le codeSélectionnez

1.
2.

double x, y=4;
x=Math.Sqrt(y);

La définition complète de la classe Math est la suivante :

IV-D-5-c. Priorités dans l'évaluation des expressions arithmétiques▲

IV-D-5-d. Expressions relationnelles▲

      bool fin;
      int x=...;
      fin=x>4;

using System;

namespace Chap1 {
    class P05 {
        static void Main(string[] args) {
            string chaine1="chat", chaine2="chien";
            int n = chaine1.CompareTo(chaine2);
            bool egal = chaine1.Equals(chaine2);
            Console.WriteLine("i={0}, egal={1}", n, egal);
            Console.WriteLine("chien==chaine1:{0},chien!=chaine2:{1}", "chien"==chaine1,"chien" != chaine2);
        }
    }
}

i=-1, egal=False
chien==chaine1:False,chien!=chaine2:False

IV-D-5-e. Expressions booléennes▲

            double x = 3.5;
            bool valide = x > 2 && x < 4;

IV-D-5-f. Traitement de bits▲

short i = 100, j = -13;
ushort k = 0xF123;
Console.WriteLine("i=0x{0:x4}, j=0x{1:x4}, k=0x{2:x4}", i,j,k);
Console.WriteLine("i<<4=0x{0:x4}, i>>4=0x{1:x4},k>>4=0x{2:x4},i&j=0x{3:x4},i|j=0x{4:x4},~i=0x{5:x4},j<<2=0x{6:x4},j>>2=0x{7:x4}", i << 4, i >> 4, k >> 4, (short)(i & j), (short)(i | j), (short)(~i), (short)(j << 2), (short)(j >> 2));

i=0x0064, j=0xfff3, k=0xf123
i<<4=0x0640, i>>4=0x0006,k>>4=0x0f12,i&j=0x0060,i|j=0xfff7,~i=0xff9b,j<<2=0xffcc,j>>2=0xfffc

IV-D-5-g. Combinaison d'opérateurs▲

IV-D-5-h. Opérateurs d'incrémentation et de décrémentation▲

IV-D-5-i. L'opérateur ternaire ?▲

    expr_cond ? expr1:expr2

IV-D-5-j. Priorité générale des opérateurs▲

IV-D-5-k. Les changements de type▲

using System;

namespace Chap1 {
    class P06 {
        static void Main(string[] args) {
            int i = 3, j = 4;
            float f1=i/j;
            float f2=(float)i/j;
            Console.WriteLine("f1={0}, f2={1}",f1,f2);
        }
    }
}

f1=0, f2=0,75

La méthode Exit définie dans la classe Environment permet d'arrêter l'exécution d'un programme.

syntaxe    void Exit(int status)

actionarrête le processus en cours et rend la valeur status au processus père

Exit provoque la fin du processus en cours et rend la main au processus appelant. La valeur de status peut être utilisée par celui-ci. Sous DOS, cette variable status est rendue dans la variable système ERRORLEVEL dont la valeur peut être testée dans un fichier batch. Sous Unix, avec l'interpréteur de commandes Shell Bourne, c'est la variable $? qui récupère la valeur de status.

    Environment.Exit(0);

arrêtera l'exécution du programme avec une valeur d'état à 0.

syntaxe :  if (condition) {actions_condition_vraie;} else {actions_condition_fausse;}

notes:

• la condition est entourée de parenthèses.
• chaque action est terminée par point-virgule.
• les accolades ne sont pas terminées par point-virgule.
• les accolades ne sont nécessaires que s'il y a plus d'une action.
• la clause else peut être absente.
• il n'y a pas de clause then.

L'équivalent algorithmique de cette structure est la structure si .. alors … sinon :

si condition

alors actions_condition_vraie

sinon actions_condition_fausse

finsi

exemple

    if (x>0)  { nx=nx+1;sx=sx+x;} else dx=dx-x;

On peut imbriquer les structures de choix :

if(condition1)
if (condition2)
        {......}
      else         //condition2
         {......}
else         //condition1
     {.......}

Se pose parfois le problème suivant :

using System;

namespace Chap1 {
    class P07 {
        static void Main(string[] args) {
            int n = 5;
            if (n > 1)
                if (n > 6)
                    Console.Out.WriteLine(">6");
                else Console.Out.WriteLine("<=6");
        }
    }
}

Dans l'exemple précédent, le else de la ligne 10 se rapporte à quel if ? La règle est qu'un else se rapporte toujours au if le plus proche : if(n>6), ligne 8, dans l'exemple. Considérons un autre exemple :

            if (n2 > 1) {
                if (n2 > 6) Console.Out.WriteLine(">6");
       } else Console.Out.WriteLine("<=1");

Ici nous voulions mettre un else au if(n2>1) et pas de else au if(n2>6). A cause de la remarque précédente, nous sommes obligés de mettre des accolades au if(n2>1) {…} else …

La syntaxe est la suivante :

switch(expression) {
    case v1:     
            actions1;
            break;
    case v2:     
            actions2;
            break;
         . .. .. .. .. ..
    default:     
            actions_sinon;
            break;
}

notes

• la valeur de l'expression de contrôle du switch peut être un entier, un caractère, une chaîne de caractères
• l'expression de contrôle est entourée de parenthèses.
• la clause default peut être absente.
• les valeurs v_i sont des valeurs possibles de l'expression. Si l'expression a pour valeur v_i , les actions derrière la clause case v_i sont exécutées.
• l'instruction break fait sortir de la structure de cas.
• chaque bloc d'instructions lié à une valeur vi doit se terminer par une instruction de branchement (break, goto, return…) sinon le compilateur signale une erreur.

exemple

En algorithmique

selon la valeur de choix

cas 0

fin du module

cas 1

exécuter module M1

cas 2

exécuter module M2

sinon

erreur<--vrai

findescas

En C#

int choix = 2; 
            bool erreur = false;
            switch (choix) {
                case 0: return;
                case 1: M1(); break;
                case 2: M2(); break;
                default: erreur = true; break;
            }
        }// fin Main

        static void M1() {
            Console.WriteLine("M1");
        }

        static void M2() {
            Console.WriteLine("M2");
        }
}

IV-E-4-a. Nombre de répétitions connu▲

    for (i=id;i<=if;i=i+ip){ 
       actions; 
      }

foreach (Type variable in collection)
    instructions; 
}

            string[] amis = { "paul", "hélène", "jacques", "sylvie" };
            foreach (string nom in amis) {
                Console.WriteLine(nom);
         }

paul
hélène
jacques
sylvie

IV-E-4-b. Nombre de répétitions inconnu▲

    while(condition){
          actions;
        }

    do{
       instructions;
    }while(condition);

for(instructions_départ;condition;instructions_fin_boucle){
    instructions; 
}

            int i, somme, n=10;
            for (i = 1, somme = 0; i <= n; i = i + 1)
                somme = somme + i;
            
            for (i = 1, somme = 0; i <= n; somme = somme + i, i = i + 1) ;
            
            i = 1; somme = 0;
            while (i <= n) { somme += i; i++; }
            
            i = 1; somme = 0;
            do somme += i++;
            while (i <= n);

IV-E-4-c. Instructions de gestion de boucle▲

L'exemple suivant nous montre que les paramètres d'une fonction sont par défaut passés par valeur, c'est-à-dire que la valeur du paramètre effectif est recopiée dans le paramètre formel correspondant. On a deux entités distinctes. Si la fonction modifie le paramètre formel, le paramètre effectif n'est lui en rien modifié.

using System;

namespace Chap1 {
    class P12 {
        public static void Main() {
            int age = 20;
            ChangeInt(age);
            Console.WriteLine("Paramètre effectif age=" + age);
        }
        private static void ChangeInt(int a) {
            a = 30;
            Console.WriteLine("Paramètre formel a=" + a);
        }
    }
}

Les résultats obtenus sont les suivants :

Paramètre formel a=30
Paramètre effectif age=20

La valeur 20 du paramètre effectif age a été recopiée dans le paramètre formel a (ligne 10). Celui-ci a été ensuite modifié (ligne 11). Le paramètre effectif est lui resté inchangé. Ce mode de passage convient aux paramètres d'entrée d'une fonction.

Dans un passage par référence, le paramètre effectif et le paramètre formel sont une seule et même entité. Si la fonction modifie le paramètre formel, le paramètre effectif est lui aussi modifié. En C#, ils doivent être tous deux précédés du mot clé ref :

Voici un exemple :

using System;

namespace Chap1 {
    class P12 {
        public static void Main() {
            // exemple 2
            int age2 = 20;
            ChangeInt2(ref age2);
            Console.WriteLine("Paramètre effectif age2=" + age2);
        }
        private static void ChangeInt2(ref int a2) {
            a2 = 30;
            Console.WriteLine("Paramètre formel a2=" + a2);
        }
    }
}

et les résultats d'exécution :

Paramètre formel a2=30
Paramètre effectif age2=30

Le paramètre effectif a suivi la modification du paramètre formel. Ce mode de passage convient aux paramètres de sortie d'une fonction.

Considérons l'exemple précédent dans lequel la variable age2 ne serait pas initialisée avant l'appel à la fonction changeInt :

using System;

namespace Chap1 {
    class P12 {
        public static void Main() {
            // exemple 2
            int age2;
            ChangeInt2(ref age2);
            Console.WriteLine("Paramètre effectif age2=" + age2);
        }
        private static void ChangeInt2(ref int a2) {
            a2 = 30;
            Console.WriteLine("Paramètre formel a2=" + a2);
        }
    }
}

Lorsqu'on compile ce programme, on a une erreur :

Use of unassigned local variable 'age2'

On peut contourner l'obstacle en affectant une valeur initiale à age2. On peut aussi remplacer le mot clé ref par le mot clé out. On exprime alors que la paramètre est uniquement un paramètre de sortie et n'a donc pas besoin de valeur initiale :

using System;

namespace Chap1 {
    class P12 {
        public static void Main() {
            // exemple 3
            int age3;
            ChangeInt3(out age3);
            Console.WriteLine("Paramètre effectif age3=" + age3);
        }
        private static void ChangeInt3(out int a3) {
            a3 = 30;
            Console.WriteLine("Paramètre formel a3=" + a3);
        }
    }
}

Les résultats de l'exécution sont les suivants :

Paramètre formel a3=30
Paramètre effectif age3=30