C# Méthodes

Une méthode est un bloc de code qui regroupe un ensemble d'instructions liées pour accomplir une tâche spécifique. C'est l'implémentation en C# dela réutilisation du codeet del'encapsulation de la logiqueLe mécanisme central. Chaque programme C# a au moins uneMainUne méthode sert de point d'entrée du programme.

L'utilisation d'une méthode nécessite deux étapes :Définir la méthodeetAppeler la méthode。

1. Définition des méthodes

La syntaxe de base pour définir une méthode en C# est la suivante :

<access modifier> <return type> <method name>(<parameter list>)
{
    method body
}

Une méthode est composée des éléments suivants :

  • Modificateurs d'accès(Access Modifier) : contrôle la visibilité de la méthode, commepublic、private、protected、internal。
  • Type de retour(Type de retour) : le type de données de la valeur de retour de la méthode. Si la méthode ne renvoie aucune valeur, utilisezvoid。
  • nom de méthode(Nom de méthode) : l'identifiant unique de la méthode, suivant les conventions de nommage PascalCase (par ex.FindMax、GetUserName）。
  • Liste de paramètres(Liste de paramètres) : les entrées que la méthode reçoit, entre parenthèses. Les paramètres sont facultatifs ; une méthode peut ne pas avoir de paramètres.
  • corps de la méthode(Corps de la méthode) : contient le code qui implémente la fonctionnalité, entre accolades{}Entourez.

La figure suivante montre la structure complète d'une méthode :

C# method structure parsing public int FindMax ( int num1, int num2 ) Access modifiers public / private Control visibility Return Type int / void Return value data type method name PascalCase Unique identifier Parameter list Type + name Separate multiple with commas { Method body — code that implements functionality } Method Body Full method signature: public int FindMax(int a, int b) Modifier → Return type → Method name → Parameter list

1.1 Premier exemple de méthode

Ce qui suit définit unFindMaxUne méthode qui prend deux entiers et renvoie le plus grand :

Exemple

using System;

namespace MethodDemo
{
    class NumberHelper
    {
        // Définit une méthode qui prend deux entiers et renvoie le plus grand
        public int FindMax(int num1, int num2)
        {
            if (num1 > num2)
                return num1;
            else
                return num2;
        }

        static void Main(string[] args)
        {
            // Créer un objet et appeler la méthode
            NumberHelper helper = new NumberHelper();
            int result = helper.FindMax(100, 200);

            Console.WriteLine($"La valeur maximale est : {result}");  // La valeur maximale est : 200
        }
    }
}

Le processus d'invocation de méthode :

Method call flow caller FindMax(100, 200) Actual argument Method receives num1=100, num2=200 Execute method body Compare and return result return Return Value result = 200 1. Call the method, pass the actual arguments → 2. Formal parameters receive the values → 3. Execute the method body → 4. Return the result to the caller

Appel inter-classes :Tant que la méthode est déclarée commepublic, elle peut être appelée depuis d'autres classes en créant une instance. C'est le fondement de la réutilisation du code dans la programmation orientée objet.

2. Méthodes de passage des paramètres

C# propose trois façons de passer des paramètres aux méthodes. Leur différence essentielle réside dansle partage ou non de la mémoire：

Comparison of Three Parameter Passing Methods Pass by value (default) caller a = 100 Copy within the method x = 100 Mutually independent memory spaces Modifying x does not affect a a and b remain unchanged after swap(a, b) No extra keyword required void Swap(int x, int y) Pass by reference (ref) caller a = 200 Same address within the method ref x = 200 Share the same memory block Modifying x will change a After swap(ref a, ref b), the swap is successful Requires the ref keyword void Swap(ref int x, ref int y) Output parameter (out) caller a = 5 ← Output within the method out x = 5 The method must assign a value to the out parameter. No need to initialize before calling Can return multiple values Requires the out keyword void Calc(out int x, out int y)
Méthode Mots-clés Comportement Scénarios typiques
Passage par valeur (aucun) Copie la valeur du paramètre ; les modifications à l'intérieur de la méthode n'affectent pas la variable d'origine. La plupart des appels de méthode (par défaut)
Passage par référence ref Passage d'une référence à la variable ; les modifications à l'intérieur de la méthode modifieront la variable d'origine. Besoin de modifier des variables externes (par exemple, échanger des valeurs)
Paramètre de sortie out Semblable à ref, mais la méthode doit affecter une valeur, et la variable n'a pas besoin d'être initialisée avant l'appel. La méthode doit retourner plusieurs valeurs

2.1 Passage par valeur (par défaut)

Le passage par valeur est le mode par défaut. La valeur de l'argument seracopiéeet transmise au paramètre ; les modifications apportées au paramètre à l'intérieur de la méthode n'affecteront pas la variable d'origine :

Exemple

using System;

namespace ParameterDemo
{
    class Program
    {
        // Passage par valeur : x et y sont des copies de a et b
        public void Swap(int x, int y)
        {
            int temp = x;
            x = y;
            y = temp;
            Console.WriteLine($" Dans la méthode : x={x}, y={y}");  // Échange réussi
        }

        static void Main(string[] args)
        {
            var p = new Program();
            int a = 100, b = 200;

            Console.WriteLine($Avant l'appel : a={a}, b={b});
            p.Swap(a, b);
            Console.WriteLine($Après l'appel : a={a}, b={b});  // a, b n'ont pas changé !
        }
    }
}
调用前：a=100, b=200
  方法内：x=200, y=100
调用后：a=100, b=200

2.2 Passage par référence (ref)

UtilisationrefLe mot clé transmet laréférence(adresse mémoire) de la variable ; les modifications apportées au paramètre à l'intérieur de la méthode affecteront directement la variable d'origine. Notez que le mot clé doit également être ajouté lors de l'appel.ref：

Exemple

using System;

namespace ParameterDemo
{
    class Program
    {
        // Passage par référence : x et y référencent directement la mémoire de a、b
        public void Swap(ref int x, ref int y)
        {
            int temp = x;
            x = y;
            y = temp;
        }

        static void Main(string[] args)
        {
            var p = new Program();
            int a = 100, b = 200;

            Console.WriteLine($Avant l'appel : a={a}, b={b});
            p.Swap(ref a, ref b);  // Lors de l'appel, il faut aussi ajouter ref
            Console.WriteLine($Après l'appel : a={a}, b={b});  // Échange réussi !
        }
    }
}
调用前：a=100, b=200
调用后：a=200, b=100

La différence entre ref et out :refNécessite que la variable soit passée au préalableDoit être déjà initialisée；outEnsuite, ce n'est pas obligatoire, mais à l'intérieur de la méthodeLe paramètre out doit recevoir une valeuravant de pouvoir être utilisé.

2.3 Paramètres de sortie (out)

outLes paramètres permettent à la méthode deretourner plusieurs valeurs. EtrefLa différence est que la variable n'a pas besoin d'être initialisée avant l'appel, mais la méthode doit lui affecter une valeur :

Exemple

using System;

namespace ParameterDemo
{
    class Program
    {
        // paramètre out : la méthode est responsable de l'affectation
        public void GetValues(out int x, out int y)
        {
            Console.Write("Veuillez saisir la première valeur :");
            x = Convert.ToInt32(Console.ReadLine());

            Console.Write("Veuillez saisir la deuxième valeur :");
            y = Convert.ToInt32(Console.ReadLine());
            // Remarque : tous les paramètres out doivent être affectés avant la fin de la méthode, sinon une erreur de compilation se produit.
        }

        // Exemple pratique : modèle TryParse
        public bool TryDivide(int a, int b, out double result)
        {
            if (b == 0)
            {
                result = 0;
                return false;  // Division par zéro
            }
            result = (double)a / b;
            return true;
        }

        static void Main(string[] args)
        {
            var p = new Program();

            // les paramètres out n'ont pas besoin d'initialisation
            int a, b;
            p.GetValues(out a, out b);
            Console.WriteLine($"a={a}, b={b}");

            // modèle TryParse
            if (p.TryDivide(10, 3, out double res))
                Console.WriteLine($"10 / 3 = {res:F2}");  // 3.33
        }
    }
}

Depuis C# 7.0, vous pouvez, lors de l'appel,déclaration inlineles variables out rendent le code plus concis :

// C# 7.0+ 内联声明
if (int.TryParse("123", out int number))
    Console.WriteLine($"解析成功：{number}");

3. Méthodes récursives

La récursion fait référence à une méthodequi s'appelle elle-mêmeChaque méthode récursive nécessite deux éléments :

  • Condition de base(cas de base) : La condition qui arrête la récursion, empêchant une récursion infinie.
  • Étape récursive(étape récursive) : Décompose le problème en sous-problèmes plus petits.

Exemple classique — calcul de la factorielle $$n! = n \times (n-1)!$$ :

Exemple

using System;

namespace RecursionDemo
{
    class Program
    {
        // Calcule récursivement la factorielle
        public int Factorial(int n)
        {
            // Condition de base : 0! = 1, 1! = 1
            if (n <= 1)
                return 1;

            // Étape récursive : n! = n × (n-1)!
            return n * Factorial(n - 1);
        }

        static void Main(string[] args)
        {
            var p = new Program();
            Console.WriteLine($"6! = {p.Factorial(6)}");   // 720
            Console.WriteLine($"7! = {p.Factorial(7)}");   // 5040
            Console.WriteLine($"8! = {p.Factorial(8)}");   // 40320
        }
    }
}
6! = 720
7! = 5040
8! = 40320

Le processus d'expansion des appels récursifs :

Factorial(4)
  = 4 × Factorial(3)
  = 4 × 3 × Factorial(2)
  = 4 × 3 × 2 × Factorial(1)
  = 4 × 3 × 2 × 1
  = 24

Remarque :Lorsque la profondeur de récursion est trop grande, cela peut entraînerStackOverflowExceptionPour les scénarios sensibles aux performances, envisagez plutôt d'utiliser une boucle.

4. Plus de fonctionnalités des méthodes

4.1 Paramètres par défaut et paramètres nommés

C# permet de définir des paramètres avecune valeur par défautvous pouvez omettre ces paramètres lors de l'appel. En combinaison avecdes paramètres nommésvous pouvez également ignorer certains paramètres et ne spécifier que ceux qui suivent :

Exemple

using System;

namespace MethodFeatures
{
    class Program
    {
        // Paramètre par défaut : power vaut 2 par défaut
        static double Power(double baseNum, int puissance = 2)
        {
            double result = 1;
            for (int i = 0; i < power; i++)
                result *= baseNum;
            return result;
        }

        // Plusieurs paramètres par défaut
        static void PrintInfo(string name, int age = 18, string city = "Inconnu")
        {
            Console.WriteLine($"{name}, {age} ans, {city}");
        }

        static void Main(string[] args)
        {
            // Utilisation des paramètres par défaut
            Console.WriteLine(Power(3));       // 9.0 (avec power=2 par défaut)
            Console.WriteLine(Power(3, 3));    // 27.0

            // Arguments nommés : omettre age, ne spécifier que city
            PrintInfo(Xiaoming, city: "Pékin");
            // Sortie : Xiaoming, 18 ans, Pékin

            // Les arguments nommés peuvent être dans n'importe quel ordre
            PrintInfo(city: "Shanghai", name: Xiaohong, age: 25);
            // Sortie : Xiaohong, 25 ans, Shanghai
        }
    }
}

4.2 Méthodes à corps d'expression

Lorsque le corps de la méthode ne contient qu'une seule instruction, vous pouvez utiliser=>Syntaxe simplifiée (C# 6.0+) :

// 传统写法
public int Add(int a, int b)
{
    return a + b;
}

// 表达式体写法（等价）
public int Add(int a, int b) => a + b;

4.3 Surcharge de méthodes (Overloading)

Dans la même classe, il peut y avoirplusieurs méthodes portant le même nomtant que les listes de paramètres sont différentes (types, nombres ou ordre des paramètres différents) :

Exemple

using System;

namespace MethodFeatures
{
    class Calculator
    {
        // Surcharge 1 : Addition de deux int
        public int Add(int a, int b) => a + b;

        // Surcharge 2 : Addition de trois int
        public int Add(int a, int b, int c) => a + b + c;

        // Surcharge 3 : Addition de deux double
        public double Add(double a, double b) => a + b;

        static void Main(string[] args)
        {
            var calc = new Calculator();
            Console.WriteLine(calc.Add(1, 2));         // 3 (appel de la surcharge 1)
            Console.WriteLine(calc.Add(1, 2, 3));      // 6 (appel de la surcharge 2)
            Console.WriteLine(calc.Add(1.5, 2.5));     // 4.0 (appel de la surcharge 3)
        }
    }
}

Résumé

Fonctionnalités Syntaxe Description
Définir une méthode int Add(int a, int b) { ... } Spécifier le type de retour, le nom de la méthode et les paramètres
Aucune valeur de retour void DoSomething() { ... } voidIndique qu'aucune valeur n'est renvoyée
Passage par valeur void Foo(int x) Méthode par défaut ; les modifications apportées aux paramètres n'affectent pas les arguments
Passage par référence void Foo(ref int x) Mémoire partagée ; les modifications sont répercutées dans les arguments
Paramètre de sortie void Foo(out int x) Doit être assigné à l'intérieur de la méthode ; peut renvoyer plusieurs valeurs
Paramètre par défaut void Foo(int x = 10) Peut être omis lors de l'appel ; utilise les valeurs par défaut
Paramètres nommés Foo(city: "北京") Spécifier les paramètres par nom, l'ordre peut être modifié
Corps d'expression int Add(int a, int b) => a + b; Raccourci pour les méthodes d'une seule ligne (C# 6.0+)
Surcharge de méthode Même nom, paramètres différents Le compilateur sélectionne automatiquement en fonction de la liste des paramètres
autres extensions