C#: Les méthodes

Définitions

• Dans la résolution d’un problème, on peut constater qu’une suite d’actions revient plusieurs fois. Dans ce cas il serait judicieux de l’écrire une seule fois, et de l’utiliser autant de fois que c’est nécessaire, en effectuant des calculs avec des données différentes.
• Cette suite d’actions sera définie dans un sous programme, qui peut prendre soit la forme d’une procédure, soit la forme d’une méthode. D’autre part, on peut observer que certains groupes d’actions se rapportent à des traitements précis et différents.
• Il est souhaitable alors de représenter chacun d’eux dans un sous programme. On perçoit alors un programme comme un ensemble de procédures/méthodes.
• La structuration d’un programme par morceaux (modules) est la base de la programmation structurée et modulaire.
• A titre d’exemple, un programme de gestion de la formation peut être découpé en plusieurs modules :demande de formation, inscription, suivi des absences, examens, diplômes, etc.
• Une méthode est un groupe d’instructions,une suite d’instructions regroupées sous un nom ; elle prend en entrée des paramètres et retourne un résultat.
• Une méthode peut ne prendre aucun paramètre en entrée ou ne retourner aucun résultat.
• Une méthode nous permet de ne pas avoir à réécrire beaucoup de lignes de code à chaque fois qu’on veut faire une certaine opération.
• Chaque programme C # a au moins une classe avec une méthode nommée Main.
• Un programme amène les instructions à exécuter en appelant la méthode et la spécification des arguments de méthode requise.
• La méthode principale est le point pour chaque application C # d’entrée et il est appelé par le Common Language Runtime (CLR) lorsque le programme est lancé.
• Pour utiliser une méthode, vous devez:
• Définir la méthode
• Appelez la méthode

Autres définitions

• Une méthode est un groupe d’instructions C# qui ont été rassemblées et auxquelles un nom a été
  attribué.
• La plupart des langages de programmation modernes partagent un concept similaire ; vous pouvez vous représenter une méthode comme une fonction, une sous-routine, une procédure ou un sous-programme.

Syntaxe d’une méthode en c#

(Liste des paramètres)
{
// corps de la méthode
}

• Ceci détermine la visibilité d’une variable ou une méthode d’une autre classe.
• Il définit le mode d’accès (public, privé ou protégé), le type de méthode (statique ou d’instance).

• Une méthode peut renvoyer une valeur .
• Le type de retour est le type de la valeur des données renvoyé par la méthode.
• Si la méthode ne retourne aucune valeur, alors le type de retour est nulle.

• le Nom de la méthode est un identifiant unique et il est sensible à la casse .
• Il ne peut pas être le même que tout autre identificateur déclaré dans la classe .
• Vous ne pouvez pas attribuer à une méthode un nom identique à celui d’une variable, d’une constante
  ou de tout élément qui n’est pas une méthode déclarée dans la classe.
• Une méthode correspond à une action, donc un verbe lui correspond bien.
• Prenez donc l’habitude de choisir des verbes anglais pour vos méthodes.
• Par exemple, une méthode qui trie un tableau peut être nommée SortArray étant donné que « to sort » veut dire « trier », et qu’un array est un tableau.

• Liste des paramètres : Clôturé entre parenthèses , les paramètres sont utilisés pour transmettre et recevoir des données à partir d’une méthode.
• La liste des paramètres fait référence au type , l’ordre et le nombre des paramètres d’une méthode.
• Les paramètres sont facultatifs ; autrement dit, un procédé peut contenir aucun paramètre.
• Cette liste figure entre parenthèses. Ces parenthèses doivent être utilisées même si la liste ne contient aucun paramètre.

L’exemple suivant montre comment créer une méthode appelée ExampleMethod dans la classe ExampleClass :

using System;
class ExampleClass
{
static void ExampleMethod( )
{
Console.WriteLine("Méthode ExampleMethod");
}
static void Main( )
{
Console.WriteLine("Méthode Main");
}
}

• Un paramètre est au sens large un élément d’information à prendre en compte pour prendre une décision ou pour effectuer un calcul. On parle aussi d’argument.
• En informatique, un paramètre est une donnée manipulée par une section de code et connue du code appelant cette section.

• Les paramètres d’une méthode sont déclarés

1. Les paramètres de valeur, qui sont déclarés sans modificateur.(Valeur)
2. Les paramètres de sortie, qui sont déclarés à l’aide du modificateur out.(Out)
3. Les paramètres de référence, qui sont déclarés à l’aide du modificateur ref.(Ref)
4. Les tableaux de paramètres, qui sont déclarés à l’aide du modificateur params.(Params)



1. Valeur
• Le type Valeur est le type de paramètre par défaut dans C #.
• Si le paramètre n’a pas de modificateur , il est (type valeur) le paramètre par défaut.
• Lorsque nous utilisons le type valeur comme paramètre, la valeur réelle est transmise à la fonction, ce qui signifie les modifications apportées au paramètre est locale à la fonction et ne sont pas répercutés sur la partie appelant.
• A titre d’exemple, un programme de gestion de formation peut être découpé en plusieurs modules : demandeurs de formations,inscription, suivi des absences, examens, diplômes, etc.


Out

• Déclarer une méthode out est utile lorsque vous voulez qu’une méthode renvoie plusieurs valeurs.
• Habituellement , une méthode renvoie la valeur avec le retour mot clé. Malheureusement , un modificateur de retour ne peut renvoyer qu’une seule valeur à la fois .
• Parfois , votre programme C # doit retourner plusieurs valeurs à partir d’une seule méthode. Dans cette situation, vous avez besoin d’ un tel type de fonction qui peut produire des résultats de sortie multiples à partir d’une seule fonction.
• Le paramètre de sortie C # permet à votre programme pour renvoyer des valeurs multiples.
• Paramètres « out » ne sont émis que des paramètres qui signifie qu’ils ne peuvent passer en arrière une valeur d’une fonction.
• Nous créons un paramètre « out » en faisant précéder le type de données de paramètre avec le modificateur out.
• Quand jamais un paramètre « out » est passé seulement une référence non affectée est passée à la fonction.
• Un paramètre déclaré avec un modificateur out est un paramètre de sortie. À l’instar d’un paramètre de référence, un paramètre de sortie ne crée pas de nouvel emplacement de stockage. Il représente plutôt le même emplacement de stockage en tant que variable fournie comme argument dans l’appel de méthode.
• Lorsqu’un paramètre formel est un paramètre de sortie, l’argument correspondant dans un appel de méthode doit être le mot clé out suivi d’un variable-reference du même type que le paramètre formel. Une variable doit être absolument assignée avant d’être passée en tant que paramètre de sortie, mais après un appel dans lequel une variable a été passée en tant que paramètre de sortie, la variable est considérée comme étant absolument assignée.

Exemples de programmation de paramètre out C #

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace methode_out_parametre
{
    class Program
    {
        //Accepter deux paramètres d'entrée et renvoie deux sur la valeur
       public static void rect(int longueur, int largeur, out int surface, out int perimetre)
            {
            surface = longueur * largeur;
                perimetre = 2 * (longueur + largeur);
            }
            static void Main(string[] args)
        {
            int surface, perimetre;
            // passing two parameter and getting two returning value
            Program.rect(5, 4, out surface, out perimetre);
            Console.WriteLine("La surface de Rectangle est {0}\t", surface);
            Console.WriteLine("Le Perimètre de Rectangle est {0}\t", perimetre);
            Console.ReadLine();
        }
    }
}

Exercice d’application

Exercice_apcpedagogie015
Écrire un programme dans lequel accepte deux arguments en tant que paramètre de l’utilisateur et renvoie quatre valeur de sortie addition, soustraction , multiplication et division .
Solution




2. Ref
• Un paramètre par référence fait référence à un emplacement dans la mémoire. Contrairement à un paramètre par valeur, un paramètre par référence ne crée pas de nouveaux emplacements de stockage. Au lieu de cela, il représente le même emplacement dans la mémoire que la variable qui est fournie dans l’appel de la méthode.
• Un paramètre de référence est une référence à un emplacement de mémoire d’une variable. Lorsque vous passez des paramètres par référence , à la différence des paramètres de valeur , un nouvel emplacement de stockage est pas créé pour ces paramètres .
• Vous pouvez déclarer les paramètres de référence en utilisant le mot-clé ref .
  

  L’exemple suivant illustre ceci:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace application_calcul_methode_ref
{
    class manipulateur_nombre
    {
        public void echange(ref int x, ref int y)
        {
            int temp;

            temp = x; /* Enregistrer la valeur x x */
            x = y;    /* Maettre y dans x */
            y = temp; /* Mettre temp dans y*/
        }
        static void Main(string[] args)
        {
            manipulateur_nombre n = new manipulateur_nombre();

            /* Définition des variables locales */
            int a = 100;
            int b = 200;

            Console.WriteLine("Avant échange, valeur de a : {0}", a);
            Console.WriteLine("Avant échange, valeur de b : {0}", b);

            /* Appeler la méthode pour changer la valeur */
            n.echange(ref a, ref b);

            Console.WriteLine("Aprés échange, valeur de a : {0}", a);
            Console.WriteLine("Aprés échange, valeur de b : {0}", b);

            Console.ReadLine();
        }
    }
}

• Les paramètres de référence représentent le même emplacement de mémoire que les paramètres réels qui sont fournis au procédé .
• Le mot clé ref entraîne le passage d’un argument par référence, et non par valeur.
• La conséquence est que toute modification apportée au paramètre dans la méthode appelée est répercutée dans la méthode d’appel.

Exemple:

• Par exemple, si l’appelant passe une expression de variable locale ou d’une expression d’accès à un élément de tableau et que la méthode appelée remplace l’objet auquel fait référence le paramètre ref, la variable locale de l’appelant ou l’élément de tableau font désormais référence au nouvel objet.
• Pour utiliser un paramètre ref, la définition de la méthode et la méthode d’appel doivent utiliser explicitement le mot clé ref, comme indiqué dans l’exemple suivant.

class RefExample
{
    static void Method(ref int i)
    {
        // Placez le pointeur de la souris sur i pour vérifier qu'il est un int.
        // La déclaration suivante provoquerait une erreur de compilation si i
        //a été en boîte comme un objet.
        i = i + 44;
    }

    static void Main()
    {
        int val = 1;
        Method(ref val);
        Console.WriteLine(val);

        // Résultat: 45
    }
}

• Si vous modifiez la valeur d’un paramètre par référence, la variable fournie par l’appelant est également modifiée, car elles font toutes deux référence au même emplacement dans la mémoire.

Exemple

• L’exemple suivant montre comment la modification du paramètre par référence entraîne également
  celle de la variable :

static void Ajouter_un(ref int x)
{
x++;
}
static void Main( )
{
int k = 6;
Ajouter_un(ref k);
Console.WriteLine(k); // Affiche la valeur 7
}




3. Params
• Un tableau peut également être transmis à la méthode comme argument ou d’un paramètre .Un processus de la méthode de sortie du réseau et retourner .
• Un paramètre déclaré avec un modificateur params est un tableau de paramètres. Si une liste de paramètres formels comprend un tableau de paramètres, celui-ci doit être le dernier paramètre dans la liste et correspondre à un type tableau à une seule dimension.
• L’argument fourni pour un tableau de paramètres peut être une expression unique d’un type qui est convertible implicitement en un type tableau de paramètres. Dans ce cas, le tableau de paramètres opère précisément comme un paramètre de valeur.
• Dans l’autre cas, l’appel peut spécifier zéro argument ou plus pour le tableau de paramètres, où chaque argument est une expression d’un type implicitement convertible en type des éléments du tableau de paramètres. L’appel crée alors une instance du type du tableau de paramètres d’une longueur correspondant au nombre d’arguments, initialise les éléments de l’instance du tableau avec les valeurs d’argument fournies et utilise la nouvelle instance de tableau comme argument réel.
• La démonstration suivante vous aidera à comprendre comment passer un tableau comme argument en programmation C # .

exemple:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace array_parameter
{
    class Program
    {
        static void printarray(int[] newarray)
        {
            int i, sum = 0;
            Console.Write("\n\nVous avez entré:\t");
            for (i = 0; i < 4; i++)
            {
                Console.Write("{0}\t", newarray[i]);
                sum = sum + newarray[i];
            }
            Console.Write("\n\nLa somme de tous les valeurs est:\t{0}", sum);
            Console.ReadLine();
        }
        static void Main(string[] args)
        {
            int[] arr = new int[4];
            int i;
            for (i = 0; i < 4; i++)
            {
                Console.Write("Entrez un nombre:\t");
                arr[i] = Convert.ToInt32(Console.ReadLine());
            }
            // passer un tableau comme argument
            Program.printarray(arr);
        }
    }
}

• Lorsqu’une méthode est définie, vous pouvez l’appeler à partir de la classe dans laquelle elle a étédéfinie et à partir d’autres classes.
• Pour appeler une méthode, utilisez le nom de la méthode suivi de la liste des paramètres entre parenthèses.
• Les parenthèses sont requises même si la méthode que vous appelez ne contient aucun paramètre, comme le montre l’exemple suivant.

nomDeLaMéthode(paramètresSéparésParUneVirgule);

Exemple:

using System;
namespace CalculatorApplication
{
   class NumberManipulator
   {
      public int FindMax(int num1, int num2)
      {
         /* local variable declaration */
         int result;
         
         if (num1 > num2)
            result = num1;
         else
            result = num2;
         return result;
      }
      static void Main(string[] args)
      {
         /* local variable definition */
         int a = 100;
         int b = 200;
         int ret;
         NumberManipulator n = new NumberManipulator();

         //calling the FindMax method
         ret = n.FindMax(a, b);
         Console.WriteLine("Max value is : {0}", ret );
         Console.ReadLine();
      }
   }
}

Retenir

Vous pouvez également appeler une méthode déclarée public auprès d’autres classes en utilisant l’ instance de la classe . Par exemple , la méthode TrouverMax appartient à la classe de NombreManipulateur , vous pouvez l’appeler d’un autre test de classe .

Autre Exemple:

using System;
namespace CalculatorApplication
{
   class NombreManipulateur
   {
      public int TrouverMaximum(int num1, int num2)
      {
         /* local variable declaration */
         int result;
         
         if(num1 > num2)
            result = num1;
         else
            result = num2;
         
         return result;
      }
   }
   
   class Test
   {
      static void Main(string[] args)
      {
         /* local variable definition */
         int a = 100;
         int b = 200;
         int ret;
         NombreManipulateur n = new NombreManipulateur();
         
         //calling the FindMax method
         ret = n.TrouverMaximum(a, b);
         Console.WriteLine("Max value is : {0}", ret );
         Console.ReadLine();
      }
   }
}

• Une méthode peut être surchargée (overload en anglais), c’est à dire qu’il peut exister au sein de la même classe plusieurs méthodes portant le même nom, à condition qu’elles soient différentiables par leur signature.
• La surcharge des méthodes permet à une classe, un struct ou une interface de déclarer plusieurs méthodes avec le même nom, sous réserve que leurs signatures soient uniques dans cette classe, ce struct ou cette interface.
• La signature d’une méthode correspond aux types et nombre de paramètres acceptés par celle-ci.
• La signature d’une méthode se compose du nom de la méthode ainsi que du type et du genre (valeur, référence ou sortie) de chacun de ses paramètres formels, considérés de gauche à droite.
• La signature d’une méthode ne contient pas spécifiquement le type de retour ni le modificateur params qui peut être spécifié pour le paramètre le plus à droite.

Exemple:

public int Ajouter ( int valeur1, int valeur2 )
{
 return valeur1 + valeur2;
}
public double Ajouter ( double valeur1, double valeur2 )
{
 return valeur1 + valeur2;
}

• Le type de retour ne fait pas partie de la signature, car la valeur retournée par une méthode appelée peut être ignorée. Si deux méthodes portent le même nom et ont la même signature, le compilateur génère une erreur.

Exemple :
Les deux méthodes ont la même signature

public double Longueur ( string chaine )
{
 return (double) chaine.Length;
}
public int Longueur ( string chaine )
{
 return (int) chaine.Length;
}

• Une méthode peut appeler une autre méthodes, mais il peut aussi appeler lui-même. Quand un mathod appelle lui-même, il sera nommé méthode récursive.
• La récursivité est une importante technique de programmation qui permet à une fonction de s’appeler elle-même.
• Le calcul de factorielles constitue un exemple de récurrence. La factorielle de 0 est définie spécifiquement pour avoir la valeur 1. La factorielle de n, un entier supérieur à 0, est le produit de tous les entiers dans la plage de 1 à n.

Exemple;
En mathématique, la valeur factorielle d’un nombre positif n est représenté par cette formule :
n!= n . (n-1) . (n-2) . (n-3) … 1

C’est-à-dire que le factoriel de notre nombre n est le produit de ce nombre, n, avec tous les nombres qui lui sont plus petit, jusqu’à 1. Donc, 5! c’est en fait 5x4x3x2x1

La solution simple avec le nombre 5

public Factoriel(intNombre)
{
	dynamic intCount = null;
	dynamic intFactoriel = null;

	intFactoriel = 1;
	for (intCount = intNombre; intCount >= 1; intCount += -1) {
		intFactoriel = intFactoriel * intCount;
	}

	return intFactoriel;
}

Solution récursive

public  FactorielRecursif(intNombre)
{
	object functionReturnValue = null;
	if (intNombre <= 1) {
		functionReturnValue = 1;
	} else {
		functionReturnValue = intNombre * FactorielRecursif(intNombre - 1);
	}
	return functionReturnValue;
}

Explication de la forme récursive :

SI le nombre « intNombre » est plus petit ou égal à 1, alors la fonction retournera 1 SINON la valeur retournée sera le produit du nombre « intNombre » avec la valeur retournée par la fonction pour le nombre « intNombre -1 ».

Résultat: 5! = 5 . (5-1) . (5-2) . (5-3) . (5-4)

Simplifié: 5! = 5 . 4 . 3 . 2. 1 = 120

Autres exemples

       // Fonction de factoriel récursive
        public static double factorielRecursif(int n)
        {
            if (n > 1) return n * factorielRecursif(n - 1);
            else return 1;
        }
         // Fonction de factoriel récursive méthode 2
        public static double factorielRecursif1(int n)
        {
            if (1 < n) return n * factorielRecursif1(n - 1);
            else return 1;
        }
 

Fonction de factoriel par une boucle While

         // Fonction de factoriel par une boucle While et une décrémentation
        public static double factoBoucleWhile(double n)
        {
            double res = 1;
            while (n > 1) res *= n--;
            return res;
        }
        // Fonction de factoriel par une boucle While et une incrémentation
        public static double factoBoucleWhile2(double n)
        {
            double res = 1;
            double i = 1;
            while (i < n) res *= i++;
            return res;
        }
    

Fonction de factoriel par une boucle For

// Fonction de factoriel par une boucle For et une décrémentation
        public static double factoBoucleFor(double n)
        {
            double resultat = 1;
            for (double i = n; i > 1; i--)resultat *= i;
            return resultat;
        }
 
        // Fonction de factoriel par boucle For et une incrémentation
        public static double factoBoucleFor2(double n)
        {
            double resultat = 1;
            for (double i = 1; i < n; i++) resultat *= i;
            return resultat;
        }