Methoden in C#

Methoden sind benannte Bloecke wiederverwendbarer Logik. In C# gehoeren sie zu Klassen (oder Structs) - aber mit Top-Level Statements kannst du sie auch einfach “in der Datei” definieren.

Die Grundform

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

Begruessen();

• void = kein Rueckgabewert
• Methodennamen sind PascalCase
• () listet Parameter auf (hier keine)

Parameter und Rueckgabewerte

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

var ergebnis = Addiere(3, 4); // 7

• Rueckgabetyp steht vor dem Namen
• Parameter brauchen Typ und Namen
• return liefert den Wert

Expression-bodied Methods

Fuer einzeilige Methoden:

int Addiere(int a, int b) => a + b;
string Gross(string s) => s.ToUpper();

=> zeigt: “liefert diesen Ausdruck”.

Optional-Parameter

Standardwerte direkt im Parameter:

void Gruessen(string name = "Welt", string gruss = "Hallo")
{
    Console.WriteLine($"{gruss}, {name}!");
}

Gruessen();                       // "Hallo, Welt!"
Gruessen("Anna");                 // "Hallo, Anna!"
Gruessen("Anna", "Guten Tag");    // "Guten Tag, Anna!"

Named Arguments

Du kannst Argumente benannt uebergeben - besonders hilfreich bei vielen Parametern:

Gruessen(gruss: "Hi", name: "Leo"); // Reihenfolge egal

Das macht den Aufruf selbstdokumentierend.

Method Overloading

Mehrere Methoden mit gleichem Namen, aber unterschiedlichen Parametern:

int Addiere(int a, int b) => a + b;
double Addiere(double a, double b) => a + b;
string Addiere(string a, string b) => a + b;

Addiere(3, 4);         // int-Version
Addiere(3.5, 4.5);     // double-Version
Addiere("Hallo ", "Welt"); // string-Version

Der Compiler waehlt automatisch die passende Ueberladung anhand der Argumenttypen.

out-Parameter

Manchmal willst du mehrere Werte zurueckgeben. C# hat dafuer out:

void MinMax(int[] zahlen, out int min, out int max)
{
    min = zahlen[0];
    max = zahlen[0];
    foreach (var z in zahlen)
    {
        if (z < min) min = z;
        if (z > max) max = z;
    }
}

// Aufruf
MinMax(new[] { 3, 1, 4, 1, 5, 9, 2, 6 }, out var min, out var max);
Console.WriteLine($"Min {min}, Max {max}");

out var deklariert die Variablen inline.

Tuples als modernere Alternative

out-Parameter fuehlen sich heute etwas aus der Zeit. Die moderne Variante sind Tuples:

(int min, int max) MinMax(int[] zahlen)
{
    var min = zahlen[0];
    var max = zahlen[0];
    foreach (var z in zahlen)
    {
        if (z < min) min = z;
        if (z > max) max = z;
    }
    return (min, max);
}

var (min, max) = MinMax(new[] { 3, 1, 4, 1, 5, 9, 2, 6 });

ref-Parameter

ref erlaubt einer Methode, den uebergebenen Wert zu aendern:

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

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

Im Alltag selten noetig - return ist meistens klarer.

params - beliebig viele Argumente

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

Summe(1, 2, 3);           // 6
Summe(1, 2, 3, 4, 5);     // 15
Summe(new[] { 10, 20 });  // 30 - Array geht auch

params muss der letzte Parameter sein.

Lokale Funktionen

Du kannst Methoden innerhalb einer Methode definieren - praktisch fuer kleine Helfer, die nur lokal Sinn ergeben:

int PrimFakultaet(int n)
{
    if (!IstPrim(n))
        return -1;

    int ergebnis = 1;
    for (int i = 2; i <= n; i++) ergebnis *= i;
    return ergebnis;

    static bool IstPrim(int zahl)
    {
        if (zahl < 2) return false;
        for (int i = 2; i * i <= zahl; i++)
            if (zahl % i == 0) return false;
        return true;
    }
}

Das static vor der lokalen Funktion zeigt: “greift auf nichts von aussen zu” - gut fuer Klarheit und Performance.

Rekursion

Methoden koennen sich selbst aufrufen:

int Fakultaet(int n) =>
    n <= 1 ? 1 : n * Fakultaet(n - 1);

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

Achte auf die Abbruchbedingung - sonst Stack Overflow.

Praktisches Beispiel

string Formatieren(
    string name,
    int alter,
    string gruss = "Hallo",
    bool formal = false)
{
    var anrede = formal ? "Herr/Frau " : "";
    return $"{gruss}, {anrede}{name}! Sie sind {alter} Jahre alt.";
}

Console.WriteLine(Formatieren("Anna", 28));
// "Hallo, Anna! Sie sind 28 Jahre alt."

Console.WriteLine(Formatieren("Mueller", 45, formal: true));
// "Hallo, Herr/Frau Mueller! Sie sind 45 Jahre alt."

Stil-Tipps

• PascalCase fuer Methodennamen
• Verben benutzen (Berechne, Lade, Speichere) - die Methode tut etwas
• Kleine Methoden sind besser als grosse - eine Methode, eine Aufgabe
• Rueckgabewert > out/ref-Parameter

Zusammenfassung

• Methoden: Rueckgabetyp Name(Parameter) { ... } oder => Ausdruck
• Optional-Parameter mit Standardwerten
• Named Arguments fuer klarere Aufrufe
• Overloading nach Parameter-Signatur
• out, ref, params fuer Spezialfaelle
• Tuples sind die moderne Multi-Return-Loesung
• Lokale Funktionen fuer private Helfer

Im naechsten Kapitel werden wir objektorientiert: Klassen und Objekte.