Lernen durch Erklären: Mein Weg mit C# – Eine Tutorial-Reihe für Einsteiger

Mein Weg mit C# und Spieleentwicklung

Hallo zusammen,

ich habe mich entschlossen, meinen Weg beim Lernen von C# hier im Forum festzuhalten - nicht nur für mich selbst, sondern vielleicht auch für andere, die gerade anfangen oder ähnliche Hürden haben wie ich.

Ich möchte irgendwann eigene Spiele programmieren - richtig mit Unity. Aber mir ist klar geworden: Ohne solide Grundlagen in der Sprache selbst bringt das nichts. Ich will verstehen, wie Programmieren wirklich funktioniert, nicht nur irgendwas hinklicken oder Code abschreiben, den ich nicht verstehe.

In dieser Beitragsreihe schreibe ich deshalb alles mit, was ich beim Lernen von C# verstehe - oder erstmal nicht verstehe. Ich teile, wie ich mir Wissen aufbaue, wo ich scheitere, was mir hilft und wie ich die Theorie in echte Anwendungen bringe. Das Ganze soll wie ein offenes Lerntagebuch funktionieren - mir kleinen Beispielen, Erklärungen in meinen eigenen Worten und vielleicht sogar eigene Mini-Projekte.

Wenn du auch gerade C# lernst, vielleicht für Unity oder ein anderes Ziel, dann bist du hier herzlich willkommen mitzulesen, mitzulernen oder mitzumachen. Ich freue mich über Feedback, Ergänzungen oder Fragen - und vielleicht motivieren wir uns ja gegenseitig.

Es gibt zu diesem Tutorial auch eine YouTube Playlist auf meinem Kanal:

Also, los geht's: Lernen durch Erklären. Schritt für Schritt.

Inhaltsverzeichnis

Hier findest du eine Übersicht über alle Kapitel und Beiträge in dieser Reihe. Ich aktualisiere die Liste regelmäßig.

Kaptiel 3 - Was ist C#? Eine Einführung für Einsteiger

Heute möchte ich ein bisschen darüber schreiben, was C# eigentlich ist, wo es herkommt und warum ich mich dafür entschieden habe. Ich selbst wusste anfangs gar nicht, wie viele Dinge mit C# gemacht werden - von Spiele über Apps bis hin zu Webanwendungen.

C# in einfachen Worten

C# (sprich: C-Sharp) ist eine moderne, objektorientierte Programmiersprache, die von Microsoft entwickelt wurde. Sie wird hauptsächlich verwendet für:

• Windows Anwendungen
• Spiele (z.B. in Unity)
• Webanwendungen (mit ASP.NET)
• Tools, Automatisierungen und mehr

Sie ist stark verwandt mit Sprachen wie Java oder C++, aber deutlich einfacher zu lesen und zu schreiben.

Was macht C# besonders?

• Stark typisiert - du sagst genau, welche Art von Daten du verwendest.
• Objektorientiert - du arbeitest mit Klassen und Objekten.
• Sicher & robust - viele Fehler werden vom Compiler abgefangen.
• Teil der .NET-Plattform - du kannst riesige Bibliotheken nutzen (z.B für Grafiken, Daten, Netzwerk...).

Was brauchst du, um C# zu schreiben?

Eine Entwicklungsumgebung (IDE) - am besten:

• Visual Studio (kostenlos, direkt von Microsoft)
• Ein Projekt-Typ: Für den Anfang reicht ein simples "Konsolenprojekt" - also Programme, die in einem schwarzen Textfenster laufen (wie ein kleines Terminal-Spiel oder ein Rechner.

Wie sieht C# Code aus?

Ein einfaches Beispiel:

using System;

class Programm
{
	static void Main(string[] args)
	{
		Console.WriteLine("Hallo Welt!");
	}
}

Erklärung:

• using System;
  • holt das Grundzeug rein, das du brauchst(z.B. Console)
• class Programm
  • du definierst eine Klasse (mehr dazu bald)
• static void Main (...)
  • Startpunkt deines Programms
• Console.WriteLine(...)
  • schreibt Text auf dem Bildschirm

Videomaterial

Kapitel 4 - Variablen & Datentypen in C#

In diesem Kapitel lerne ich, was Variablen sind, welche Datentypen es in C# gibt, wie man sie richtig deklariert und verwendet - und warum sie so wichtig sind. Das Ziel: Nicht nur wissen, was sie tun, sondern verstehen, wie man sie sicher nutzt.

Was ist eine Variable überhaupt?

Eine Variable ist ein bekannter Speicherplatz, der einen bestimmten Datentyp enthält. Sie speichert z.B. Zahlen, Texte oder Wahr/Falsch-Werte. Man kann sie jederzeit lesen oder neue Werte zuweisen.

Merksatz: Eine Variable ist wie eine beschriftete Kiste - man weiß, was drin ist, und kann den Inhalt austauschen.

Warum braucht man Variablen?

Ohne Variablen kannst du keine Daten speichern, keine Berechnungen machen, keine Logik umsetzen. Beispiele:

• Punktestand speichern
• Name des Spielers
• Lebensanzeige
• "Ist-Spiel-gestartet" - Status

So deklariert man eine Variable in C#

<Datentyp> <Name> = <Wert>

Beispiel:

int punkte = 100;
string name = "Nico";
bool istSpielGestartet = true;

Erklärung:

int - Ganzzahl

punkte - Name der Variable

100 - Wert, der gespeichert wird

Namensregeln für Variablen in C#:

Wichtige Datentypen in C#:

Hinweis: Manche Typen wie float, decimal oder long brauchen ein Suffix(f,m,L)!

Beispiel: Verschiedene Typen in Code:

using system;

class Program
{
	static void Main(string[] args)
	{
		int leben = 3;
		float geschwindigkeit = 4.5f;
		bool istGameOver = false;
		string spielerName = "Nico";
		char taste = 'W';
		decimal = 19.99m;
		
		Console.WriteLine("Spieler: " + spielerName);
		Console.WriteLine("Leben: " + leben);
		Console.WriteLine("Geschwindigkeit: " + geschwindigkeit);
		Console.WriteLine("Taste gedrückt: " + taste);
		Console.WriteLine("Game Over? " + istGameOver);
		Console.WriteLine("Kontostand: " + kontostand + "€");
	}
}

Typische Anfängerfehler:

Videomaterial

Kapitel 5 - Kommentare & Codeblöcke

In diesem Kapitel beschäftige ich mich mit den Grundlagen, die für alle weiteren Programmierkonzepte wichtig sind: Kommentare, also wie man im Code Notizen hinterlässt und Blöcke, also wie man Anweisungen sauber zusammenfasst. Klingt einfach - aber ohne das geht in größeren Projekten bald alles drunter und drüber.

Kommentare

Ein Kommentar ist eine Textzeile im Code, die vom Computer ignoriert wird. Sie dient nur mir selbst, damit ich verstehe, was ein bestimmtet Abschnitt macht.

Arten von Kommentare

// Das ist ein Kommentar - einzeilig

/*
	Das ist ein 
	mehrzeiliger Kommentar
*/ 

Kommentare haben keinerlei Auswirkungen auf die Ausführung des Programms. Sie helfen mir aber beim Verstehen, Erklären und Strukturieren meines Codes.

Alltagsbeispiel

// Berechnung des Grundpreises
double grundpreis = 10.0;
double steuer = 1.9;
double gesamt = grundpreis + steuer; // Gesamtpreis = 11.9

Console.WriteLine(gesamt);

Spiele-Beispiel

// Spielpunktestand
int punkte = 100;
int bonus = 50;
int endstand = punkte + bonus;

Console.WriteLine(endstand); // Ausgabe: 150

Codeblöcke

Ein Block ist ein abgeschlossener Bereich in geschweiften Klammern {}. Darin kann ich mehrere Anweisungen zusammenfassen.

{
	// Dies ist ein Beispiel
	string name = "Nico";
	Console.WriteLine("Spielername: " + name); 
}

Wichtig zu wissen: Variablen, die im Block deklariert sind, gelten nur darin. Blöcke helfen, Code besser zu strukturieren.

Videomaterial

Kapitel 6 - Operatoren Teil 1: Rechnen & Zuweisung

Jetzt geht's los mit dem "echten Rechnen" im Code. In diesem Kapitel lerne ich, wie man mit C# rechnet, wie ich Werte in Variablen verändere und was dabei beachtet werden muss. Das sind Grundlagen für jede Spielmechanik oder Rechenlogik in einem Programm.

Arithmetische Operatoren

Diese Operatoren nutze ich, um mit Zahlen zu rechnen:

Wichtig: Wenn ich int / int rechne, gibt es nur ganze Zahlen! Beispiel: 5 / 2 = 2, NICHT 2.5!

Spiele-Beispiel:

int punkte = 100;
int bonus = 25;
int gesamt = punkte + bonus;

Console.WriteLine("Endpunktzahl: " + gesamt);

Alltagsbeispiel:

int apfelpreis = 2;
int anzahl = 5;

int gesamtpreis = apfelpreis * anzahl;
Console.WriteLine("Gesamt: " + gesamtpreis + " Euro");

Zuweisungsoperatoren

Zuweisung heißt, ich ändere den Wert einer Variable.

Spiele-Beispiel:

int leben = 3;
leben--; // Spieler verliert ein Leben

Console.WriteLine("Verbleibende Leben: " + leben);

Videomaterial

Kapitel 7 - Der bool-Typ und Wahrheitswerte

Jetzt lerne ich den Datentypen kennen, mit dem Programme Entscheidungen treffen können:

true = wahr

false = falsch

Mit dem bool-Typ lassen sich Zustände und Bedingungen abbilden - z.B. "ist das Spiel gewonnen?", "hat der Spieler noch Leben?", oder "wurde eine Eingabe korrekt verarbeitet?"

Was ist ein bool?

Ein bool-Wert kann nur zwei Zustände haben:

• true - etwas ist wahr
• false - etwas ist nicht wahr

Deklaration:

bool istSpielVorbei = false;
bool istGewonnen = true;

Man kann boolesche Variablen auch umschalten:

bool status = true;
status = !status; // Ergebnis: false (Negationsoperator "!") 

Kombiniert mit Vergleichen

Vergleichsoperationen (kommt später etwas ausführlicher) wie ==, !=, <, > usw. liefern immer ein bool zurück:

int leben = 3;
bool istSpielerTot = leben == 0; // false

Alltagsbeispiel:

int alter = 20;
bool istVolljaehrig = alter >= 18;

Console.WriteLine("Volljährig: " + istVolljaehrig); // Ausgabe: true 

Spiele - Beispiel:

int score = 500;
bool bonusAktiv = score >= 1000;

Console.WriteLine("Bonus aktiviert? " + bonusAktiv); // false

Videomaterial

Kapitel 8 - Vergleichs- & Logische Operatoren

In diesem Kapitel geht es darum, Bedingungen zu formulieren. Ich lerne:

• Mit Vergleichen zu prüfen, ob zwei Werte zueinander in Beziehung stehen.
• Mit logischen Verknüpfungen mehrere Bedingungen zusammenzufassen.
• So den Grundstein für spätere Entscheidungen wie if, while usw. zu legen.

Vergleichsoperatoren

Diese Operatoren vergleichen zwei Werte und geben ein bool (true/false) zurück:

Diese Vergleiche liefern also immer ein Wahrheitswert (bool).

Alltagsbeispiel:

int alter = 17;
bool istVolljaehring = alter >= 18;

Console.WriteLine("Volljährig: " + istVolljaehring); // false

Logische Operatoren

Jetzt kann ich mehrere Bedingungen miteinander verknüpfen:

Kombinieren von Bedingungen:

int alter = 20;
bool ausweisVorhanden = true;

bool darfRein = alter >= 18 && ausweisVorhanden;
Console.WriteLine("Einlass erlaubt: " + darfRein); //true

Spiele-Beispiel:

int leben = 1;
bool schildAktiv = false;

bool istVerwundbar = leben <= 1 && !schildAktiv;
Console.WriteLine("Verwundbar: " + istVerwundbar); // true

Videomaterial:

Kapitel 9 - Entscheidungen treffen mit if, else und if else

Mit if-Anweisungen bringe ich dem Programm bei, Entscheidungen zu treffen, z.B:

• Wenn eine Bedingung erfüllt ist ---> mache X
• Sonst ---> mache Y
• Mehrere Bedingungen nacheinander prüfen

Das ist das Fundament jeder Programmsteuerung - ob im Spiel, in Tools oder in Apps.

Die Grundform von if

if(Bedingung)
{
	// Wird nur ausgeführt, wenn Bedingung true ist
}

Beispiel:

int alter = 20;

if(alter >= 18)
{
	Console.WriteLine("Du bist volljährig.");
}

if + else

if(alter >= 18)
{
	Console.WriteLine("Du bist volljährig.");
} else {
	Console.WriteLine("Du bist noch nicht volljährig.");
}

else if

int punkte = 80;

if(punkte >= 90)
{
	Console.WriteLine("Note: Sehr gut");
} else if(punkte >= 75) 
{
	Console.WriteLine("Note: Gut");
} else 
{
	Console.WriteLine("Note: Ausbaufähig");
}

Wichtig: Bedingungen brauchen bool!

Nur Ausdrücke, die true oder false ergeben, sind erlaubt:

int leben = 0;

if(leben == 0) // richtig
{
	Console.WriteLine("Game Over!");
}

Alltagsbeispiel:

int temperatur = 30;

if(temperatur > 25)
{
	Console.WriteLine("Es ist heiß!");
} 
else 
{
	Console.WriteLine("Es ist angenehm.");
}

Spiele-Beispiel:

int leben = 0;

if(leben <= 0)
{
	Console.WriteLine("Spieler ist tot!");
} else 
{
	Console.WriteLine("Spieler lebt noch");
}

Kurzform: Ternärer Operator ? :

Die Kurzschreibweise von if ist die sogenannte ternäre Bedingung - sie ist kompakt, aber oft nur für einfache Entscheidungen gedacht.

Aufbau:

Bedingung ? AusdruckWennTrue : AusdruckWennFalse;

Beispiel:

int alter = 20;
string status = alter >= 18 ? "Volljährig" : "Nicht volljährig";

Console.WriteLine(status); // Ausgabe: Volljährig

... das ganze entspricht also genau diesem if:

int alter = 20;
string status;

if(alter >= 18)
{	
	status = "Volljährig";
	Console.WriteLine(status);
} 
else 
{
	status = "Nicht volljährig";
	Console.WriteLine(status);
}

Videomaterial:

Kapitel 10 - Entscheidungen mit switch

In diesem Kapitel habe ich mir angeschaut, wie ich mehrere Möglichkeiten übersichtlich abfragen kann. Mit if und else if geht das zwar, aber es wird bei vielen Bedingungen schnell unübersichtlich. Dafür gibt es switch. Damit kann ich ganz gezielt einen Wert prüfen und passende Aktionen ausführen lassen.

Grundaufbau von switch

switch(VariableOderAusdruck)
{
	case Wert1:
	// Wird ausgeführt, wenn Variable den Wert1 hat
		break;
	case Wert2:
	// Wird ausgeführt, wenn Wert2 zutrifft
		break;
	default:
	// Wird ausgeführt, wenn kein anderer Fall passt
		break;
}

Wichtig:

break; beendet den jeweiligen Fall.

default: ist wie ein "Auffangnetz" - wird genommen, wenn keiner der case's passt.

Beispiel:

string waffe = "Stab";

switch (waffe)
{
	case "Schwert":
	Console.WriteLine("Du kämpfst mit dem Schwert!");
	break;
	
	case "Bogen":
	Console.WriteLine("Du schießt mit dem Bogen!");
	break;
	
	case "Stab":
	Console.WriteLine("Du zauberst mit dem Stab!");
	break;
	
	default:
	Console.WriteLine("Unbekannte Waffe.);
	break;
}

Das Programm prüft, was in der Variable waffe steht und führt dann den passenden Codeblock aus.

Ein weiteres Beispiel aus der Spiele-Welt:

int level = 5;

switch(level)
{
	case 1:
	Console.WriteLine("Willkommen, Anfänger!");
	break;
	
	case 5:
	Console.WriteLine("Du bist ein erfahrener Spieler!");
	break;
	
	case 10:
	Console.WriteLine("Wow, du bist ein Meister!");
	
	default:
	Console.WriteLine("Level nicht erkannt.");
	break;
}

Mehrere Fälle zusammenfassen

Ich kann auch mehrere case's zusammenlegen, wenn sie das Gleiche tun sollen:

int stufe = 2;

switch (stufe)
{
	case 1:
	case 2:
	case 3:
		Console.WriteLine("Noch ganz am Anfang.");
		break;
	
	default:
		Console.WriteLine("Schon fortgeschritten!");		
}

Das spart Code und bleibt übersichtlich.

Videomaterial:

Kapitel 11 - Schleifen - Wiederholungen im Code steuern

In diesem Kapitel lerne ich etwas unglaublich Wichtiges: Wie kann mein Programm Aufgaben wiederholen - ohne Copy & Paste?

Statt fünfmal hintereinander Console.WriteLine() zu schreiben, kann ich das automatisch machen lassen. Ich sage dem Programm also: "Solange diese Bedingung gilt, mach das hier immer wieder."

Das spart nicht nur Zeit, sondern ist auch die Grundlage für:

• Spielrunden
• Wiederholungen in Dialogen
• Versuche bei Eingaben
• Punkte hochzählen
• und alles, was sich mehrfach wiederholt

Die drei Grundtypen von Schleifen

while-Schleife

Die while-Schleife prüft zuerst die Bedingung - und läuft nur, wenn sie true ist.

int i = 0;

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

Wichtig:

• Die Bedingung steht am Anfang
• Wenn sie nie falsch wird, läuft die Schleife ewig (Endlosschleife)

do-while-Schleife

Der Unterschied zu while:

Hier wird der Schleifenblock mindestens einmal ausgeführt, weil die Bedingung erst danach geprüft wird.

int i = 0;

do 
{
	Console.WriteLine("Wert: " + i);
	i++;
} while ( i < 3);

for - Schleife

Wenn ich weiß, wie oft etwas wiederholt werden soll, ist for ideal.

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

Die for-Schleife besteht aus 3 Teilen:

1. Startwert ---> int i = 1
2. Bedingung ---> i <= 5
3. Veränderung ---> i++;

Alltagsbeispiel:

int etage = 1;

while(etage <= 5)
{
	Console.WriteLine("Fahrstuhl hält in Etage: " + etage);
	etage++;
}

Der Fahrstuhl hält von Etage 1 bis 5 automatisch an - kein Copy & Paste nötig.

Spiele-Welt Beispiel:

int leben = 3;

do 
{
	Console.WriteLine("Autsch! Du wurdest getroffen!");
	leben--;
} while (leben > 0);

Console.WriteLine("Game Over!");

Videomaterial

Kapitel 12 - Arrays

In diesem Kapitel beschäftige ich mich mit Arrays - einer Möglichkeit, mehrere Werte desselben Typs unter einem gemeinsamen Namen zu speichern. Statt viele einzelne Variablen zu verwenden, kann ich mit einem Array z.B. mehrere Zahlen oder Namen übersichtlich verwalten. Jeder Wert im Array hat einen festen Platz, der über einen Index angesprochen wird - beginnend bei 0.

Ich lerne, wie man Array deklariert, mit Werten füllt und mit Schleifen durchläuft. Besonders praktisch ist dabei die foreach-Schleife, mit der ich alle Elemente bequem nacheinander abarbeiten kann. Arrays haben eine feste Länge und eignen sich gut, wenn ich vorher weiß, wie viele Daten ich speichern möchte - etwa bei Notenlisten, Punktestände oder Spielstände.

Was ist ein Array?

Ein Array ist eine Sammlung von Elementen gleichen Typs. Die Werte haben feste Positionen, sogenannte Indizes, beginnend bei 0.

int[] noten = {2,1,3};
Console.WriteLine(noten[0]); // Ausgabe: 2

Merken:

• Die Zählung beginnt bei 0
• Die Länge des Arrays bekommt man mit .Length
• Der letzte gültige Index ist Length - 1.

Arrays durchlaufen

Ich kann alle Elemente mit einer for-Schleife durchgehen:

for(int i = 1; i < noten.Length; i++)
{
	Console.WriteLine(noten[i]);
}

oder bequemer mit foreach:

foreach(int note in noten)
{
	Console.WriteLine(note);
}

Alltagsbeispiel:

Ich möchte die Anzahl der Schritte speichern, die ich an drei Tagen gemacht habe und die Gesamtsumme berechnen:

int[] schritte = {5000,7200,8100};
int summe = 0;

foreach(int tag in schritte)
{
	summe += tag;
}

Console.WriteLine("Gesamtschritte in 3 Tagen: " + summe); // Ausgabe: 20300

Spiele-Beispiel:

Ein Array speichert die Lebenspunkte dreier Spieler. Ich prüfe, ob mindestens einer K.O. ist:

int[] leben = {100,80,0};

bool istJemandKO = leben[0] == 0 || leben[1] == 0 || leben[2] == 0;

Console.WriteLine("Mindestens ein Spieler ist K.O. : + istkemandKO); // true

Video sieht Kapitel 13

Kapitel 13 - Mehrdimensionale Arrays

In diesem Kapitel lerne ich, wie man mit mehrdimensionalen Arrays arbeitet - also mit Daten, die wie in einer Tabelle in Zeilen und Spalten angeordnet sind. So kann ich z.B. Spielbretter, Punktelisten oder Temperaturen-Tabellen programmieren.

Um auf die Werte zuzugreifen, braucht man zwei Indizes - einen für die Zeile, einen für die Spalte. Neu für mich ist dabei, wie man solche Strukturen mit verschachtelten Schleifen verarbeitet: Die äußere Schleife läuft über die Zeilen, die innere über die Spalten. Das sieht zuerst etwas komplex aus, macht aber schnell Sinn, sobald man versteht, dass jede Zeile eine eigne kleine Schleife über ihre Spalten braucht.

Außerdem habe ich verstanden, wie leicht man sich bei den Indizes vertun kann - z.B. wenn man denkt, 2 sei der dritte Wert, obwohl der Index 2 schon außerhalb liegen kann. Deshalb ist es wichtig, beim Durchlauf die richtigen Grenzen zu verwenden.

Was ist ein mehrdimensionales Array?

Ein zweidimensionales Array ist wie eine Tabelle mit Zeilen und Spalten. Ich kann es auf zwei Arten erstellen:

1. Direkt mit Werten ( ohne new )

int[,] feld = 
{
	{1,2,3},
	{4,5,6}
};

Das ist die einfachste und bisher für mich passendste Methode: Ich schreibe die Werte direkt hinein - Zeile für Zeile, wie in einer Tabelle. Das geht, wenn ich die Werte beim Anlegen schon kenne.

2. Mit new - wenn ich nur die Größe angeben will:

int[,] feld = new int[2,3];

Was passiert hier?

• Das Schlüsselwort new bedeutet: "Erzeuge ein neues Array."
• In diesem Fall sage ich: "Mach mir ein zweidimensionales Array mit 2 Zeilen und 3 Spalten."
• Die Werte darin sind erst einmal alle automatisch auf 0 gesetzt.

Ich kann später Werte wie folgt eintragen:

feld[0,0] = 5;
feld[1,2] = 9;

und wieder auslesen mit:

Console.WriteLine(feld[1,2]); // Ausgabe: 9

Warum brauche ich new manchmal?

Manchmal weiß ich beim Start noch nicht, welche Werte ins Array kommen - aber wie viele Plätze ich brauche, das weiß ich. Dann kann ich das Array mit new vorbereiten und später mit Werten füllen.

Wichtiger Hinweis:

Das Schlüsselwort new ist ein zentrales Konzept in C#. Später wirst du es auch bei Klassen, Objekten, Strings und vielen anderen Dingen brauchen. In diesem Kapitel lernst du es ganz konkret im Zusammenhang mit Arrays kennen. Wie new im Hintergrund funktioniert, behandeln wir später ausführlich, sobald es um Speicher, Objekte und Konstruktoren geht.

Mehrdimensionale Arrays durchlaufen

Damit ich alle Werte eines zweidimensionalen Arrays lesen oder verändern kann, brauche ich zwei Schleifen - eine für jede Dimension.

int[,] matrix =
{
	{1,2,3},
	{4,5,6}
};

for(int zeile = 0; zeile < 2; zeile++)
{
	for(int spalte = 0; spalte < 3; spalte++)
	{
		Console.WriteLine("Wert an [" + zeile + "," + spalte + "]: " + matrix[zeile,spalte]);
	}
}

Die äußere Schleife geht jede Zeile durch. Für jede Zeile startet die innere Schleife erneut und gibt alle Spalten dieser Zeile aus. Das Prinzip ist immer gleich: Zeile für Zeile, Spalte für Spalte.

Alltagsbeispiel:

int[,] temperaturen = 
{
	{15,16,17}, // Stadt 1
	{20,22,21}
};

Console.WriteLine("Tag 2, Stadt 2: " + temperaturen[1,1]); // Ausgabe: 22

Spiele-Beispiel:

char[,] spielfeld =
{
	{'X',' ' , 'O'},
	{' ','X' , ''},
	{'O',' ' , 'X'}
};

Console.WriteLine("Feld Mitte: " + spielfeld[1,1]); // Ausgabe: X

Fehlerquelle: Index außerhalb des Bereichs

Das hier führt zu einem Fehler:

int[,] zahlen = new int[2,2];
int x = zahlen[2,0]; // Fehler (IndexOutOfRangeException!)

Warum? Gültige Zeilen sind 0 und 1. Der Index 2 liegt außerhalb. Ein häufiger Fehler:

Man nimmt einen Wert aus einem anderen Array und nutzt ihn direkt als Index, ohne zu prüfen, ob er gültig ist - dass kann schnell zu einer IndexOutOfRangeExeception führen, auch wenn der Code formal richtig aussieht.

Besser vorher die Grenzen prüfen!

int zeilen = zahlen.GetLength(0); // Zeilenanzahl
int spalten = zahlen.GetLength (1); // Spaltenanzahl

Videomaterial:

Kapitel 14 - Benutzereingabe mit Console.ReadLine()

Zum Abschluss der Grundlagen bringe ich meinem Programm noch bei, mit dem Benutzer zu sprechen. Mit Console.ReadLine() kann ich Texteingaben einlesen - z.B. eine Zahl, einen Namen oder ein "Ja" oder "Nein".

Ich lerne:

• Wie man Eingaben vom Benutzer liest,
• Wie ich sie in passende Datentypen umwandelt (z.B. von string zu int)
• Wie ich diese Eingabe weiterverarbeite - z.B. mit Bedingungen oder in Arrays speichern kann.

So wird mein Programm interaktiv - ich bestimme nicht mehr alles im Code, sondern lasse den Benutzer entscheiden.

Was macht Console.ReadLine()?

string eingabe = Console.ReadLine();

Damit liest mein Programm eine komplette Zeile aus der Konsole ein - als string. Egal ob Zahl, Wort oder Satz - alles kommt erstmal als Zeichenkette rein.

Beispiel 1: Namen eingeben

Console.WriteLine("Wie heißt du?");
string name = Console.ReadLine();

Console.WriteLine("Hallo, " + name + "!");

Beispiel 2: Zahlen einlesen & umrechnen

Console.WriteLine("Wie alt bist du?");
string eingabe = Console.ReadLine();

int alter = Convert.ToInt32(eingabe);

if(alter >= 18)
{
	Console.WriteLine("Du bist volljährig");
}
else 
{
	Console.WriteLine("Du bist noch nicht volljährig.");
}

Hier lerne ich: Wenn ich mit Zahlen arbeiten will, muss ich den string umwandeln - z.B. mit Convert.ToInt32().

Kombi mit Arrays

Ich kann sogar mehrere Eingaben in ein Array packen:

string[] namen = new string[3];

for(int i = 0; i < namen.Length; i++)
{
	Console.WriteLine("Name " + (i + 1) + ": ");
	namen[i] = Console.ReadLine();
}

foreach(string name in namen)
{
	Console.WriteLine("Hallo, " + name + "!");
}

Videomaterial:

Kapitel 15 - Einstieg in die Objektorientierung

Was sind Klassen und Objekte - und warum brauche ich sie?

In diesem Kapitel beginnt für mich ein ganz neuer Abschnitt beim Programmieren:

Ich lerne, wie man in C# mit Klassen und Objekten arbeitet - dem Herzstück der sogenannten objektorientierten Programmierung (OOP). Bisher habe ich mit Variablen, Schleifen, Bedingungen und Arrays gearbeitet - alles in einer Datei, in der Main() Methode. Das reicht für kleine Tools und Übungen - aber wenn mein Programm wachsen soll, wirds schnell unübersichtlich.

Jetzt lerne ich, wie ich mein Programm strukturieren kann - indem ich mir eigene Bausteine erschaffe.

Was bedeutet "objektorientiert" überhaupt?

C# ist von Grund auf objektorientiert. Das heißt:

• In C# denkt man in Dingen, nicht nur in Zahlen und Variablen. Die Dinge nennt man Objekte - und sie basieren auf Klassen.

Alltag & Spielewelt: Beispiele zum Verstehen

Alltagsbeispiel: "Auto"

• Ein Auto hat: Farbe, PS, Marke --> das sind Eigenschaften
• Es kann: fahren, bremsen, hupen --> das sind Methoden
• Ich kann viele Autos bauen - rot, blau, schnell, langsam

Dafür brauche ich einen Bauplan - also eine Klasse Auto. Jedes Auto, das ich damit erstelle, ist ein Objekt, also eine Instanz dieser Klasse.

Spielewelt-Beispiel: "Spieler":

• Jeder Spieler hat: Namen, Lebenspunkte, Level
• Jeder kann: angreifen, heilen, speichern

Also baue ich mir eine Klasse Spieler und jedes Objekt davon ist dann "Tim", "Peter" oder "MonsterGlubschi".

Vergleich: Nur mit Variablen vs. mit Klassen

Variante ohne Klassen

string name1 = "Tim";
int leben1 = 100;

string name2 = "Peter";
int leben2 = 120;

Wird schnell chaotisch - alles doppelt, keine Struktur.

Variante mit Klasse

Spieler s1 = new Spieler();
s1.Name = "Tim";
s1.Leben = 100;

Spieler s2 = new Spieler();
s2.Name = "Peter";
s2.Leben = 120;

Jetzt ist jeder Spieler ein eigenes Objekt - sauber getrennt, aber demselben Plan gebaut.

Begriffe einfach erklärt:

Warum das Ganze?

Wenn man komplexe Programme schreiben möchte - z.B:

• ein Rollenspiel mit vielen Gegnern
• ein Shopsystem mit Produkten und Kunden
• ein Nachrichtensystem mit Benutzern und Nachrichten

... dann hilft es enorm, wenn man seine Welt in Klassen unterteilt.

Das macht den Code lesbarer, strukturierter und wiederverwendbar.

Kapitel 16 - Meine erste eigene Klasse

Heute betrete ich zum ersten Mal die Welt der eigenen Klassen. Ich lerne, wie ich in C# meine eigenen Datentypen erstelle - mit Eigenschaften, die ich selbst bestimme. Ich lerne außerdem, wo ich solche Klassen im Projekt sinnvoll platziere, wie ich daraus Objekte erzeuge und was das Schlüsselwort new wirklich bedeutet. Zum Schluss erfahre ich, was es mit public und private auf sich hat - also: Wer darf eigentlich auf meine Daten zugreifen und wer nicht?

Was ist eine Klasse - und wo kommt sie hin?

Eine Klasse ist ein Bauplan für Objekte. Sie beschreibt, welche Daten (Felder) und später Funktionen (Methoden) ein Objekt haben soll. In einem C# Projekt lege ich Klassen nicht in Program.cs an, sondern in einer eigenen Datei - das ist sauberer und besser lesbar.

Beispiel:

Projektstruktur:

Program.cs

Spieler.cs <-- meine eigene Klasse!

So sieht eine Klasse z.B. aus:

public class Spieler
{
	public string Name;
	public int Leben;
	public int Level;
}

Ich will einen Spieler im Programm verwenden

Wenn ich meine Klasse Spieler einmal definiert habe, kann ich im Hauptprogramm ein Objekt davon erstellen:

Spieler s1 = new Spieler();

Jetzt kann ich diesem Objekt Werte geben:

s1.Name = "Nico";
s1.Leben = 100;
s1.Level = 5;

und ich kann sie anzeigen:

Console.WriteLine("Spieler: " + s1.Name);
Console.WriteLine("Leben: " + s1.Leben);
Console.WriteLine("Level: " + s1.Level);

Was bedeutet das new?

Das Schlüsselwort new ist hier ganz entscheidend. Es bedeutet:

Erzeuge ein neues Objekt im Arbeitsspeicher, basierend auf der Klasse Spieler. Reserviere Speicher für die Felder Name, Leben und Level. Gib mir eine Variable zurück, mit der ich dieses Objekt ansprechen kann.

Ohne das new gäbe es kein echtes Objekt - ich hätte nur eine leere Referenz, aber keine Werte, keinen Speicher, kein Leben.

Darum: Immer wenn ich ein neues Ding erschaffen möchte - ein Spieler, ein Auto, ein Gegner, benutze ich new.

Aus einer Klasse mehrere Spieler machen

Ich kann aus einer Klasse viele Objekte vom selben Typ erzeugen.

Spieler boss = new Spieler();
boss.Name = "Boss007"
boss.Leben = 250;
boss.Level = 10;

Alle diese Objekte basieren auf den gleichen Bauplan, haben aber eigene Daten. Das ist das Herzstück der Objektorientierung.

Zugriffsmodifizierer - Wer darf auf meine Daten zugreifen?

Beim Schreiben meiner Klasse ist dir bestimmt schon aufgefallen: Ich schreibe bei den Feldern immer public davor.

public string Name;
public int Leben;
public int Level;

Aber was bedeutet das genau? Und gibt es Alternativen?

Was sind Zugriffsmodifizier?

Zugriffsmodifizierer steuern: Wer darf auf eine Klasse, ein Feld oder eine Methode zugreifen?

Die drei wichtigsten Modifizierer:

Beispiel: public vs. private

public class Spieler
{
	public string Name;
	private int geheimCode;
}

Im Hauptprogramm:

Spieler s = new Spieler();

s.Name = "Peter"; // Erlaubt
s.geheimCode = 1234; // Fehler - geheimCode ist privat

public = sichtbar und veränderbar

private = nur die Klasse selbst darf damit arbeiten

Warum ist das wichtig?

Stell dir vor, du hast eine Klasse Bankkonto. Du willst sicherstellen, dass niemand einfach kontostand = 999999 setzen kann. Dann musst du das Feld private machen und den Zugriff kontrolliert über eine Methode oder Eigenschaft erlauben.

Wichtige Merksätze:

• Eine Klasse ist der Bauplan, ein Objekt das Produkt.
• Mit new wird ein echtes Objekt im Speicher erzeugt.
• Mit . greife ich auf die Eigenschaft des Objekts zu.
• Mit public gebe ich den Zugriff frei.
• Mit private schütze ich interne Daten.

Kapitel 17 - Eigenschaften verstehen

In diesem Kapitel verstehe ich, wie ich meine Objekte besser schützen kann. Ich habe gelernt, dass ich mit public Feldern zwar einfach auf Daten zugreifen kann - aber jeder alles verändern kann, ohne Kontrolle. Ich lerne heute, wie ich mit sogenannten Eigenschaften (Properties) meine Daten kapseln kann: So kann ich Felder privat halten, aber trotzdem von außen ganz gezielt Zugriff geben - über kontrollierte Wege mit get und set.

Probleme mit public Feldern

Bisher habe ich die Felder einfach so geschrieben:

public class Spieler
{
	public string Name;
	public int Leben;
}

Im Hauptprogramm kann ich das Objekt ganz einfach benutzen:

Spieler s = new Spieler();
s.Leben = -50; // Logisch falsch - aber der Code erlaubt es!

Das ist ein großes Problem: Es gibt keine Kontrolle, was jemand mit den Feldern macht. Lebenspunkte dürfen z.B. nicht negativ sein - aber es prüft niemand.

Lösung: Das Feld private machen - und eine Property schreiben

public class Spieler
{
	private int _leben;
	
	public int Leben
	{
		get { return _leben;}
		set
		{
			if(value >= 0)
			{
				_leben = value;
			}
		}
	}
}

Was passiert hier?

Beispiel im Code:

Spieler s = new Spieler();
s.Leben = 80;		// erlaubt.
Console.WriteLine(s.Leben);		// Ausgaben: 80

s.Leben = -50;		// wird ignoriert - weil < 0
Console.WriteLine(s.Leben);		// Ausgabe bleibt: 80

Warum ist das besser?

• Ich kann prüfen, ob ein Wert gültig ist.
• Ich kann jederzeit sagen, "Wenn jemand lesen will, gib das zurück - aber beim Schreiben prüfe erst".
• Das Objekt ist besser geschützt, der Code ist robuster.

Properties sehen aus wie Felder - verhalten sich aber wie Methoden

Für den Benutzer des Objekts ist es ganz bequem:

s.Leben = 100;		// Sieht aus wie ein Feld
int x = s.Leben;	// Sieht aus wie ein Feld

Aber unter der Haube laufen Methoden (get und set) ab - und ich kann alles kontrollieren.

Was passiert, wenn ich set ganz weglasse?

public int Leben
{
	get { return _leben; }
}

Dann ist die Property nur lesbar - niemand kann von außen etwas setzen. Das ist nützlich für Dinge wie ID, ErstelltAm, Version usw.

Achtung: Das Feld und die Property dürfen nicht gleich heißen!

Das hier wäre falsch:

public int Leben
{
	get { return Leben; }	// Endlos-Schleife!!!!
}

Darum benutzt man für das Feld oft einen anderen Namen: leben, _leben, m_leben - Hauptsache eindeutig.

Auto-Property (nur mal kurz erwähnt)

Wenn ich keine Prüfung brauche, sondern einfach nur Zugriff geben will, kann ich das auch so schreiben:

public int Leben {get; set; }

Das ist eine automatische implementierte Eigenschaft - sie funktioniert wie ein public Feld, bietet aber später mehr Kontrolle, wenn ich das will. Aber nur, wenn keine Prüfung nötig ist!

Merksätze:

• get liest einen Wert, set schreibt einen Wert.
• Mit einer Property kann ich prüfen, bevor etwas verändert wird
• Felder sollten möglichst privat sein
• Properties sind der saubere Weg, um Daten sicher zu kapseln
• Wenn ich später will, kann ich in der Property z.B. Logs schreiben, oder Berechnungen einbauen.

Kapitel 18 - Referenz- vs. Werttypen

Heute lerne ich etwas sehr Zentrales, das für objektorientiertes Programmieren absolut wichtig ist: Ich verstehe, warum ein int sich anders verhält als ein Objekt wie Spieler, wenn ich es z.B. einer anderen Variable zuweise. Ich lerne den Unterschied zwischen Werttypen und Referenztypen und was das für Kopieren, Veränderung und Vergleich bedeutet.

Was sind Werttypen?

Beispiele für Werttypen:

• int, double, bool, char, decimal
• alle "einfachen" Datentypen

Werttypen speichern ihren eigentlichen Wert direkt in der Variable.

Beispiel:

int a = 5;
int b = a;

b = 10;

Console.WriteLine(a);	// 5
Console.WriteLine(b);	// 10

Hier wurde der Wert von a kopiert - danach sind a und b völlig unabhängig.

Was sind Referenztypen?

Beispiele für Referenztypen:

• eigene Klassen wie Spieler, Auto, Produkt
• auch: Arrays, Strings, Listen

Beispiel:

Spieler s1 = new Spieler();
s1.Name = "Nico";

Spieler s2 = s1;
s2.Name = "Gustav";

Console.WriteLine(s1.Name);	// Ausgabe: Gustav!

Warum? - Weil s1 und s2 auf dasselbe Objekt zeigen. Sie verweisen beide auf den gleichen Speicherplatz.

So funktioniert es im Hintergrund:

• s1 zeigt auf ein Objekt im Speicher (z.B. bei Adresse 0x01A4)
• Wenn ich s2 = s1 mache, zeigt s2 auf dieselbe Adresse
• Es gibt also nur ein Objekt, aber zwei Namen, die darauf zeigen

Klassischer Fehler beim Kopieren

Ich denke vielleicht:

Spieler kopie = original;

Aber in Wirklichkeit bedeutet das: kopie zeigt auf das selbe Objekt - Änderungen wirken sich auf beide aus.

Wenn ich ein echtes Duplikat möchte?

Dann muss ich das Objekt aktiv kopieren - z.B. per Methode:

Spieler kopie = new Spieler();
kopie.Name = original.Name;
kopie.Leben = orginal.Leben;

Jetzt habe ich zwei unabhängige Objekte mit identischen Werten.

Zusammenfassung

Vergleich aus dem Alltag

Merksätze:

• Werttypen enthalten den Wert selbst

• Referenztypen enthalten nur einen Verweis auf das Objekt
• Bei Spieler b = a; sind a und b verbunden - sie meinen dasselbe Objekt
• Wenn ich wirklich eine Kopie will, muss ich ein neues Objekt erzeugen