C# CSharp Programmierung fortgeschrittene Techniken – Von Variablen zu Azure Cloud Techniken.

Eine schnelle Einführung in die Programmierung mit C# von einfachen Beginner-Steps hin zu Azure-Cloud-Techniken.

Hier findest du alle Techniken und Methoden, um schnell C#-Programmierung zu lernen.

Wenn du bereits eine Programmiersprache beherrscht oder die einfachsten Beispiele verstehst, dann wirst du hier schnell und zeitsparend C# erlernen, ggf. auch an ein oder zwei Nachmittagen.

Allerdings solltest Du bereits mit einer Entwicklungsumgebung umgehen können.
Für C# empfehlen wir Visual Studio oder Visual Studio Code ( Linux etc)

Ich habe diese Seite erstellt, damit ich innerhalb von wenigen Minuten alle wichtigen Techniken erneut wiederholen und lernen kann. Daher ist es kein perfektes


Wenn du ein gutes Lernbuch benötigst, dann empfehlen wir dir:

C# und .NET 8 – Grundlagen, Profiwissen und Rezepte : Gebundene Ausgabe – 10. Mai 2024

Dieser Link führt Dich zu Amazon.de

Einführung in C#

C# (ausgesprochen „C-Sharp“) ist eine objektorientierte Programmiersprache, die von Microsoft entwickelt wurde. Sie wurde als Teil des .NET-Frameworks geschaffen und bietet Entwicklern eine einfache und leistungsstarke Sprache, die sowohl für Desktop- als auch Webanwendungen verwendet werden kann.

Auch für Linux-Anwender kann C# ein tolles Werkzeug sein, auch wenn es ungewöhnlich erscheint.
In der Webentwicklung immer weniger wegzudenken.

1. Variablen in C#

Variablen sind Platzhalter für Daten. Bevor du eine Variable in C# verwendest, musst du sie deklarieren und ihr einen Datentyp zuweisen. Die gängigsten Datentypen sind:

• int (Ganzzahlen)
• float (Gleitkommazahlen mit einfacher Genauigkeit)
• double (Gleitkommazahlen mit doppelter Genauigkeit)
• char (Einzelne Zeichen)
• string (Text oder Zeichenfolgen)
• bool (Wahrheitswerte: true oder false)

Ein Beispiel zur Deklaration und Initialisierung einer Variablen:

int alter = 25; // Eine Variable vom Typ "int" mit dem Namen "alter" und dem Wert 25 

string name = "Max"; // Eine Zeichenfolge mit dem Namen "name" 

bool istProgrammierer = true; // Ein boolescher Wert

Du solltest hier in der Lage sein per Copy und Paste die Daten in deine Entwicklungsumgebung zu kopieren.
Wenn du hier zum Start eine Ausgabe benötigst, kannst Du dies mit
Console.WriteLine(name); erzwingen oder Console.WriteLine(„Der Name lautet wie folgt: “ + name);

2. Operatoren in C#

C# verwendet verschiedene Operatoren, um Berechnungen durchzuführen oder Werte zu vergleichen. Die wichtigsten Kategorien sind:

• Arithmetische Operatoren: + (Addition), – (Subtraktion), * (Multiplikation), / (Division), % (Modulus)
• Vergleichsoperatoren: == (gleich), != (ungleich), > (größer als), < (kleiner als), >= (größer oder gleich), <= (kleiner oder gleich)
• Logische Operatoren: && (und), || (oder), ! (nicht)

Ein Beispiel mit Operatoren:

int a = 5; 
int b = 3; 
int summe = a + b; // Ergebnis ist 8 
bool ergebnis = (a > b); // Ergebnis ist true

3. Kontrollstrukturen

Kontrollstrukturen steuern den Fluss des Programms basierend auf bestimmten Bedingungen.

if-Anweisung:
Prüft eine Bedingung und führt Code aus, wenn diese Bedingung wahr ist.

if (alter > 18) 
{ 
Console.WriteLine("Du bist volljährig auf IRC-Mania.de unterwegs!"); 
}

else if und else: Ergänzt die if-Anweisung, um alternative Aktionen zu ermöglichen.

if (alter > 18)
{
    Console.WriteLine("Du bist volljährig auf IRC-Mania.de unterwegs!");
}
else if (alter == 18)
{
    Console.WriteLine("Du bist gerade 18 geworden.");
}
else
{
    Console.WriteLine("Du bist minderjährig.");
}

while-Schleife: Wiederholt eine Anweisung, solange die Bedingung wahr ist.

int count = 0;
while (count < 5)
{
    Console.WriteLine("Count ist: " + count);
    count++;
}

4. C# Schleifen

for-Schleife:
Eine Schleife, die oft verwendet wird, wenn die Anzahl der Durchläufe vorher feststeht.

for (int i = 0; i < 5; i++)
{
    Console.WriteLine("i ist: " + i);
}

foreach-Schleife:

Durchläuft jedes Element in einer Sammlung (wie Arrays oder Listen).

string[] namen = { "Dennis", "Schutzgeist", "IRC" };
foreach (string n in namen)
{
    Console.WriteLine(n);
}

Do-While-Schleife:

Die do-while-Schleife führt den Codeblock mindestens einmal aus, bevor die Bedingung am Ende überprüft wird. Sie wird verwendet, wenn du sicherstellen möchtest, dass der Code mindestens einmal ausgeführt wird.

int i = 0;

do
{
    Console.WriteLine("i ist: " + i);
    i++;
} 
while (i < 5);

In diesem Beispiel wird der Wert von i ausgegeben, und dann wird i um 1 erhöht. Die Schleife läuft so lange weiter, bis i den Wert 5 erreicht. Auch wenn die Bedingung zu Beginn nicht erfüllt wäre, würde der Code im do-Block mindestens einmal ausgeführt.

For-Schleife:

for (int j = 0; j < 5; j++)
{
    Console.WriteLine("j ist: " + j);
}

Erklärung: Hier wird die Schleife 5 Mal durchlaufen. Die Schleife beginnt bei j = 0, und in jedem Durchlauf wird j um 1 erhöht, bis j den Wert 5 erreicht. Während jedes Durchlaufs wird der aktuelle Wert von j ausgegeben.

Switch-Case:

Der switch-case-Block wird verwendet, um den Wert einer Variablen mit mehreren möglichen Werten zu vergleichen und je nach Übereinstimmung einen bestimmten Code auszuführen.

int tag = 3;

switch (tag)
{
    case 1:
        Console.WriteLine("Montag");
        break;
    case 2:
        Console.WriteLine("Dienstag");
        break;
    case 3:
        Console.WriteLine("Mittwoch");
        break;
    case 4:
        Console.WriteLine("Donnerstag");
        break;
    case 5:
        Console.WriteLine("Freitag");
        break;
    default:
        Console.WriteLine("Wochenende");
        break;
}

5. c# CSharp Methoden

Methoden in C# sind Codeblöcke, die bestimmte Aufgaben ausführen. Sie werden verwendet, um den Code übersichtlich und wiederverwendbar zu machen. Eine Methode hat einen Rückgabewert, einen Namen und kann Parameter annehmen.

// Eine Methode, die zwei Zahlen addiert und das Ergebnis zurückgibt
int Addiere(int zahl1, int zahl2)
{
    return zahl1 + zahl2;
}

// Aufruf der Methode
int ergebnis = Addiere(3, 4);  // Ergebnis ist 7

Methoden können auch void sein, was bedeutet, dass sie keinen Wert zurückgeben:

void Begruessung(string name)
{
    Console.WriteLine("Hallo, " + name);
}

// Aufruf der Methode
Begruessung("Schutzgeost");

6. Klassen und Objekte

class Person
{
    public string name;
    public int alter;

    public void Begruessung()
    {
        Console.WriteLine("Hallo, ich bin " + name + " und ich bin " + alter + " Jahre alt.");
    }
}

// Ein Objekt der Klasse "Person" erstellen
Person person1 = new Person();
person1.name = "Max";
person1.alter = 25;
person1.Begruessung();

7. Vererbung

Vererbung ist ein wichtiges Konzept in der objektorientierten Programmierung. Sie erlaubt es, eine neue Klasse zu erstellen, die die Eigenschaften und Methoden einer bestehenden Klasse erbt.
Die Basis– (oder Eltern-) Klasse stellt allgemeine Funktionen bereit, während die abgeleitete (oder Kind-) Klasse spezialisierte Funktionen hinzufügen oder ändern kann.

// Basisklasse (Elternklasse)
class Tier
{
    public string Name;

    public void MachGeräusch()
    {
        Console.WriteLine(Name + " macht ein Geräusch.");
    }
}

// Abgeleitete Klasse (Kindklasse)
class Hund : Tier
{
    public void Wedeln()
    {
        Console.WriteLine(Name + " wedelt mit dem Schwanz.");
    }
}

// Ein Objekt der abgeleiteten Klasse
Hund meinHund = new Hund();
meinHund.Name = "Bello";
meinHund.MachGeräusch();  // Ausgabe: Bello macht ein Geräusch.
meinHund.Wedeln();        // Ausgabe: Bello wedelt mit dem Schwanz.

In diesem Beispiel erbt die Klasse Hund die Methode MachGeräusch von der Klasse Tier und fügt ihre eigene Methode Wedeln hinzu.

8. Polymorphismus

c# Polymorphismus Beispiel

// Basisklasse
class Tier
{
    public string Name;

    // Virtuelle Methode kann in abgeleiteten Klassen überschrieben werden
    public virtual void MachGeräusch()
    {
        Console.WriteLine(Name + " macht ein allgemeines Geräusch.");
    }
}

// Abgeleitete Klasse
class Hund : Tier
{
    // Überschreiben der Methode in der abgeleiteten Klasse
    public override void MachGeräusch()
    {
        Console.WriteLine(Name + " bellt.");
    }
}

// Abgeleitete Klasse
class Katze : Tier
{
    public override void MachGeräusch()
    {
        Console.WriteLine(Name + " miaut.");
    }
}

// Polymorphismus in Aktion
Tier meinTier = new Hund();
meinTier.Name = "DasTier";
meinTier.MachGeräusch();  // Ausgabe: DasTier bellt.

meinTier = new Katze();
meinTier.Name = "Mieze";
meinTier.MachGeräusch();  // Ausgabe: Mieze miaut.

Hier haben wir die Methode MachGeräusch in der Basisklasse Tier als virtual deklariert, und in den abgeleiteten Klassen Hund und Katze haben wir diese Methode überschrieben. Der Polymorphismus ermöglicht es, dass dieselbe Methode je nach Objekt unterschiedlich funktioniert.

9. C# Interfaces

C# C-Sharp Beispiel für ein Interface:

// Interface
interface IFahrzeug
{
    void Fahren();
}

// Klasse, die das Interface implementiert
class Auto : IFahrzeug
{
    public void Fahren()
    {
        Console.WriteLine("Das Auto fährt.");
    }
}

// Klasse, die das Interface implementiert
class Fahrrad : IFahrzeug
{
    public void Fahren()
    {
        Console.WriteLine("Das Fahrrad fährt.");
    }
}

// Interface in Aktion
IFahrzeug meinFahrzeug = new Auto();
meinFahrzeug.Fahren();  // Ausgabe: Das Auto fährt.

meinFahrzeug = new Fahrrad();
meinFahrzeug.Fahren();  // Ausgabe: Das Fahrrad fährt.

Interfaces erlauben es, eine Art Vertrag für die implementierenden Klassen vorzugeben, ohne festzulegen, wie die Methoden umgesetzt werden sollen. Dies ist besonders nützlich, wenn du sicherstellen willst, dass bestimmte Klassen spezifische Funktionen haben, ohne sich auf eine Vererbungshierarchie festzulegen.

10. C# Delegates

Ein Delegate ist ein Typ, der einen Verweis auf eine Methode speichert. Delegates ermöglichen das dynamische Zuweisen und Ausführen von Methoden während der Laufzeit. Dies ist besonders nützlich für Ereignisse oder Callback-Mechanismen.

// Definition des Delegates
public delegate void BegruessungsDelegate(string name);

// Methode, die den Delegate verwendet
public void Begruessung(string name)
{
    Console.WriteLine("Hallo, " + name);
}

// Zuweisung und Aufruf des Delegates
BegruessungsDelegate meinDelegate = new BegruessungsDelegate(Begruessung);
meinDelegate("Schutzgeist");  // Ausgabe: Hallo, Schutzgeist