Méthodes C#
Une méthode consiste à organiser certaines instructions liées ensemble dans un bloc d'instructions pour effectuer une tâche. Chaque programme C# possède au moins une classe avec une méthode Main.
Pour utiliser une méthode, vous devez :
Définir la méthode
Appeler la méthode
Définir des méthodes en C#
Lorsque vous définissez une méthode, vous déclarez essentiellement les éléments de sa structure. En C#, la syntaxe pour définir une méthode est la suivante :
<Access Specifier> <Return Type> <Method Name>(Parameter List)
{
Method Body
}Voici les différents éléments de la méthode :
Access Specifier : modificateur d'accès, ceci détermine la visibilité d'une variable ou d'une méthode sur une autre classe.
Type de retour : Type de retour, une méthode peut renvoyer une valeur. Le type de retour est le type de données de la valeur renvoyée par la méthode. Si la méthode ne renvoie aucune valeur, le type de retour est void.
Nom de la méthode : Le nom de la méthode est un identifiant unique et est sensible à la casse. Il ne peut pas être identique aux autres identifiants déclarés dans la classe.
Liste des paramètres : Liste des paramètres, entre parenthèses, ce paramètre est utilisé pour transmettre et recevoir des données de méthode. La liste des paramètres fait référence au type, à l'ordre et au numéro des paramètres de la méthode. Les paramètres sont facultatifs, c'est-à-dire qu'une méthode ne peut contenir aucun paramètre.
Corps de la méthode : Corps de la méthode, contenant l'ensemble des instructions nécessaires pour terminer la tâche.
Exemple
L'extrait de code ci-dessous montre une fonction FindMax qui accepte deux valeurs entières et renvoie la plus grande des deux. Il a un modificateur d'accès public, il est donc accessible depuis l'extérieur de la classe à l'aide d'une instance de la classe.
class NumberManipulator
{
public int FindMax(int num1, int num2)
{
/* 局部变量声明 */
int result;
if (num1 > num2)
result = num1;
else
result = num2;
return result;
}
...
}Appel de méthodes en C#
Vous pouvez appeler une méthode en utilisant son nom. L'exemple suivant le démontre :
using System;
namespace CalculatorApplication
{
class NumberManipulator
{
public int FindMax(int num1, int num2)
{
/* 局部变量声明 */
int result;
if (num1 > num2)
result = num1;
else
result = num2;
return result;
}
static void Main(string[] args)
{
/* 局部变量定义 */
int a = 100;
int b = 200;
int ret;
NumberManipulator n = new NumberManipulator();
//调用 FindMax 方法
ret = n.FindMax(a, b);
Console.WriteLine("最大值是： {0}", ret );
Console.ReadLine();
}
}
}Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :
最大值是： 200
Vous pouvez également utiliser une instance d'une classe d'une autre classe Appeler des méthodes publiques des autres classes. Par exemple, la méthode FindMax appartient à la classe NumberManipulator et vous pouvez l'appeler depuis une autre classe Test.
using System;
namespace CalculatorApplication
{
class NumberManipulator
{
public int FindMax(int num1, int num2)
{
/* 局部变量声明 */
int result;
if (num1 > num2)
result = num1;
else
result = num2;
return result;
}
}
class Test
{
static void Main(string[] args)
{
/* 局部变量定义 */
int a = 100;
int b = 200;
int ret;
NumberManipulator n = new NumberManipulator();
//调用 FindMax 方法
ret = n.FindMax(a, b);
Console.WriteLine("最大值是： {0}", ret );
Console.ReadLine();
}
}
}Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :
最大值是： 200
Appel de méthode récursive
Une méthode peut s'appeler elle-même. C'est ce qu'on appelle la récursion. L'exemple suivant utilise une fonction récursive pour calculer la factorielle d'un nombre :
using System;
namespace CalculatorApplication
{
class NumberManipulator
{
public int factorial(int num)
{
/* 局部变量定义 */
int result;
if (num == 1)
{
return 1;
}
else
{
result = factorial(num - 1) * num;
return result;
}
}
static void Main(string[] args)
{
NumberManipulator n = new NumberManipulator();
//调用 factorial 方法
Console.WriteLine("6 的阶乘是： {0}", n.factorial(6));
Console.WriteLine("7 的阶乘是： {0}", n.factorial(7));
Console.WriteLine("8 的阶乘是： {0}", n.factorial(8));
Console.ReadLine();
}
}
}Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :
6 的阶乘是： 720 7 的阶乘是： 5040 8 的阶乘是： 40320
Passer des paramètres
Lorsque vous appelez une méthode avec des paramètres, vous devez transmettre les paramètres à la méthode. En C#, il existe trois manières de transmettre des paramètres aux méthodes :
| 方式 | 描述 |
|---|---|
| 值参数 | 这种方式复制参数的实际值给函数的形式参数，实参和形参使用的是两个不同内存中的值。在这种情况下，当形参的值发生改变时，不会影响实参的值，从而保证了实参数据的安全。 |
| 引用参数 | 这种方式复制参数的内存位置的引用给形式参数。这意味着，当形参的值发生改变时，同时也改变实参的值。 |
| 输出参数 | 这种方式可以返回多个值。 |
Transmettre les paramètres par valeur
C'est la manière par défaut de transmettre les paramètres. De cette façon, lorsqu'une méthode est appelée, un nouvel emplacement de stockage est créé pour chaque paramètre de valeur.
La valeur du paramètre réel sera copiée dans le paramètre formel. Le paramètre réel et le paramètre formel utilisent deux valeurs différentes en mémoire. Par conséquent, lorsque la valeur du paramètre formel change, la valeur du paramètre réel ne sera pas affectée, garantissant ainsi la sécurité des données du paramètre réel. L'exemple suivant illustre ce concept :
using System;
namespace CalculatorApplication
{
class NumberManipulator
{
public void swap(int x, int y)
{
int temp;
temp = x; /* 保存 x 的值 */
x = y; /* 把 y 赋值给 x */
y = temp; /* 把 temp 赋值给 y */
}
static void Main(string[] args)
{
NumberManipulator n = new NumberManipulator();
/* 局部变量定义 */
int a = 100;
int b = 200;
Console.WriteLine("在交换之前，a 的值： {0}", a);
Console.WriteLine("在交换之前，b 的值： {0}", b);
/* 调用函数来交换值 */
n.swap(a, b);
Console.WriteLine("在交换之后，a 的值： {0}", a);
Console.WriteLine("在交换之后，b 的值： {0}", b);
Console.ReadLine();
}
}
}Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :
在交换之前，a 的值：100 在交换之前，b 的值：200 在交换之后，a 的值：100 在交换之后，b 的值：200
Les résultats montrent que même si la valeur est modifiée dans la fonction, la valeur Rien n'a changé.
Passer des paramètres par référence
Un paramètre de référence est une référence à l'emplacement mémoire d'une variable. Lorsque les paramètres sont transmis par référence, contrairement aux paramètres de valeur, cela ne crée pas de nouvel emplacement de stockage pour ces paramètres. Les paramètres de référence représentent le même emplacement mémoire que les paramètres réels fournis à la méthode.
En C#, utilisez le mot-clé ref pour déclarer les paramètres de référence. L'exemple suivant le démontre :
using System;
namespace CalculatorApplication
{
class NumberManipulator
{
public void swap(ref int x, ref int y)
{
int temp;
temp = x; /* 保存 x 的值 */
x = y; /* 把 y 赋值给 x */
y = temp; /* 把 temp 赋值给 y */
}
static void Main(string[] args)
{
NumberManipulator n = new NumberManipulator();
/* 局部变量定义 */
int a = 100;
int b = 200;
Console.WriteLine("在交换之前，a 的值： {0}", a);
Console.WriteLine("在交换之前，b 的值： {0}", b);
/* 调用函数来交换值 */
n.swap(ref a, ref b);
Console.WriteLine("在交换之后，a 的值： {0}", a);
Console.WriteLine("在交换之后，b 的值： {0}", b);
Console.ReadLine();
}
}
}Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :
在交换之前，a 的值：100 在交换之前，b 的值：200 在交换之后，a 的值：200 在交换之后，b 的值：100
Il s'avère que dans la fonction swap la valeur de a changé, et ce changement peut être reflété dans la fonction Main.
Passer les paramètres par sortie
L'instruction return peut être utilisée pour renvoyer uniquement une valeur d'une fonction. Cependant, vous pouvez utiliser le paramètre de sortie pour renvoyer deux valeurs de la fonction. Les paramètres de sortie s'attribuent les données sorties par la méthode et sont par ailleurs similaires aux paramètres de référence.
L'exemple suivant démontre ceci :
using System;
namespace CalculatorApplication
{
class NumberManipulator
{
public void getValue(out int x )
{
int temp = 5;
x = temp;
}
static void Main(string[] args)
{
NumberManipulator n = new NumberManipulator();
/* 局部变量定义 */
int a = 100;
Console.WriteLine("在方法调用之前，a 的值： {0}", a);
/* 调用函数来获取值 */
n.getValue(out a);
Console.WriteLine("在方法调用之后，a 的值： {0}", a);
Console.ReadLine();
}
}
}Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :
在方法调用之前，a 的值： 100 在方法调用之后，a 的值： 5
Variables fournies aux paramètres de sortie Aucune affectation n'est requis. Les paramètres de sortie sont particulièrement utiles lorsque vous devez renvoyer une valeur à partir d'une méthode qui ne spécifie pas de valeur initiale pour le paramètre. Consultez l'exemple suivant pour comprendre cela :
using System;
namespace CalculatorApplication
{
class NumberManipulator
{
public void getValues(out int x, out int y )
{
Console.WriteLine("请输入第一个值： ");
x = Convert.ToInt32(Console.ReadLine());
Console.WriteLine("请输入第二个值： ");
y = Convert.ToInt32(Console.ReadLine());
}
static void Main(string[] args)
{
NumberManipulator n = new NumberManipulator();
/* 局部变量定义 */
int a , b;
/* 调用函数来获取值 */
n.getValues(out a, out b);
Console.WriteLine("在方法调用之后，a 的值： {0}", a);
Console.WriteLine("在方法调用之后，b 的值： {0}", b);
Console.ReadLine();
}
}
}Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants (en fonction de la saisie de l'utilisateur) :
请输入第一个值： 7 请输入第二个值： 8 在方法调用之后，a 的值： 7 在方法调用之后，b 的值： 8
