> ## Documentation Index
> Fetch the complete documentation index at: https://homelab.amylify.de/llms.txt
> Use this file to discover all available pages before exploring further.

# 4.2.4 Methoden

> Methoden in C#: Parameter, Rückgabewerte, optionale und benannte Argumente, ref, out und Lambdas.

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

***

## Aufbau einer Methode

```csharp theme={"dark"}
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 |

> [!NOTE]
>
> 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)

```csharp theme={"dark"}
static void Begruesse(string name)
{
    Console.WriteLine($"Hallo {name}!");
}

Begruesse("Mira");
```

### Kurzschreibweise

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

```csharp theme={"dark"}
static int Quadrat(int x) => x * x;
```

***

## Parameter im Detail

### Optionale Parameter

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

```csharp theme={"dark"}
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:

```csharp theme={"dark"}
Gruss(anrede: "Moin", name: "Mira");
```

### Überladung

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

```csharp theme={"dark"}
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:

```csharp theme={"dark"}
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:

```csharp theme={"dark"}
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 |

> [tab] ref
>
> ```csharp theme={"dark"}
> static void Verdopple(ref int zahl)
> {
>     zahl *= 2;
> }
>
> int x = 5;
> Verdopple(ref x);
> Console.WriteLine(x);   // 10
> ```

> [tab] out
>
> Praktisch, wenn eine Methode mehrere Werte liefern soll. Ein bekanntes Beispiel ist `int.TryParse`:
>
> ```csharp theme={"dark"}
> 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
> }
> ```

> [!NOTE]
>
> 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:

```csharp theme={"dark"}
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

> [tab] Lokale Funktion
>
> Eine Methode in einer Methode, nur dort sichtbar:
>
> ```csharp theme={"dark"}
> static void Bericht(int[] werte)
> {
>     Console.WriteLine($"Summe: {Summe()}");
>
>     int Summe()
>     {
>         int s = 0;
>         foreach (int w in werte) s += w;
>         return s;
>     }
> }
> ```

> [tab] Lambda
>
> Eine kurze, namenlose Funktion. Sie wird oft an andere Methoden übergeben (siehe LINQ):
>
> ```csharp theme={"dark"}
> 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:

```csharp theme={"dark"}
static int Fakultaet(int n)
{
    if (n <= 1) return 1;          // Abbruchfall
    return n * Fakultaet(n - 1);   // Selbstaufruf
}

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

***

## Gute Methoden

> [card] Eine Aufgabe
>
> Jede Methode erledigt genau eine Sache.

> [card] Klarer Name
>
> Verb zuerst: `BerechneSumme`, `LeseEingabe`.

> [card] Kurz halten
>
> Passt sie nicht mehr auf einen Bildschirm, aufteilen.

***

## Weiter

> [card] [4.2.5 Arrays & Collections](https://homelab.amylify.de/documentation/code/csharp/collections.md)
>
> Viele Werte in einer Variable speichern.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.