Jeder kann coden / Programmieren & TicTacToe / C# Einführung / Funktionen Grundlagen
Prozeduren, Funktionen und Methoden in C#¶
|
|
|
Link zur Microsoft Dokumentation Link zum roten Faden auf Miro Link zu Tutorial auf w3schools |
In C# sind Prozeduren und Funktionen spezielle Arten von Methoden, die in Klassen oder Strukturen definiert werden. Der Unterschied zwischen Prozeduren und Funktionen liegt im Rückgabewert:
- Prozedur: Eine Methode, die keinen Rückgabewert hat (definiert mit
void). - Funktion: Eine Methode, die einen Rückgabewert hat.
Methodensignaturen¶
Eine Methodensignatur definiert den Namen, die Parameter und den Rückgabewert einer Methode. Sie ist eindeutig, wenn:
- Der Name der Methode
- Die Anzahl der Parameter
- Die Reihenfolge und Typen der Parameter
Codebeispiel (Umweltinformatik – Berechnung des CO₂-Fußabdrucks):
public class CO2Berechnung
{
// Methode ohne Rückgabewert (Prozedur)
public void Begrüßung()
{
Console.WriteLine("Willkommen zur CO₂-Fußabdruck-Berechnung!");
}
// Methode mit Rückgabewert (Funktion)
public double BerechneEmissionen(double streckeInKm, double emissionsFaktor)
{
// Signatur: BerechneEmissionen(double, double) : double
return streckeInKm * emissionsFaktor;
}
}
Methodenzugriff¶
Methoden können mit Zugriffsmodifizierern definiert werden:
- public: Zugriff von überall.
- private: Zugriff nur innerhalb der gleichen Klasse.
- protected: Zugriff in der gleichen Klasse und abgeleiteten Klassen.
- internal: Zugriff innerhalb der gleichen Assembly.
- protected internal: Mischung aus
protectedundinternal.
Beispiel:
public class CO2Berechnung
{
private double emissionsFaktor = 0.21; // nur innerhalb der Klasse sichtbar
public double BerechneEmissionen(double streckeInKm)
{
return streckeInKm * emissionsFaktor; // Zugriff auf private Variable
}
}
Methodenparameter und Argumente¶
Methoden können Parameter enthalten, die bei ihrem Aufruf mit Werten (Argumenten) belegt werden.
Beispiel:
public double BerechneEmissionen(double streckeInKm, double emissionsFaktor)
{
return streckeInKm * emissionsFaktor;
}
// Aufruf
double ergebnis = BerechneEmissionen(100, 0.21);
Übergeben nach Wert und Übergeben nach Verweis¶
- Nach Wert (by value): Standardverhalten, der Wert wird kopiert.
- Nach Verweis (by reference): Übergabe eines Verweises auf die ursprüngliche Variable mit
refoderout.
Beispiel:
public void ÄndereWert(ref double emissionsFaktor)
{
emissionsFaktor = 0.25; // Originalvariable wird geändert
}
Rückgabewerte¶
Eine Methode kann:
- Keinen Rückgabewert haben (
void). - Einen Wert zurückgeben (z. B.
int,double,string).
Beispiel:
public double BerechneEmissionen(double streckeInKm, double emissionsFaktor)
{
return streckeInKm * emissionsFaktor;
}
Asynchrone Methoden¶
Asynchrone Methoden erlauben es, langlaufende Operationen nicht-blockierend auszuführen, z. B. Daten von einer API abrufen.
Beispiel (Daten von einer Umwelt-API abrufen):
using System.Net.Http;
using System.Threading.Tasks;
public async Task<double> LadeEmissionsFaktorAsync()
{
HttpClient client = new HttpClient();
string response = await client.GetStringAsync("https://api.umweltinfo.de/emissionsfaktor");
return double.Parse(response); // Beispielwert
}
Ausdruckstextdefinitionen¶
Kurzform für einfache Methoden, die eine Berechnung oder Rückgabe durchführen.
Beispiel:
public double BerechneEmissionen(double streckeInKm, double emissionsFaktor) => streckeInKm * emissionsFaktor;
Iterators¶
Iterators erlauben das schrittweise Durchlaufen von Elementen (z. B. mit yield return).
Beispiel:
public IEnumerable<double> Emissionsfaktoren()
{
yield return 0.21; // Auto
yield return 0.05; // Zug
yield return 0.12; // Flugzeug
}
Gesamtbeispiel¶
Code zur Berechnung und Iteration von CO₂-Emissionen:
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Threading.Tasks;
public class CO2Berechnung
{
public void Begrüßung()
{
Console.WriteLine("Willkommen zur CO₂-Fußabdruck-Berechnung!");
}
public double BerechneEmissionen(double streckeInKm, double emissionsFaktor) => streckeInKm * emissionsFaktor;
public async Task<double> LadeEmissionsFaktorAsync()
{
HttpClient client = new HttpClient();
string response = await client.GetStringAsync("https://api.umweltinfo.de/emissionsfaktor");
return double.Parse(response);
}
public IEnumerable<double> Emissionsfaktoren()
{
yield return 0.21; // Auto
yield return 0.05; // Zug
yield return 0.12; // Flugzeug
}
}
class Program
{
static async Task Main(string[] args)
{
CO2Berechnung co2Berechnung = new CO2Berechnung();
co2Berechnung.Begrüßung();
double strecke = 100; // 100 km
double emissionsFaktor = 0.21; // Auto
Console.WriteLine($"Emissionen: {co2Berechnung.BerechneEmissionen(strecke, emissionsFaktor)} kg CO₂");
double apiFaktor = await co2Berechnung.LadeEmissionsFaktorAsync();
Console.WriteLine($"Lade Emissionsfaktor von API: {apiFaktor}");
Console.WriteLine("Verfügbare Emissionsfaktoren:");
foreach (double faktor in co2Berechnung.Emissionsfaktoren())
{
Console.WriteLine($"- {faktor} kg/km");
}
}
}
Cheatsheet zu funktionaler Programmierung in C#¶
