C# Methoden

Eine Methode ist ein Codeblock, der eine Reihe zusammengehöriger Anweisungen organisiert, um eine bestimmte Aufgabe auszuführen. Sie ist die Umsetzung in C# vonCode-WiederverwendungundLogik-Kapselungdem Kernmechanismus. Jedes C#-Programm hat mindestens eineMainEine Methode dient als Programmeinstiegspunkt.

Die Verwendung einer Methode erfordert zwei Schritte:Methode definierenundMethode aufrufen。

1. Methoden definieren

Die grundlegende Syntax zum Definieren einer Methode in C# lautet wie folgt:

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

Eine Methode besteht aus den folgenden Elementen:

  • Zugriffsmodifizierer(Zugriffsmodifizierer): Steuert die Sichtbarkeit der Methode, wie z. B.public、private、protected、internal。
  • Rückgabetyp(Rückgabetyp): Der Datentyp des Rückgabewerts der Methode. Wenn die Methode keinen Wert zurückgibt, verwenden Sievoid。
  • Methodenname(Methodenname): Die eindeutige Kennung der Methode, die den PascalCase-Namenskonventionen folgt (z. B.FindMax、GetUserName）。
  • Parameterliste(Parameterliste): Die Eingaben, die die Methode empfängt, in Klammern eingeschlossen. Parameter sind optional; eine Methode kann keine Parameter haben.
  • Methodenkörper(Methodenkörper): Enthält den Code, der die Funktionalität implementiert, in geschweiften Klammern eingeschlossen{}Umschließen.

Die folgende Abbildung zeigt die vollständige Struktur einer Methode:

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 Erstes Methodenbeispiel

Das Folgende definiert eineFindMaxEine Methode, die zwei Ganzzahlen entgegennimmt und die größere zurückgibt:

Beispiel

using System;

namespace MethodDemo
{
    class NumberHelper
    {
        // Definiert eine Methode, die zwei int-Werte entgegennimmt und die größere zurückgibt
        public int FindMax(int num1, int num2)
        {
            if (num1 > num2)
                return num1;
            else
                return num2;
        }

        static void Main(string[] args)
        {
            // Ein Objekt erstellen und die Methode aufrufen
            NumberHelper helper = new NumberHelper();
            int result = helper.FindMax(100, 200);

            Console.WriteLine($"Der Maximalwert ist: {result}");  // Der Maximalwert ist: 200
        }
    }
}

Der Methodenaufrufprozess:

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

Klassenübergreifender Aufruf:Solange die Methode deklariert ist alspublic, dann kann sie von anderen Klassen durch Erstellen einer Instanz aufgerufen werden. Dies ist die Grundlage der Codewiederverwendung in der objektorientierten Programmierung.

2. Parameterübergabemethoden

C# bietet drei Möglichkeiten, Parameter an Methoden zu übergeben. Der entscheidende Unterschied liegt darin,ob Speicher gemeinsam genutzt wird：

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)
Methode Schlüsselwörter Verhalten Typische Szenarien
Übergabe per Wert (keine) Kopiert den Parameterwert; Änderungen innerhalb der Methode wirken sich nicht auf die ursprüngliche Variable aus. Die meisten Methodenaufrufe (Standard)
Übergabe per Referenz ref Übergabe einer Referenz auf die Variable; Änderungen innerhalb der Methode verändern die ursprüngliche Variable. Externe Variablen müssen geändert werden (z. B. Werte tauschen)
Ausgabeparameter out Ähnlich wie ref, aber die Methode muss einen Wert zuweisen, und die Variable muss vor dem Aufruf nicht initialisiert werden. Die Methode muss mehrere Werte zurückgeben

2.1 Übergabe als Wert (Standard)

Die Übergabe als Wert ist der Standard. Der Wert des Arguments wirdkopiertund an den Parameter übergeben; Änderungen am Parameter innerhalb der Methode wirken sich nicht auf die ursprüngliche Variable aus:

Beispiel

using System;

namespace ParameterDemo
{
    class Program
    {
        // Übergabe als Wert: x und y sind Kopien von a und b
        public void Swap(int x, int y)
        {
            int temp = x;
            x = y;
            y = temp;
            Console.WriteLine($" Innerhalb der Methode: x={x}, y={y}");  // Tausch erfolgreich
        }

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

            Console.WriteLine($Vor dem Aufruf: a={a}, b={b});
            p.Swap(a, b);
            Console.WriteLine($Nach dem Aufruf: a={a}, b={b});  // a, b haben sich nicht geändert!
        }
    }
}
调用前：a=100, b=200
  方法内：x=200, y=100
调用后：a=100, b=200

2.2 Übergabe per Referenz (ref)

NutzungrefDas Schlüsselwort übergibt dieReferenz(Speicheradresse) der Variablen; Änderungen am Parameter innerhalb der Methode wirken sich direkt auf die ursprüngliche Variable aus. Beachten Sie, dass das Schlüsselwort auch beim Aufruf angegeben werden muss.ref：

Beispiel

using System;

namespace ParameterDemo
{
    class Program
    {
        // Übergabe per Referenz: x und y verweisen direkt auf den Speicher von 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($Vor dem Aufruf: a={a}, b={b});
            p.Swap(ref a, ref b);  // Beim Aufruf muss ebenfalls ref angegeben werden
            Console.WriteLine($Nach dem Aufruf: a={a}, b={b});  // Tausch erfolgreich!
        }
    }
}
调用前：a=100, b=200
调用后：a=200, b=100

Der Unterschied zwischen ref und out:refErfordert die Variable vor der ÜbergabeMuss bereits initialisiert sein；outDann ist sie nicht erforderlich, aber innerhalb der MethodeDem out-Parameter muss ein Wert zugewiesen werden, bevor er verwendet werden kann.

2.3 Ausgabeparameter (out)

outParameter ermöglichen es der Methode,mehrere Werte zurückzugeben. UndrefDer Unterschied besteht darin, dass die Variable vor dem Aufruf nicht initialisiert werden muss, aber die Methode ihr einen Wert zuweisen muss:

Beispiel

using System;

namespace ParameterDemo
{
    class Program
    {
        // out-Parameter: Die Methode ist für die Zuweisung verantwortlich
        public void GetValues(out int x, out int y)
        {
            Console.Write("Bitte geben Sie den ersten Wert ein:");
            x = Convert.ToInt32(Console.ReadLine());

            Console.Write("Bitte geben Sie den zweiten Wert ein:");
            y = Convert.ToInt32(Console.ReadLine());
            // Hinweis: Alle out-Parameter müssen zugewiesen werden, bevor die Methode endet, andernfalls tritt ein Kompilierungsfehler auf.
        }

        // Praxisbeispiel: TryParse-Muster
        public bool TryDivide(int a, int b, out double result)
        {
            if (b == 0)
            {
                result = 0;
                return false;  // Division durch Null
            }
            result = (double)a / b;
            return true;
        }

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

            // out-Parameter müssen nicht initialisiert werden
            int a, b;
            p.GetValues(out a, out b);
            Console.WriteLine($"a={a}, b={b}");

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

Seit C# 7.0 können Sie beim Aufruf mit derInline-Deklarationvon out-Variablen den Code prägnanter machen:

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

3. Rekursive Methoden

Rekursion bezeichnet eine Methode,die sich selbst aufruft.Jede rekursive Methode benötigt zwei Elemente:

  • Abbruchbedingung(Basisfall): Die Bedingung, die die Rekursion beendet und eine unendliche Rekursion verhindert.
  • Rekursiver Schritt(Rekursiver Schritt): Zerlegt das Problem in kleinere Teilprobleme.

Klassisches Beispiel — Berechnung der Fakultät $$n! = n \times (n-1)!$$:

Beispiel

using System;

namespace RecursionDemo
{
    class Program
    {
        // Fakultät rekursiv berechnen
        public int Factorial(int n)
        {
            // Abbruchbedingung: 0! = 1, 1! = 1
            if (n <= 1)
                return 1;

            // Rekursiver Schritt: 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

Der Expansionsprozess rekursiver Aufrufe:

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

Hinweis:Wenn die Rekursionstiefe zu groß ist, kann dies verursachenStackOverflowExceptionErwägen Sie bei leistungssensiblen Szenarien stattdessen die Verwendung einer Schleife.

4. Weitere Merkmale von Methoden

4.1 Standardparameter und benannte Parameter

In C# können Parameter mit einemStandardwertfestgelegt werden; beim Aufruf können diese Parameter weggelassen werden. In Kombination mitbenannten Parameternkönnen Sie außerdem einige Parameter überspringen und nur die folgenden angeben:

Beispiel

using System;

namespace MethodFeatures
{
    class Program
    {
        // Standardparameter: power hat standardmäßig den Wert 2
        static double Power(double baseNum, int Potenz = 2)
        {
            double result = 1;
            for (int i = 0; i < power; i++)
                result *= baseNum;
            return result;
        }

        // Mehrere Standardparameter
        static void PrintInfo(string name, int age = 18, string city = "Unbekannt")
        {
            Console.WriteLine($"{name}, {age} Jahre alt, {city}");
        }

        static void Main(string[] args)
        {
            // Verwendung von Standardparametern
            Console.WriteLine(Power(3));       // 9.0 (mit Standardwert power=2)
            Console.WriteLine(Power(3, 3));    // 27.0

            // Benannte Argumente: age überspringen, nur city angeben
            PrintInfo(Xiaoming, city: "Beijing");
            // Ausgabe: Xiaoming, 18 Jahre alt, Beijing

            // Benannte Argumente können in beliebiger Reihenfolge stehen
            PrintInfo(city: "Shanghai", name: Xiaohong, age: 25);
            // Ausgabe: Xiaohong, 25 Jahre alt, Shanghai
        }
    }
}

4.2 Ausdruckskörper-Methoden

Wenn der Methodenrumpf nur eine Anweisung enthält, können Sie=>Vereinfachte Syntax (C# 6.0+):

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

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

4.3 Methodenüberladung (Overloading)

In derselben Klasse kann esmehrere Methoden mit demselben Namengeben, solange die Parameterlisten unterschiedlich sind (unterschiedliche Parametertypen, -anzahlen oder -reihenfolge):

Beispiel

using System;

namespace MethodFeatures
{
    class Calculator
    {
        // Überladung 1: Zwei int-Werte addieren
        public int Add(int a, int b) => a + b;

        // Überladung 2: Drei int-Werte addieren
        public int Add(int a, int b, int c) => a + b + c;

        // Überladung 3: Zwei double-Werte addieren
        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 (Aufruf von Überladung 1)
            Console.WriteLine(calc.Add(1, 2, 3));      // 6 (Aufruf von Überladung 2)
            Console.WriteLine(calc.Add(1.5, 2.5));     // 4.0 (Aufruf von Überladung 3)
        }
    }
}

Zusammenfassung

Funktionen Syntax Beschreibung
Methode definieren int Add(int a, int b) { ... } Rückgabetyp, Methodennamen und Parameter angeben
Kein Rückgabewert void DoSomething() { ... } voidGibt an, dass kein Wert zurückgegeben wird
Übergabe per Wert void Foo(int x) Standardmethode; Änderungen an Parametern wirken sich nicht auf Argumente aus
Übergabe per Referenz void Foo(ref int x) Gemeinsam genutzter Speicher; Änderungen werden in den Argumenten widergespiegelt
Ausgabeparameter void Foo(out int x) Muss innerhalb der Methode zugewiesen werden; kann mehrere Werte zurückgeben
Standardparameter void Foo(int x = 10) Kann beim Aufruf weggelassen werden; verwendet Standardwerte
Benannte Parameter Foo(city: "北京") Parameter nach Namen angeben, Reihenfolge kann geändert werden
Ausdruckskörper int Add(int a, int b) => a + b; Kurzschreibweise für einzeilige Methoden (C# 6.0+)
Methodenüberladung Gleicher Name, unterschiedliche Parameter Der Compiler wählt automatisch anhand der Parameterliste aus
Weitere Erweiterungen