[c#-Tutorial] C#-Methode

C#-Methode

Eine Methode besteht darin, einige verwandte Anweisungen in einem Anweisungsblock zusammenzufassen, um eine Aufgabe auszuführen. Jedes C#-Programm verfügt über mindestens eine Klasse mit einer Main-Methode.

Um eine Methode zu verwenden, müssen Sie:

die Methode definieren

die Methode aufrufen

die Methode in C# definieren

Wenn Sie eine Methode definieren, deklarieren Sie im Wesentlichen ein Element ihrer Struktur. In C# lautet die Syntax zum Definieren einer Methode wie folgt:

<Access Specifier> <Return Type> <Method Name>(Parameter List)
{
   Method Body
}

Im Folgenden sind die verschiedenen Elemente der Methode aufgeführt:

Zugriffsspezifizierer: Zugriffsmodifikator, der den Zugriff von a bestimmt Variable oder Methode in eine andere Sichtbarkeitsklasse einfügen.

Rückgabetyp: Rückgabetyp, eine Methode kann einen Wert zurückgeben. Der Rückgabetyp ist der Datentyp des von der Methode zurückgegebenen Werts. Wenn die Methode keinen Wert zurückgibt, ist der Rückgabetyp void.

Methodenname: Der Methodenname ist eine eindeutige Kennung und unterscheidet zwischen Groß- und Kleinschreibung. Er darf nicht mit anderen in der Klasse deklarierten Bezeichnern identisch sein.

Parameterliste: Die in Klammern eingeschlossene Parameterliste wird zum Übergeben und Empfangen von Methodendaten verwendet. Die Parameterliste bezieht sich auf den Parametertyp, die Reihenfolge und die Nummer der Methode. Parameter sind optional, das heißt, eine Methode darf keine Parameter enthalten.

Methodenkörper: Methodenkörper, der die zum Abschließen der Aufgabe erforderlichen Anweisungen enthält.

Beispiel

Der folgende Codeausschnitt zeigt eine Funktion FindMax, die zwei ganzzahlige Werte akzeptiert und den größeren der beiden zurückgibt. Es verfügt über einen öffentlichen Zugriffsmodifikator, sodass von außerhalb der Klasse mithilfe einer Instanz der Klasse darauf zugegriffen werden kann.

class NumberManipulator
{
   public int FindMax(int num1, int num2)
   {
      /* 局部变量声明 */
      int result;

      if (num1 > num2)
         result = num1;
      else
         result = num2;

      return result;
   }
   ...
}

Methoden in C# aufrufen

Sie können eine Methode über ihren Namen aufrufen. Das folgende Beispiel zeigt dies:

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

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt er die folgenden Ergebnisse:

最大值是： 200

Sie können auch eine Instanz einer Klasse von Call verwenden eine öffentliche Methode einer anderen Klasse aus einer anderen Klasse. Beispielsweise gehört die Methode FindMax zur Klasse NumberManipulator und Sie können sie von einer anderen Klasse Test aus aufrufen.

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

        }
    }
}

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt er die folgenden Ergebnisse:

最大值是： 200

Rekursiver Methodenaufruf

Eine Methode kann sich selbst aufrufen. Dies nennt man Rekursion. Das folgende Beispiel verwendet eine rekursive Funktion, um die Fakultät einer Zahl zu berechnen:

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

        }
    }
}

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt er die folgenden Ergebnisse:

6 的阶乘是： 720
7 的阶乘是： 5040
8 的阶乘是： 40320

Übergabe von Parametern

Wenn Sie eine Methode mit Parametern aufrufen, müssen Sie Parameter an die Methode übergeben. In C# gibt es drei Möglichkeiten, Parameter an Methoden zu übergeben:

Methode

Beschreibung

Wertparameter Diese Methode kopiert den tatsächlichen Wert des Parameters in den formalen Parameter der Funktion. Der tatsächliche Parameter und der formale Parameter verwenden zwei Werte in unterschiedlichen Speichern. Wenn sich in diesem Fall der Wert des formalen Parameters ändert, wird der Wert des tatsächlichen Parameters nicht beeinflusst, wodurch die Sicherheit der tatsächlichen Parameterdaten gewährleistet wird.

Referenzparameter Diese Methode kopiert die Referenz des Speicherorts des Parameters in den formalen Parameter. Das heißt, wenn sich der Wert des Formalparameters ändert, ändert sich auch der Wert des Aktualparameters.

Ausgabeparameter Diese Methode kann mehrere Werte zurückgeben.

Parameter nach Wert übergeben

Dies ist die Standardmethode der Parameterübergabe. Auf diese Weise wird beim Aufruf einer Methode für jedes Wertargument ein neuer Speicherort erstellt.

Der Wert des tatsächlichen Parameters wird in den formalen Parameter kopiert. Der tatsächliche Parameter und der formale Parameter verwenden zwei unterschiedliche Werte im Speicher. Wenn sich daher der Wert des formalen Parameters ändert, wird der Wert des tatsächlichen Parameters nicht beeinflusst, wodurch die Sicherheit der tatsächlichen Parameterdaten gewährleistet wird. Das folgende Beispiel demonstriert dieses Konzept:

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

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt er die folgenden Ergebnisse:

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

Die Ergebnisse zeigen, dass selbst dann Änderungen vorgenommen werden Die Funktion Der Wert hat sich überhaupt nicht geändert.

按引用传递参数

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

在 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）！