Apprenez à programmer en C#

Depuis le début de ce cours, nous utilisons des fonctions (ou méthodes) comme  Console.WriteLine()  . Dans ce chapitre, vous allez vous familiariser avec les différents composants de la déclaration d'une méthode (paramètres et valeur de renvoi), et la différence entre un type valeur et un type référence.

De quoi est constituée une déclaration de méthode ?

Supposons que vous ayez un rectangle de 6 (de longueur) par 4 (de largeur), et que vous vouliez calculer son périmètre.

public static void AfficherPerimetre()
{
    int perimetre = 2*(6 + 4);
    Console.WriteLine(perimetre); // -> 20
}

Cette méthode est certes correcte, mais tout à fait inutile, car elle utilise toujours les mêmes chiffres. Alors, comment faire pour qu’elle calcule un périmètre avec d’autres données ?

Fonctions avec paramètres

Pour remédier à cette limite, vous devez faire en sorte que votre fonction accepte des données extérieures. Pour cela, vous pouvez définir une fonction dotée de paramètres.

En C#, la déclaration d'une fonction inclut le nom de la variable et le type du paramètre. Voici à quoi cela ressemble :

public static void AfficherPerimetre(int longueur, int largeur)
{
    int perimetre = 2 * (longueur + largeur);
    Console.WriteLine(perimetre); // -> La valeur affichée dépend de la longueur et la largeur
}

Les paramètres sont des variables listées dans la déclaration de la fonction. Elles sont spécifiées à l'intérieur de parenthèses () par leur type et leur nom. Vous pouvez maintenant appeler cette fonction et lui passer les valeurs que vous voulez :

AfficherPerimetre(10, 11); // -> 42
AfficherPerimetre(2, 2); // -> 8

Chaque valeur est affectée à un paramètre selon l'ordre dans lequel ils sont définis.

Détaillons un peu cette nouvelle terminologie. Les paramètres sont les variables déclarées dans une fonction. Les valeurs passées à cette fonction s'appellent des arguments.

Parfait, nous avons ajouté un but à notre fonction.

Souvent, le code qui a appelé la fonction a besoin d'une réponse pour effectuer son propre travail. Cette réponse peut être fournie par la valeur de retour de la fonction.

Définissez une valeur de retour

Pour définir une valeur de retour, vous devez :

1. Modifier la déclaration de la fonction pour indiquer que l'on s'attend à ce qu'elle renvoie un résultat.

2. Terminer la fonction avec le mot-clé return.

Voici comment créer une fonction  Somme  qui renverra le résultat du calcul pour qu'il soit utilisé par la fonction d'appel :

public static int Somme(int a, int b)
{
    int calc = a + b;
    return calc;
}

Vous pouvez également renoncer à la variable calc et renvoyer directement le résultat de l'expression de calcul :

public static int Somme(int a, int b)
{
    return a + b;
}

Une fois votre fonction définie, vous pouvez l'utiliser autant de fois que vous le souhaitez. Voici quelques variantes :

int sommeDePetitsNombres = Somme(3,7);
Console.WriteLine(sommeDePetitsNombres); // -> 10
int sommeDeGrandsNombres  = Somme(sommeDePetitsNombres,999);
Console.WriteLine(sommeDeGrandsNombres); // -> 1009

Dans l'exemple ci-dessus, nous avons utilisé le résultat du premier calcul comme paramètre pour le suivant.

Un autre élément à comprendre et à assimiler : certaines variables contiennent directement une valeur, tandis que d'autres contiennent plutôt une référence. Cette différence a un impact sur la façon dont elles sont envoyées comme arguments à une fonction.

Comprenez la différence entre les types valeur et les types référence

Vous avez appris qu'il existe des types de variables simples (comme les nombres ou les chaînes) ou plus complexes (comme les classes).

Chacun de ces types est considéré comme un type valeur ou un type référence.

Commençons par le type valeur.

Types valeur

Prenons l'exemple des nombres entiers. Si vous créez une variable de type int et que vous lui donnez une valeur, puis que vous affectez cette variable à une seconde variable int, la valeur de la première sera copiée dans la seconde :

// Déclarer une variable « a » de type « int » et l'initialiser avec la valeur 10
int a = 10;
// Déclarer une variable « b » de type « int » et l'initialiser avec une copie de la valeur de « a »
int b = a;

Puisque  int  est un type valeur, une copie de la valeur de a est affectée à b. Les deux valeurs sont indépendantes. Cela signifie que si vous modifiez ultérieurement la valeur de  a  , la valeur de  b  ne sera pas modifiée.

Console.WriteLine(a); // -> 10
Console.WriteLine(b); // -> 10
a = 15;
Console.WriteLine(a); // -> 15
Console.WriteLine(b); // -> 10

C'est assez simple. Viennent ensuite les types référence.

Types référence

Dans cette section, nous allons travailler avec des classes. Lorsque vous créez une variable et lui affectez une instance de classe, l'objet est créé, mais la variable elle-même contient une référence à cet objet : l'emplacement où il est stocké dans la mémoire. Ensuite, lorsque vous affectez la valeur de cette variable à une autre variable, l'objet lui-même n'est pas copié. Ainsi, la nouvelle variable contiendra elle aussi une référence à cet objet, la même adresse.

En voici un exemple :

public class Voiture
{
    public String couleur = "rouge";
}


Voiture voiture = new Voiture();
Voiture voitureAPeindre = voiture;

Si vous voulez changer la couleur de la voiture qui est accessible par la deuxième variable, la première variable sera également affectée, car les deux pointent exactement vers la même instance de la classe Voiture :

public class Voiture
{
    public String couleur = "rouge";
}

Voiture voiture = new Voiture();
Voiture voitureAPeindre = voiture;
Console.WriteLine(voiture.couleur); // -> rouge
Console.WriteLine(voitureAPeindre.couleur); // -> rouge


voitureAPeindre.couleur = "jaune";
Console.WriteLine(voiture.couleur); // ->jaune
Console.WriteLine(voitureAPeindre.couleur); // -> jaune

Vous voyez la différence ? ⚡️ C'est très utile, car cela permet d'économiser beaucoup de mémoire si vous devez transmettre le même objet plusieurs fois dans votre programme. Cependant, cette particularité peut également être dangereuse, car changer un objet dans une partie d'un programme affecte toutes les autres parties du programme qui utilisent le même objet.

C'est une chose à laquelle vous allez devoir faire attention lorsque vous utiliserez des arguments de fonctions. Si vous passez des types de référence en tant qu'arguments, toutes les modifications que vous allez effectuer sur eux dans ces fonctions modifieront les objets d'origine.

public class Voiture
{
    public String couleur = "rouge";
}


public static void Peindre(Voiture voiture, String couleur)
{
    voiture.couleur = couleur;
}


Voiture voiture = new Voiture();
Console.WriteLine(voiture.couleur); // -> rouge
Peindre(voiture, "verte");
Console.WriteLine(voiture.couleur); // -> verte

Mais les arguments des fonctions ne seraient-ils pas des constantes en C# ? En effet, en C#, les arguments d'une fonction sont des constantes et ne peuvent pas être modifiés, ce qui signifie que vous ne pouvez pas affecter une nouvelle valeur à l'ensemble du nouvel objet (ou à une référence à un objet). Mais vous pouvez tout à fait modifier les attributs de cet objet. C'est ce que nous avons fait dans l'exemple ci-dessus.

Plein de nouvelles notions ici, n'est-ce pas ? Vous progressez vraiment vite !

En résumé 

Dans ce chapitre, vous avez appris les points suivants :

• Les fonctions peuvent avoir des paramètres et des valeurs de retour.

• Une valeur de retour est le résultat de l'exécution de la fonction. Elle peut être renvoyée au bloc de code qui a appelé la fonction, et être utilisée si besoin est.

• Les paramètres sont les entrées d'une fonction nécessaires à l'exécution et à l'obtention d'un résultat.

• Les paramètres sont des variables définies par leur nom et par leur type. Ces paramètres sont spécifiés dans la déclaration de la fonction.

• Lorsque vous appelez une fonction, vous passez des valeurs à ces variables. Ces valeurs sont alors appelées arguments.