3. Variables et paramètres

Une variable représente un emplacement de stockage typé. Une variable peut être une variable locale, un paramètre, un élément de tableau, un champ d'instance ou un champ statique.
Toutes les variables sont associées à un type, qui définit essentiellement les valeurs possibles que la variable peut avoir et les opérations qui peuvent être effectuées sur cette variable. C# est fortement typé, ce qui signifie que l'ensemble des opérations qui peuvent être effectuées sur un type sont imposées au moment de la compilation plutôt que par l'environnement d'exécution. De plus, C# est type sécurisé (type-safe), ce qui assure qu'une variable peut être manipulée via le type correct, seulement avec l'aide de la vérification de l'environnement d'exécution (excepté dans les blocs non fiables).

3.1. Définir les assignations

Toutes les variables en C# doivent avoir une valeur assignée avant d'être utilisées. Une variable peut soit être assignée explicitement à une valeur soit être assignée à une valeur par défaut. Une assignation automatique a lieu pour les champs statiques, les instances de classes et pour les tableaux qui n'ont pas reçu l'assignation de valeur explicite.

Code

Résultat

Remarques

using System;

namespace Exemples
{
    class Test
    {
        public int  val_int;
        public bool val_bool;
        // constructeus qui initialisent une instance de Test
        public Test() // val_int sera automatiquement assignée à 0 et val_bool à False
        {
        }
        public Test(int a, bool b) // assignation explicite de la valeur a à val_int et b à val_bool
        {
            val_int = a;
            val_bool = b;
        }

    }
    class DefinirAssignations
    {
        static void Main(string[] args)
        {
            Test[] tests = new Test[2]; // déclare un tableau
            if (tests[0] == null) // OK, les éléments sont assignés à  null
            {
                Console.WriteLine("tests[0] == null");
            }
            tests[0] = new Test(33, true);
            Console.WriteLine(tests[0].val_int); // affiche 33
            Console.WriteLine(tests[0].val_bool); // affiche True
            tests[1] = new Test();
            Console.WriteLine(tests[1].val_int); // affiche 0 par défaut
            Console.WriteLine(tests[1].val_bool); // affiche False par défaut
            Console.ReadKey();
        }
    }
}

tests[0] == null
33
True
0
False

On voit ici que :

les éléments du tableau sont assignés à null,
la valeur par défaut du type numérique est 0 et
la valeur par défaut du type booléen est false.

3.2. Valeurs par défaut

La valeur par défaut pour tous les types primitifs (ou atomiques) est 0 :

Type	Valeur par défaut
Numérique	0
Booléen	False
Char	'\0'
Enum	0
Référence	Null

La valeur par défaut pour chaque champ d'un type complexe (ou composé) est l'une de celle mentionnée ci-dessus.

3.3. Paramètres

Une méthode possède une suite de paramètres. les paramètres définissent l'ensemble des arguments qui doivent être fournis pour cette méthode.

3.3.1. Passer des arguments par valeur

Par défaut, en C#, les arguments sont passés par leur valeur. Ceci est de loin le cas le plus commun et signifie qu'une copie de la valeur est créée lors de son passage à la méthode.

Code

Résultat

Remarques

using System;

namespace Exemples
{
    class PasserArgumentsParValeur
    {
        static void Test(int p) { ++p; }
        static void Main(string[] args)
        {
            int x = 33;
            Test(x); // fait une copie de x
            Console.WriteLine(x); // x est toujours à 33
            Console.ReadKey();
        }
    }
}

Assigner à p une nouvelle valeur ne changera pas le contenu de x, puisque p et x résident chacun dans un espace mémoire différent.

3.3.2. Le modificateur ref

Pour le passage par référence, C# fournit le modificateur de paramètres ref, qui permet à p et à x de se référer aux mêmes emplacements mémoire.

Code

Résultat

Remarques

using System;

namespace Exemples
{
    class ModificateurRef
    {
        static void Test(ref int p) { ++p; }
        static void Main(string[] args)
        {
            int x = 33;
            Test(ref x); // envoi la référence de x à Test
            Console.WriteLine(x); // x est maintenant à 34
            Console.ReadKey();
        }
    }
}

En assignant à p une nouvelle valeur, le contenu de x changera. C'est généralement la raison pour laquelle nous voulons utiliser la passage par référence, bien que parfois ce soit plus efficace pour le passage de larges structures.

3.3.3. Le modificateur out

C# insiste sur le fait que les variables doivent être assignées avant leur utilisation. Il fournit également le modificateur out, qui est le complément naturel du modificteur ref. Alors qu'un modificateur ref requiert qu'une variable soit assignée avant son passage à la méthode, le modificateur out requiert qu'une variable soit assignée avant son retour d'une méthode.

Code

Résultat

Remarques

using System;

namespace Exemples
{
    class ModificateurOut
    {
        static void Split(string prenom_nom, out string prenom, out string nom)
        {
            int pos_espace = prenom_nom.IndexOf(' ');
            prenom = prenom_nom.Substring(0, pos_espace);
            nom = prenom_nom.Substring(pos_espace + 1);
        }
        static void Main(string[] args)
        {
            string prenom, nom ;
            Split("Eric CHAMPION", out prenom, out nom); // Récupération du prenom et du nom
            Console.WriteLine("Prénom : {0}, Nom : {1}", prenom, nom); // affiche Prénom : Eric, Nom : CHAMPION
            Console.ReadKey();
        }
    }
}

prénom : Eric, Nom : CHAMPION

Le nom et le prénom doivent être assignés dans la méthode Split...

3.3.4. Le modificateur de paramètres : params

Le modificateur de paramètres params doit être spécifié sur le dernier paramètre de la méthode pour que la méthode accepte n'importe quel nombre de paramètres d'un type particulier.

Code

Résultat

Remarques

using System;

namespace Exemples
{
    class ModificateurParametres
    {
        static int Add(params int[] iarr)
        {
            int sum = 0;
            foreach (int i in iarr)
                sum += i;
            return sum;
        }
        static void Main(string[] args)
        {
            int somme = Add(1, 2, 3, 4, 5); // affiche 15
            Console.WriteLine(somme);
            Console.ReadKey();
        }
    }
}

Affiche la somme des entiers passés en argument à la méthode Add.