[Tutoriel c#] Méthode C#

Méthode 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 la méthode en C#

Lorsque vous définissez une méthode, vous déclarez essentiellement un élément 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, qui détermine l'accès d'un variable ou méthode vers une autre classe Visibilité.

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 nul.

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 : la liste des paramètres, entre parenthèses, est utilisée 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, qui contient l'ensemble des instructions nécessaires pour accomplir 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 de Call une méthode publique d'une autre classe d'une autre classe. 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écursivité. 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 des paramètres à la méthode. En C#, il existe trois manières de transmettre des paramètres aux méthodes :

Méthode

Description

Paramètre de valeur Cette méthode copie la valeur réelle du paramètre dans le paramètre formel de la fonction. Le paramètre réel et le paramètre formel utilisent deux valeurs différentes en mémoire. Dans ce cas, 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.

Paramètre de référence Cette méthode copie la référence de l'emplacement mémoire du paramètre dans le paramètre formel. Cela signifie que lorsque la valeur du paramètre formel change, la valeur du paramètre réel change également.

Paramètres de sortie Cette méthode peut renvoyer plusieurs valeurs.

Passer les paramètres par valeur

C'est la méthode par défaut pour transmettre les paramètres. De cette manière, 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 des modifications sont apportées dans la fonction La valeur n'a pas changé du tout.

按引用传递参数

引用参数是一个对变量的内存位置的引用。当按引用传递参数时，与值参数不同的是，它不会为这些参数创建一个新的存储位置。引用参数表示与提供给方法的实际参数具有相同的内存位置。

在 C# 中，使用 ref 关键字声明引用参数。下面的实例演示了这点：

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();

      }
   }
}

当上面的代码被编译和执行时，它会产生下列结果：

在交换之前，a 的值：100
在交换之前，b 的值：200
在交换之后，a 的值：200
在交换之后，b 的值：100

结果表明，swap 函数内的值改变了，且这个改变可以在 Main 函数中反映出来。

按输出传递参数

return 语句可用于只从函数中返回一个值。但是，可以使用 输出参数 来从函数中返回两个值。输出参数会把方法输出的数据赋给自己，其他方面与引用参数相似。

下面的实例演示了这点：

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();

      }
   }
}

当上面的代码被编译和执行时，它会产生下列结果：

在方法调用之前，a 的值： 100
在方法调用之后，a 的值： 5

提供给输出参数的变量不需要赋值。当需要从一个参数没有指定初始值的方法中返回值时，输出参数特别有用。请看下面的实例，来理解这一点：

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();
      }
   }
}

当上面的代码被编译和执行时，它会产生下列结果（取决于用户输入）：

请输入第一个值：
7
请输入第二个值：
8
在方法调用之后，a 的值： 7
在方法调用之后，b 的值： 8

 以上就是【c#教程】C# 方法的内容，更多相关内容请关注PHP中文网（www.php.cn）！