4.2.4 Methoden

Eine Methode ist ein benannter Codeblock, den du beliebig oft aufrufen kannst. Sie vermeidet Wiederholungen und macht Programme lesbar.

Aufbau einer Methode

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

int summe = Addiere(3, 4);   // Aufruf, summe ist 7

Teil	Beispiel	Bedeutung
Modifizierer	`static`	In Top-Level-Programmen genügt `static`
Rückgabetyp	`int`	Welchen Typ die Methode zurückgibt, `void` heißt: nichts
Name	`Addiere`	`PascalCase`, am besten ein Verb
Parameter	`int a, int b`	Eingabewerte, durch Komma getrennt
`return`	`return a + b;`	Gibt den Wert zurück und beendet die Methode

In Dateien mit Top-Level-Anweisungen stehen Methoden unter dem Hauptcode oder in einer eigenen Klasse. Der Hauptcode darf sie trotzdem davor aufrufen.

Ohne Rückgabewert (void)

static void Begruesse(string name)
{
    Console.WriteLine($"Hallo {name}!");
}

Begruesse("Mira");

Kurzschreibweise

Besteht die Methode nur aus einem Ausdruck, geht es mit =>:

static int Quadrat(int x) => x * x;

Parameter im Detail

Optionale Parameter

Mit einem Standardwert muss das Argument beim Aufruf nicht angegeben werden:

static void Gruss(string name, string anrede = "Hallo")
{
    Console.WriteLine($"{anrede} {name}!");
}

Gruss("Mira");             // Hallo Mira!
Gruss("Mira", "Servus");   // Servus Mira!

Optionale Parameter stehen immer hinter den Pflichtparametern.

Benannte Argumente

Du kannst Argumente mit Namen übergeben, dann ist die Reihenfolge egal und der Aufruf besser lesbar:

Gruss(anrede: "Moin", name: "Mira");

Überladung

Mehrere Methoden dürfen gleich heißen, wenn sich ihre Parameter unterscheiden:

static int Maximum(int a, int b) => a > b ? a : b;
static double Maximum(double a, double b) => a > b ? a : b;

Beliebig viele Argumente

Mit params nimmt eine Methode eine variable Anzahl Werte entgegen:

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

Console.WriteLine(Summe(1, 2, 3, 4));   // 10

Wert oder Referenz übergeben

Standardmäßig bekommt die Methode eine Kopie des Werts. Änderungen darin bleiben unsichtbar:

static void Verdopple(int zahl)
{
    zahl *= 2;   // ändert nur die Kopie
}

int x = 5;
Verdopple(x);
Console.WriteLine(x);   // 5

Mit Modifizierern lässt sich das steuern:

Modifizierer	Bedeutung	Muss vorher einen Wert haben?
`ref`	Die Methode arbeitet mit der Original-Variable und darf sie ändern	Ja
`out`	Die Methode muss einen Wert zuweisen, gedacht für zusätzliche Ergebnisse	Nein
`in`	Nur lesen, aber ohne Kopie (für große Strukturen)	Ja

static void Verdopple(ref int zahl)
{
    zahl *= 2;
}

int x = 5;
Verdopple(ref x);
Console.WriteLine(x);   // 10

Praktisch, wenn eine Methode mehrere Werte liefern soll. Ein bekanntes Beispiel ist int.TryParse:

static bool Teile(int a, int b, out int ergebnis)
{
    if (b == 0)
    {
        ergebnis = 0;
        return false;
    }
    ergebnis = a / b;
    return true;
}

if (Teile(10, 2, out int resultat))
{
    Console.WriteLine(resultat);   // 5
}

Objekte (Klassen, Arrays, Listen) sind Referenztypen. Übergibst du sie, zeigt der Parameter schon auf dasselbe Objekt, Änderungen am Inhalt sind also auch außerhalb sichtbar.

Gültigkeitsbereich

Eine Variable existiert nur in dem { }-Block, in dem sie deklariert wurde:

static void Beispiel()
{
    int aussen = 1;

    if (aussen > 0)
    {
        int innen = 2;       // nur in diesem Block bekannt
        Console.WriteLine(aussen + innen);
    }

    // Console.WriteLine(innen);   // Fehler CS0103: Name existiert nicht
}

Variablen einer Methode sind außerhalb unbekannt. Was eine andere Methode braucht, übergibst du als Parameter und gibst es als Rückgabewert zurück.

Lokale Funktionen und Lambdas

Lokale Funktion
Lambda

Eine Methode in einer Methode, nur dort sichtbar:

static void Bericht(int[] werte)
{
    Console.WriteLine($"Summe: {Summe()}");

    int Summe()
    {
        int s = 0;
        foreach (int w in werte) s += w;
        return s;
    }
}

Eine kurze, namenlose Funktion. Sie wird oft an andere Methoden übergeben (siehe LINQ):

Func<int, int> quadrat = x => x * x;
Console.WriteLine(quadrat(6));   // 36

Action<string> ausgabe = text => Console.WriteLine(text);
ausgabe("Hallo");

Func<...> hat einen Rückgabewert (der letzte Typ), Action<...> hat keinen.

Rekursion

Eine Methode darf sich selbst aufrufen. Sie braucht immer einen Abbruchfall, sonst endet sie nie:

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

Console.WriteLine(Fakultaet(5));   // 120

Gute Methoden

Eine Aufgabe

Jede Methode erledigt genau eine Sache.

Klarer Name

Verb zuerst: BerechneSumme, LeseEingabe.

Kurz halten

Passt sie nicht mehr auf einen Bildschirm, aufteilen.

Weiter

4.2.5 Arrays & Collections

Viele Werte in einer Variable speichern.

Getting Started

Documentation

Aufbau einer Methode

Ohne Rückgabewert (void)

Kurzschreibweise

Parameter im Detail

Optionale Parameter

Benannte Argumente

Überladung

Beliebig viele Argumente

Wert oder Referenz übergeben

Gültigkeitsbereich

Lokale Funktionen und Lambdas

Rekursion

Gute Methoden

Eine Aufgabe

Klarer Name

Kurz halten

Weiter

4.2.5 Arrays & Collections

​Aufbau einer Methode

​Ohne Rückgabewert (void)

​Kurzschreibweise

​Parameter im Detail

​Optionale Parameter

​Benannte Argumente

​Überladung

​Beliebig viele Argumente

​Wert oder Referenz übergeben

​Gültigkeitsbereich

​Lokale Funktionen und Lambdas

​Rekursion

​Gute Methoden

Eine Aufgabe

Klarer Name

Kurz halten

​Weiter

4.2.5 Arrays & Collections

Aufbau einer Methode

Ohne Rückgabewert (void)

Kurzschreibweise

Parameter im Detail

Optionale Parameter

Benannte Argumente

Überladung

Beliebig viele Argumente

Wert oder Referenz übergeben

Gültigkeitsbereich

Lokale Funktionen und Lambdas

Rekursion

Gute Methoden

Weiter