Methoden und Parameterverwendung in C#

In C# werden Methoden verwendet, um wiederholten Code übersichtlich und wiederverwendbar zu machen. Eine Methode erfüllt eine bestimmte Aufgabe und kann im Programm mehrfach aufgerufen werden. Dadurch wird Code-Duplikation vermieden und die Lesbarkeit verbessert.

Methoden definieren und aufrufen

Eine Methode wird mit einem Rückgabetyp, einem Namen und optionalen Parametern definiert. Zum Beispiel gibt die folgende Methode eine einfache Nachricht aus:

static void Begruessen()
{
    Console.WriteLine("Hallo!");
}

static void Main()
{
    Begruessen(); // Methodenaufruf
}

// Ausgabe:
Hallo!

Methoden mit Parametern

Methoden können Werte von außen annehmen. Diese Werte nennt man Parameter. Im folgenden Beispiel wird ein Name übergeben und die Begrüßung personalisiert:

static void Begruessen(string name)
{
    Console.WriteLine("Hallo " + name + "!");
}

static void Main()
{
    Begruessen("Anna");
    Begruessen("Max");
}

// Ausgabe:
Hallo Anna!
Hallo Max!

Methoden mit Rückgabewert

Methoden können eine Berechnung durchführen und ein Ergebnis zurückgeben. Dafür wird ein Rückgabetyp definiert (int, string usw.). Das folgende Beispiel zeigt eine Methode, die zwei Zahlen addiert:

static int Addiere(int a, int b)
{
    return a + b;
}

static void Main()
{
    int ergebnis = Addiere(5, 7);
    Console.WriteLine("Summe: " + ergebnis);
}

// Ausgabe:
Summe: 12

Standardparameter

Parametern können Standardwerte zugewiesen werden. Wird beim Aufruf kein Wert übergeben, wird dieser Standardwert verwendet:

static void NachrichtAusgeben(string text = "Standardnachricht")
{
    Console.WriteLine(text);
}

static void Main()
{
    NachrichtAusgeben("Hallo Welt!");
    NachrichtAusgeben();
}

// Ausgabe:
Hallo Welt!
Standardnachricht

Parameter vs. Argument

Ein Parameter ist der Name in der Methodendefinition. Ein Argument ist der tatsächliche Wert, der beim Aufruf übergeben wird.

static void Quadrat(int zahl) // Parameter: zahl
{
    Console.WriteLine(zahl * zahl);
}

static void Main()
{
    Quadrat(4); // Argument: 4
}

// Ausgabe:
16

Überladung (Overloading)

Methoden mit demselben Namen, aber unterschiedlicher Anzahl oder Typen von Parametern können definiert werden. Dies nennt man Method Overloading:

static int Multipliziere(int a, int b)
{
    return a * b;
}

static int Multipliziere(int a, int b, int c)
{
    return a * b * c;
}

static void Main()
{
    Console.WriteLine(Multipliziere(3, 4));
    Console.WriteLine(Multipliziere(2, 3, 4));
}

// Ausgabe:
12
24

Rekursion

Wenn sich eine Methode selbst aufruft, spricht man von Rekursion. Jede Rekursion muss eine Abbruchbedingung haben, sonst läuft sie unendlich weiter.

static int Fakultaet(int n)
{
    if (n <= 1)
        return 1; // Abbruchbedingung
    return n * Fakultaet(n - 1); // Selbstaufruf
}

static void Main()
{
    Console.WriteLine(Fakultaet(5)); // 120
}

ref- und out-Parameter

In C# ermöglichen die Schlüsselwörter ref und out, dass Parameter per Referenz übergeben werden. Dadurch wirken sich Änderungen innerhalb der Methode auch außerhalb aus.

// ref-Beispiel
static void Erhoehen(ref int zahl)
{
    zahl++;
}

// out-Beispiel
static void Lesen(out int ergebnis)
{
    ergebnis = 42;
}

static void Main()
{
    int x = 5;
    Erhoehen(ref x);
    Console.WriteLine(x); // 6

    int y;
    Lesen(out y);
    Console.WriteLine(y); // 42
}

Mehrere Parameter mit params

Das Schlüsselwort params ermöglicht es, eine variable Anzahl von Parametern zu übergeben. Man kann entweder ein Array oder einzelne Werte übergeben.

Beispiel: Zahlen addieren

static int Addiere(params int[] zahlen)
{
    int summe = 0;
    foreach (int z in zahlen)
        summe += z;
    return summe;
}

static void Main()
{
    Console.WriteLine(Addiere(1, 2, 3));       // 6
    Console.WriteLine(Addiere(5, 10, 15, 20)); // 50
}

Beispiel: Texte verbinden

static string Verbinde(params string[] woerter)
{
    return string.Join(" ", woerter);
}

static void Main()
{
    Console.WriteLine(Verbinde("C#", "ist", "eine", "mächtige", "Sprache."));
    // Ausgabe: C# ist eine mächtige Sprache.
}

Lokale Funktionen

Seit C# 7.0 können Methoden innerhalb anderer Methoden definiert werden. Diese nennt man lokale Funktionen. Sie sorgen für besser lesbaren und strukturierten Code.

static void Main()
{
    int Multipliziere(int a, int b) // lokale Funktion
    {
        return a * b;
    }

    Console.WriteLine(Multipliziere(3, 4)); // 12
}

TL;DR