Méthode C #
Une façon est de mettre certains énoncés pertinents regroupés pour un bloc d'instructions pour effectuer la tâche. Chaque programme a au moins une classe C # avec une méthode principale.
Pour utiliser une méthode, vous devez:
- méthode de définition
- Appelez la méthode
méthode C # tel que défini dans
Lors de la définition d'une méthode, fondamentalement parlant, il est une déclaration des éléments de la structure. C #, la méthode de définition de la syntaxe est la suivante:
<Accès Specifier> <Type de retour> <Nom de la méthode> (Liste des paramètres)
{
Body Method
}
Voici les éléments individuels:
- Accès Spécificateur: modificateur d' accès, les variables de décision ou de la méthode pour une autre visibilité de la classe.
- Type de retour: type de retour, une méthode peut renvoyer une valeur.Le type de retour est le type de la valeur retournée par la méthode de données. Si la méthode ne retourne pas de valeurs, le type de retour estnulle.
- Nom de la méthode:le nom de méthode, est un identifiant unique, et est sensible à la casse. Il ne peut pas être le même que l'autre déclaration de classe d'identifiant.
- Liste des paramètres:la liste des paramètres, entre parenthèses, le paramètre est utilisé pour la transmission de données et la méthode de réception. Liste des paramètres type de paramètre se réfère à la méthode, l'ordre et la quantité. Paramètre est facultatif, à savoir, une méthode ne peut pas contenir des paramètres.
- corps Méthode: corps de la méthode, y compris la nécessité d'effectuer des tâches jeu d'instructions.
Exemples
Le fragment de code suivant montre une fonctionFindMax,qui accepte deux valeurs entières, et renvoie la plus grande des deux valeurs. Il dispose d'un modificateur d'accès public, de sorte qu'il est possible d'accéder en utilisant l'instance de la classe à partir de l'extérieur 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 des méthodes en C #
Vous pouvez utiliser le nom de la méthode d'appel. L'exemple suivant illustre ce point:
using System;
namespace CalculatorApplication
{
NumberManipulator de classe
{
public int FindMax (int num1, int num2)
{
/ * Local déclaration variable * /
résultat int;
if (num1> num2)
résultat = num1;
autre
résultat = num2;
return result;
}
static void Main (string [] args)
{
/ * Définitions variables locales * /
int a = 100;
int b = 200;
int ret;
NumberManipulator n = new NumberManipulator ();
// Appel de méthode FindMax ret = n.FindMax (a, b);
Console.WriteLine ( "Max est: {0}", ret);
Console.ReadLine ();
}
}
}
Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants:
La valeur maximale est: 200
Vous pouvez également d'autres types d'instance de classe de méthodes publiques appelé à partir d'une autre classe. Par exemple, la méthodeFindMaxappartient la classeNumberManipulator,vous pouvez l' appeler d'un autretestde classe.
using System;
namespace CalculatorApplication
{
NumberManipulator de classe
{
public int FindMax (int num1, int num2)
{
/ * Local déclaration variable * /
résultat int;
if (num1> num2)
résultat = num1;
autre
résultat = num2;
return result;
}
}
Class Test
{
static void Main (string [] args)
{
/ * Définitions variables locales * /
int a = 100;
int b = 200;
int ret;
NumberManipulator n = new NumberManipulator ();
// Appel de méthode FindMax ret = n.FindMax (a, b);
Console.WriteLine ( "Max est: {0}", ret);
Console.ReadLine ();
}
}
}
Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants:
最大值是： 200
Récursifs appels de méthode
Une méthode peut appeler l'auto. Ceci est appelérécursivité.L'exemple suivant utilise une fonction récursive pour calculer la factorielle d'un nombre:
using System;
namespace CalculatorApplication
{
NumberManipulator de classe
{
public int factorielle (int num)
{
/ * Définitions variables locales * /
résultat int;
if (num == 1)
{
return 1;
}
autre
{
résultat = factorielle (num - 1) * num;
return result;
}
}
static void Main (string [] args)
{
NumberManipulator n = new NumberManipulator ();
// Appel de la méthode factorielle Console.WriteLine ( "6 factorielle est: {0}", n.factorial (6));
Console.WriteLine ( "7 factorielle est: {0}", n.factorial (7));
Console.WriteLine ( "8 factoriel est: {0}", n.factorial (8));
Console.ReadLine ();
}
}
}
Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants:
6 factorielle est: 720 7 factorielle est: 5040 8 factoriel est: 40320
Paramètre passant
Lorsque vous appelez une méthode avec des paramètres, vous aurez besoin de passer des paramètres à la méthode. En C #, il y a trois façons de passer des paramètres à la méthode:
| 方式 | 描述 |
|---|---|
| 值参数 | 这种方式复制参数的实际值给函数的形式参数，实参和形参使用的是两个不同内存中的值。在这种情况下，当形参的值发生改变时，不会影响实参的值，从而保证了实参数据的安全。 |
| 引用参数 | 这种方式复制参数的内存位置的引用给形式参数。这意味着，当形参的值发生改变时，同时也改变实参的值。 |
| 输出参数 | 这种方式可以返回多个值。 |
Passage de paramètres par valeur
Ceci est le paramètre par défaut qui passe. De cette façon, lorsque vous appelez une méthode qui crée un nouvel emplacement de stockage pour chaque paramètre.
La valeur du paramètre réel est copié dans les paramètres, les arguments et les paramètres utilisés dans deux valeurs de mémoire différente. Ainsi, lorsque les variations de la valeur du paramètre ne sera pas affecter la valeur de l'argument, assurant ainsi la sécurité des données de 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 ont montré que, même au sein de la fonction modifie la valeur, la valeur de tout changement était arrivé.
Passer les paramètres par référence
Paramètre de référence estune référence à l'emplacement de mémoire variable.Lorsque les paramètres passés par référence, avec la valeur du paramètre est différent, il est qu'il ne crée pas un nouvel emplacement de stockage pour ces paramètres. Référence paramètre représente le paramètre réel de la méthode a le même emplacement de mémoire.
En C #, en utilisant le mot - cléref pour déclarer un paramètre de référence.L'exemple suivant illustre ce point:
using System;
namespace CalculatorApplication
{
NumberManipulator de classe
{
échange public void (ref int x, y ref int)
{
int température;
temp = x; / * enregistrer la valeur de x * /
x = y / * y est affecté à x * /
y = température; / * la température affectation à y * /
}
static void Main (string [] args)
{
NumberManipulator n = new NumberManipulator ();
/ * Définitions variables locales * /
int a = 100;
int b = 200;
Console.WriteLine ( "Avant l'échange, une valeur de: {0}", a);
Console.WriteLine ( "Avant l'échange, les valeurs b: {0}", b);
/ * Appel de la fonction de la valeur d'échange * /
n.swap (ref a, ref b);
Console.WriteLine ( "Après un échange, une valeur de: {0}", a);
Console.WriteLine ( "Après un échange, les valeurs 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
Les résultats ont montré que la valeur de la fonctiond'échangedans le changement, et ce changement peuvent être pris en compte danslafonctionprincipale.
Passage de paramètres par sortie
instruction de retour peut être utilisé que pour renvoyer une valeur à partir d'une fonction. Cependant, vous pouvez utiliser leparamètre de sortie pour revenir deux valeurs de fonctions.méthode de sortie des données de sortie de paramètre assignera leur propre, et d'autres paramètres de référence similaires.
L'exemple suivant illustre ce point:
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
Livré aux variables de paramètres de sortie ne nécessite pas l'affectation. Lorsque vous avez besoin de retourner une valeur à partir de la valeur initiale d'un paramètre non spécifié dans la méthode, le paramètre de sortie est particulièrement utile. Prenons l'exemple suivant pour comprendre ceci:
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 le résultat suivant (en fonction de l'entrée utilisateur):
S'il vous plaît entrer une valeur: 7 S'il vous plaît entrer la deuxième valeur: 8 Après l'appel de méthode, une valeur: 7 Après l'appel de méthode, les valeurs b: 8