Erste Schritte in C# und Visual Studio
Teil 2 des C#-Tutorials: Erste Schritte in C#
Zu Teil 3 des C#-Tutorials: Ablaufsteuerung in C#
Zu Teil 4 des C#-Tutorials: In C# integrierte Datentypen
Jetzt wollen wir uns zunächst einmal ein bisschen mit Visual Studio vertraut machen. Mit Visual Studio können wir Projekte und Projektmappen verwalten.
Eine Projektmappe können wir uns vorstellen als einen Arbeitsbereich, in dem verschiedene Projekte zusammengefasst werden. Ein Projekt entspricht dabei einem Programm, d.h. wenn wir mehrere Programme erstellen wollen, können wir mehrere Projekte anlegen und diese in einer Projektmappe zusammenfassen.
Wir wollen nun einmal unser erstes eigenes Projekt in Visual Studio anlegen. Dazu wählen wir im Menü Datei → Neu → Projekt. Danach Installiert → Vorlagen → Andere Sprachen → Visual C# → Klassischer Windows-Desktop. In der sich nun öffnenden Liste wählen wir Konsolen-App (.NET-Framework).
Weiter unten können wir einen Namen für das Projekt angeben (wir geben hier „Kapitel2Beispiele“ an) sowie einen Namen für die Projektmappe, die ebenfalls neu erstellt wird und in die unser Projekt gelegt wird. Als Name für die Projektmappe wählen wir „CSharpBeispiele“. Nach einem Klick auf OK werden Projektmappe und Projekt automatisch erstellt.
Wir haben nun eine Projektmappe mit einem Projekt darin. Später könnten wir in dieselbe Projektmappe noch weitere Projekte hinzufügen.
Doch zunächst wollen wir uns mit dem gerade erstellten Projekt befassen. Visual Studio hat nun automatisch einige Dateien für unser Projekt generiert, auf diese können wir mit dem Projektmappen-Explorer zugreifen.
Um eine Datei zu öffnen genügt es, im Projektmappen-Explorer die Datei anzuklicken. Sie wird dann im Editor angezeigt. Im Editor angezeigte Dateien können über das Schließen-Symbol geschlossen werden.
Von Interesse ist für uns die Datei Program.cs, die auch automatisch im Editor geöffnet wird. Diese Datei wird nämlich bei der Generierung des Projektes automatisch als Einstiegspunkt in das Programm festgelegt. Erinnern wir uns an die Definition der imperativen Programmierung: der Computer erhält eine Reihe von Anweisungen, die er nacheinander abarbeitet. Und genau in die Datei Program.cs können wir nun die Anweisungen schreiben, die das Programm abarbeiten soll.
Ein erstes Programm
Zunächst einmal sehen wir jedoch, dass Visual Studio für uns bereits automatisch einige Codezeilen in der Datei Program.cs generiert hat. Die dort gezeigten Konzepte werden wir in späteren Kapiteln noch ausführlicher kennen lernen, für den Moment soll eine kurze Einführung genügen.
Zu Beginn sehen wir einige Zeilen, die alle mit using beginnen. Mittels using kann Code aus anderen Dateien in eine Quelltext-Datei eingebunden werden. Dies macht man deshalb, weil man Funktionalitäten, die man in einer anderen Datei realisiert hat, in der Quelltext-Datei verwenden möchte. Stellen Sie sich z.B. vor, Sie hätten in einer Datei Code geschrieben, der bestimmte Funktionalitäten eines Taschenrechners beinhaltet. Nun arbeiten Sie an einer anderen Datei und möchten dort die Taschenrechner-Funktionen verwenden. Dann müssen Sie diese Taschenrechner-Funktionen zunächst mittels der using-Direktive einbinden.
Es können übrigens nicht nur Dateien eingebunden werden, die man selbst programmiert hat. Die Programmiersprache C# kommt mit einer großen Bibliothek daher, die bereits viele nützliche Funktionalitäten beinhaltet (z.B. mathematische Operationen, Operationen zum Zugriff auf Netzwerkressourcen und vieles mehr). Im konkreten Fall werden durch die using-Direktiven einige häufig verwendete Funktionalitäten in die Datei eingebunden, die wir dann später bei der Erstellung unseres eigenen Codes verwenden könnten.
Unser C#-Tutorial
Lesen Sie hier die ersten 4 Kapitel kostenlos!
Nach den Zeilen mit den using-Direktiven folgt eine Leerzeile. Leerzeilen können wir (übrigens ebenso wie Leerzeichen) an jeder Stelle des Programms in beliebiger Anzahl einfügen. Leerzeichen bzw. -zeilen werden vom Compiler bei der Übersetzung des Codes ignoriert. Sie dienen lediglich dazu, eine Quellcode-Datei für den menschlichen Leser visuell besser zu strukturieren.
Danach sehen wir eine Zeile, die mit dem Schlüsselwort namespace beginnt. Damit kann ein sogenannter Namensraum festgelegt werden. Hier wird der Namensraum Kapitel2Beispiele gesetzt. Der Namensraum entspricht in diesem Fall also dem Namen des Projektes, das wir ebenfalls Kapitel2Beispiele genannt haben.
Aber was ist ein Namensraum überhaupt? Nun, wir werden später Objekte erzeugen und können diesen Namen zuweisen. Wenn zuvor ein Namensraum festgelegt wurde, wird der Namensraum dem Namen des erzeugten Objektes einfach vorangestellt. Wenn wir also z.B. ein Objekt mit dem Namen David erzeugen, würde der vollständige Name Kapitel2Beispiele.David lauten. Wozu das nützlich ist werden wir später noch sehen, für den Moment ist es nicht weiter von Bedeutung.
In der nächsten Zeile sehen wir eine einzelne, öffnende geschweifte Klammer. Hier wird es nun erstmals interessant: geschweifte Klammern treten in C# immer paarweise auf und kennzeichnen einen zusammengehörenden Codeblock. Die zugehörige schließende Klammer findet sich in der letzten Zeile des Programmcodes. Die beiden Klammern kennzeichnen also einen zusammengehörenden Codeblock: alles was sich innerhalb der beiden Klammern befindet, gehört zu dem Codeblock. Innerhalb eines Codeblockes kann es wiederum kleinere, zusammengehörende Codeblöcke geben, die abermals durch ein Klammerpaar gekennzeichnet werden (was ja in der Datei auch der Fall ist).
Doch wozu ist das nützlich? Nun, der Codeblock bezieht sich immer auf die direkt davor getätigte Definition. Direkt vor dem Codeblock hatten wir ja den Namensraum definiert und dieser Namensraum bezieht sich demnach auf den nachfolgenden Codeblock. Bei allen Namen, die wir innerhalb dieses Codeblockes vergeben wird also (automatisch) der Namensraum vorangestellt.
Nun geht es weiter. In der nächsten Zeile finden wir eine Anweisung, die mit dem Schlüsselwort class beginnt. Mit diesem Schlüsselwort werden sogenannte Klassen (das Herzstück der Objektorientierung) erzeugt. Auch Klassen werden wir später noch ausführlich kennen lernen. Machen Sie sich darüber zunächst noch keine Gedanken. Alles, was hier wichtig ist: dieser Klasse geben wir den Namen Program. Da sich die Klasse innerhalb des zuvor festgelegten Namensraumes Kapitel2Beispiele befindet, lautet der vollständige Name der Klasse also Kapitel2Beispiele.Program.
Danach folgt wieder ein Paar von geschweiften Klammern: alles, was sich innerhalb dieses Klammerpaares befindet gehört demnach zur Klasse Program.
Jetzt finden wir ein etwas komplizierteres Konstrukt: static void Main(string[] args). Hierbei handelt es sich um die sogenannte Hauptfunktion der Klasse Program. Auch hierzu gilt abermals: Funktionen werden wir später noch ausführlich betrachten. Für den Moment brauchen uns die Details nicht weiter zu interessieren. Wichtig ist hier nur: nach der Deklaration des zuvor genannten Code-Konstruktes finden wir abermals ein Paar von geschweiften Klammern. Und innerhalb dieses Klammerpaares befindet sich der tatsächliche Inhalt der Hauptfunktion. Der Sinn der Hauptfunktion ist der folgende: wenn das Programm gestartet wird, werden die Anweisungen, die sich in der Hauptfunktionen befinden, ausgeführt. Nachdem alle Anweisungen ausgeführt wurden, beendet sich das Programm automatisch.
Alles, was wir bisher gesehen haben dient also genau einem Zweck: gewissermaßen einen Rahmen für die Ausführung eines Programms zu schaffen. Jedes Programm benötigt genau eine Hauptfunktion, die ausgeführt wird, sobald das Programm gestartet wird.
Was wir hier vor uns sehen ist also tatsächlich schon ein vollständiges Programm, das wir ausführen können. Wir können das Programm starten durch Drücken der Tastenkombination Strg + F5. Dadurch wird zunächst der Compiler ausgeführt, der den Quellcode in Maschinencode übersetzt. Danach wird der so erzeugte Maschinencode direkt ausgeführt, das Programm also gestartet.
Drücken Sie nun also Strg + F5. In der unteren Statusleiste von Visual Studio sollte kurz die Meldung „Erstellen wurde gestartet…“ erscheinen und danach „Erstellen erfolgreich“. Zudem öffnet sich ein Fenster der Windows-Eingabeaufforderung (der sogenannten Konsole). Wir werden zunächst nur Konsolenanwendungen erstellen, d.h. die Programme werden über die Windows-Eingabeaufforderung gestartet. Konsolenprogramme können Ausgaben machen, die dann als Text in der Eingabeaufforderung angezeigt werden.
Wenn wir unser Programm starten, wird also von Visual Studio automatisch eine Eingabeaufforderung geöffnet und das Programm dort ausgeführt. In unserem Fall sehen wir dort lediglich die Meldung „Drücken Sie eine beliebige Taste …“. Kommen wir der Aufforderung nach, verschwindet das Fenster.
Was hat das zu bedeuten? Nun, zunächst einmal hat unsere Hauptfunktion ja noch keinerlei Inhalt, keinerlei Anweisungen, die der Computer ausführen könnte. Das Programm wird also gestartet und da es keine Anweisungen zum Ausführen gibt, wird es auch direkt schon wieder beendet (man sagt dazu: das Programm terminiert).
Wenn ein Programm beendet wird, verschwindet normalerweise die Eingabeaufforderung auch wieder. Visual Studio greift uns hier unter die Arme, indem das Fenster erst dann geschlossen wird, wenn man (nachdem das Programm terminiert ist) eine beliebige Taste gedrückt hat. Das Programm könnte ja auch irgendwelche Ausgaben machen (also Text in die Eingabeaufforderung schreiben), den wir aber vermutlich nicht wahrnehmen können, wenn das Programm direkt wieder beendet wird. Daher wird das Fenster erst geschlossen, nachdem wir eine Taste gedrückt haben. Da in unserem Fall das Programm selbst keine Ausgabe getätigt hat, ist die Aufforderung, eine Taste zu drücken, der einzige Text, den wir innerhalb der Eingabeaufforderung sehen.
Programmieren mit C# - Einige unserer Empfehlungen
Hallo Welt
Jetzt erweitern wir dieses automatisch generierte Programm so, dass es auch tatsächlich etwas tut. Fügen Sie in der Hauptfunktion eine einzelne Codezeile ein:
Console.WriteLine("Hallo Welt");
Die komplette Quelltext-Datei sollte dann wie folgt aussehen:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Kapitel2Beispiele
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Hallo Welt");
}
}
}
Wenn Sie nun wieder Strg + F5 drücken, erscheint im sich öffnenden Konsolenfenster der Schriftzug Hallo Welt, gefolgt von der bereits bekannten Aufforderung zum Drücken einer Taste. Die Codezeile, die wir in die Hauptfunktion eingefügt haben, hat also bewirkt, dass der angegebene Text auf der Konsole angezeigt wird.
Wir haben damit nun eine erste Anweisung in der Programmiersprache C# kennen gelernt. Durch den Aufruf von
Console.WriteLine("Beliebiger Text");
kann beliebiger Text über die Konsole ausgegeben werden.
Kernelemente der Programmiersprache C#
Nachdem wir jetzt das erste sehr einfache Beispiel eines Programms in C# gesehen haben, wollen wir uns zunächst einmal etwas genauer klarmachen, was ein Programm überhaupt ist.
Wie wir zuvor schon erfahren haben, ist ein C#-Programm anzusehen als eine Reihe von Anweisungen, die vom Prozessor des Computers nacheinander ausgeführt werden. Sind alle Anweisungen abgearbeitet, terminiert das Programm. Im vorherigen Beispiel bestand das Programm also nur aus einer Anweisung. Nachdem die Anweisung ausgeführt war (d.h. der gewünschte Text auf der Konsole ausgegeben wurde) wird das Programm automatisch beendet.
Variablen
In der Regel zielen Programme darauf ab, Änderungen an Variablen durchzuführen. Eine Variable ist dabei einfach eine Speichereinheit im Speicher des Computers, in die man Werte schreiben kann. Im einfachsten Fall beinhaltet eine Variable z.B. eine Ganzzahl. Eine solche Variable können wir nun auf verschiedene Arten „manipulieren“, z.B. indem wir eine Summe mit einer anderen Ganzzahl bilden, eine Multiplikation ausführen oder eine sonstige arithmetische Operation ausführen.
Eine Variable hat immer einen bestimmten Typ, der bei der Erstellung der Variable angegeben werden muss. Der Typ einer Variable legt fest, welche Art von Werten in der Variable gespeichert werden können. Neben Ganzzahlen sind z.B. noch Fließkommazahlen, Zeichenketten oder selbst definierte Typen möglich.
Zudem muss man einer Variable bei der Erstellung einen beliebigen Namen geben. Mit diesem Namen kann man die Variable später wieder ansprechen (z.B. wenn man sie in einer Operation benutzen möchte). Der Name der Variable muss eindeutig sein, d.h. Sie können innerhalb eines Codeblockes nicht zwei Variablen mit demselben Namen haben.
Was bedeutet hierbei „innerhalb eines Codeblockes“? Nun, wie wir im vorherigen Abschnitt gesehen haben, werden zusammengehörige Codeblöcke immer durch ein Paar von geschweiften Klammern signalisiert. Innerhalb jedes solchen zusammengehörigen Codeblockes müssen alle Namen von Variablen eindeutig sein.
Das Anlegen einer Variable ist in C# sehr einfach, es erfolgt nach folgendem Muster:
Typ Name_der_Variable;
Zunächst wird also der Typ der Variablen angegeben, danach folgt der Name. Der Name kann mit wenigen Einschränkungen frei gewählt werden (z.B. muss ein Variablenname immer mit einem Buchstaben oder einem Unterstrich beginnen). Sie sollten dennoch darauf achten, die Namen für Ihre Variablen immer sinnvoll zu wählen. Ein guter Variablenname ist ein solcher, aus dem man den Zweck der Variable bereits ablesen kann. Schlecht sind dagegen generische Namen, also z.B. variable1, arg2 oder gz57.
Abgeschlossen wird ein solches Statement durch eine Semikolon (;). Generell wird das Semikolon immer verwendet, um einzelne Instruktionen abzuschließen. Wir werden im Verlauf dieses Tutorials noch sehr viele Instruktionen kennen lernen, die immer mit einem Semikolon abgeschlossen werden.
Jetzt wissen wir, wie wir den Namen wählen können, aber was für Typen wir konkret benutzen können, noch nicht. In C# gibt es bereits einige Basistypen, die oft Verwendung finden, z.B. Typen für Ganzzahlen oder Zeichenketten. Um eine Ganzzahl in einer Variable speichern zu können, gibt es den Typ int. Das ist die Abkürzung für das englische Wort Integer, was wiederum Ganzzahl bedeutet.
Eine Variable, in der wir später eine Ganzzahl speichern können, lässt sich also mit folgender Anweisung erzeugen:
int summand1;
Mit dieser Anweisung haben wir also eine Variable mit dem Namen summand1 erzeugt, in der man eine Ganzzahl speichern kann. Diesen Vorgang nennt man Deklaration einer Variable. Die Variable wird erzeugt (d.h. es wird irgendwo im Speicher des Computers ein Platz geschaffen, an dem man genau eine ganze Zahl speichern kann), es wird aber noch kein Wert in der Variablen gespeichert.
Das Speichern eines Wertes in einer Variable nennt man Zuweisung. Der Variablen wird also ein Wert zugewiesen. Zuweisungen erfolgen in C# nach folgendem Muster:
Name_der_Variable = <Ausdruck>;
Aber was bedeutet
Was heißt das? Nun, wenn wir die Zuweisung int-Variablen vornehmen wollen, können wir auch einen komplexeren Ausdruck verwenden, der letztendlich zu einem int-Wert evaluiert. Statt den Wert direkt anzugeben, können wir also z.B. auch eine Berechnung durchführen (beispielsweise 4 + 9, 6 * 7, summand1 + summand2, usw). Wir können innerhalb eines solchen Ausdrucks also auch den Namen von anderen Variablen verwenden. Die Berechnung wird dann mit dem Wert durchgeführt, der in der anderen Variablen gespeichert ist.
Unsere Variable summand1 können wir also auf folgende Weise mit einem Wert belegen:
summand1 = 3;
summand1 = summand1 + 5;
Hier wird summand1 zunächst mit dem Wert 3 belegt. Danach wird eine erneute Zuweisung vorgenommen, dabei wird der Wert der Variable summand1 zunächst ausgelesen (dieser ist zu diesem Zeitpunkt 3) und danach der Wert 5 addiert. Letztendlich wird die Variable summand1 also den Wert 8 speichern.
Deklaration und Zuweisung sind sehr häufige Instruktionen in C#-Programmen. Da man oft Variablen erzeugt und diese direkt mit einem Wert belegen möchte, lassen sich Deklaration und Zuweisung zu einer einzelnen Anweisung kombinieren.
Typ Name_der_Variable = <Ausdruck>;
In unserem Beispiel mit der int-Variable summand1 sähe das demnach folgendermaßen aus:
int summand1 = 3;
Funktionen / Methoden
Ein weiterer integraler Bestandteil von C# sind die Funktionen. Funktionen können Sie sich zunächst vorstellen wie diese, die Sie eventuell noch aus dem Mathematikunterricht in der Schule kennen. Dort sprach man z.B. von $f(x) = 2x$, wenn man eine Funktion f erstellen wollte, die jeder Zahl den doppelten Wert zuordnen soll.
Funktionen in C# sind aber viel flexibler: sie können beliebige Parameter erhalten (also z.B. auch mehrere Parameter, Parameter von unterschiedlichen Typen, z.B. Gleitkommazahlen und Zeichenketten) sowie beliebige Rückgabewerte.
Tatsächlich muss eine Funktion noch nicht einmal einen Rückgabewert beinhalten. Doch was wäre dann der Sinn einer Funktion, wenn sie schlussendlich gar kein Ergebnis liefert? Um dies zu verstehen, müssen wir uns jetzt das erste Mal mit dem Paradigma Objektorientierte Programmierung befassen.
Die Idee hinter der Objektorientierten Programmierung ist es, Programme mit Hilfe von autonomen Objekten zu modellieren, die miteinander interagieren. Autonom bedeutet in diesem Zusammenhang in etwa, das ein Objekt grundsätzlich allein „lebensfähig“ ist, d.h. dass es ohne weitere Hilfe von außen so funktioniert, wie es funktionieren soll.
Verdeutlichen wollen wir das mit Hilfe eines konkreten Beispieles. Unser Objekt soll nun eine Kaffeemaschine sein. Die Kaffeemaschine ist ein technisch gesehen hochkomplexes Objekt. Für uns als Benutzer ist es dagegen nicht ersichtlich, wie genau die Kaffeemaschine funktioniert, die Details sind uns nicht bekannt. Wir kennen nur die gewöhnlichen Funktionen, die ein solches Gerät hat, z.B. spülen, Wasser aufbrühen oder Cappuccino zubereiten. Die Kaffeemaschine arbeitet also gewissermaßen autonom. Wir als Benutzer können mit dem Gerät interagieren, indem wir diese Funktionen in Gang setzen oder den fertig zubereiteten Kaffee entnehmen und diesen dann weiter „verarbeiten“ (in diesem Fall also trinken).
Und genau das ist auch das Grundprinzip bei der Objektorientierten Programmierung. Wir haben Objekte und diese Objekte haben bestimmte Funktionen. Eine Funktion ist also immer an ein Objekt gebunden. Eine Funktion kann, wie eine mathematische Funktion, ein Ergebnis liefern. Im Fall der Kaffeemaschine wäre das von der Funktion Cappuccino zubereiten gelieferte Ergebnis also der fertig zubereitete Cappuccino. Andere Funktionen dagegen liefern kein explizites Ergebnis, sondern nehmen nur Änderungen am zu Grunde liegenden Objekt vor. Beim Beispiel unserer Kaffeemaschine wäre das z.B. die Funktion spülen: diese würde kein direktes Ergebnis liefern (wie die Funktion Cappuccino zubereiten), sondern Sie würde nur den Zustand der Kaffeemaschine ändern (also indem Sie durch den Spülvorgang die Maschine von Kaffeerückständen säubert).
In der C#-Fachsprache nennen wir die Funktionen Methoden. Ein C#-Objekt hat also verschiedene Methoden.
Wir wir selbst Objekte erstellen können, werden wir später noch sehen. Zunächst interessieren wir uns aber dafür, wie wir Objekte benutzen können. Tatsächlich ist es nämlich so, dass C# bereits eine gewisse „Grundausstattung“ besitzt, es also schon einige nützliche Objekte gibt, die wir direkt verwenden können. Der Aufruf einer Funktion erfolgt nach dem folgenden Schema:
Object.Methode(<Liste_der_Parameter>);
Einen Beispiel für einen Methodenaufruf haben wir übrigens im vorherigen Abschnitt bereits gesehen:
Console.WriteLine("Hallo Welt");
Wir haben in diesem Fall also ein Objekt namens Console. Sinnigerweise repräsentiert dieses Objekt also das Konsolenfenster. Und das Konsolen-Objekt besitzt eine Methode (Funktion), mit der man Text auf der Konsole ausgeben kann. In diesem Fall heißt die Methode also WriteLine. Als Parameter erhält die Methode eine einzelne Zeichenkette. Zeichenketten werden in C# begrenzt durch (paarige) Anführungszeichen, die eigentliche Zeichenkette befindet sich also innerhalb der Anführungszeichen. Bei Methoden, die mehrere Parameter erhalten, werden die einzelnen Parameter durch Kommata getrennt.
Möglicherweise fragen Sie sich jetzt, wo das Console-Objekt im Hallo Welt-Beispiel überhaupt herkommt. Hier machen sich zum ersten Mal die using-Direktiven, die am Anfang der Quelltext-Datei stehen, bemerkbar. Über
using System;
werden einige wichtige Objekte der C#-Grundausstattung in die Datei eingebunden. Darunter befindet sich auch das Console-Objekt, das wir zur Ausgabe des Textes genutzt haben.
Ein zweites Programm
Das bisher gelernte setzen wir nun zu einem weiteren Programm zusammen. Statt nur eine einzelne Ausgabe zu machen, wie im Hallo Welt-Programm, wollen wir nun eine Berechnung durchführen und das Ergebnis der Berechnung über die Konsole ausgeben lassen.
Wir ändern dazu lediglich den Inhalt der Hauptfunktion unseres Programms, die restlichen Codezeilen bleiben erhalten.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Kapitel2Beispiele
{
class Program
{
static void Main(string[] args)
{
int summand1 = 3;
int summand2 = 13;
int ergebnis = summand1 + summand2;
Console.WriteLine(ergebnis);
}
}
}
Wir wenden hier also die zuvor erlernten Techniken an. Zunächst erzeugen wir zwei Variablen summand1 und summand2, denen wir direkt bei der Erzeugung Werte zuweisen. Danach erzeugen wir eine dritte Variable, ergebnis, der wir die Summe aus summand1 und summand2 zuweisen. Schließlich rufen wir die bereits bekannte Methode WriteLine des Console-Objektes auf, um das Ergebnis unserer Berechnung auf der Konsole anzeigen zu lassen.
Mittels Strg + F5 können wir das Programm nun abermals starten. Im sich öffnenden Konsolen-Fenster sollten wir also die Zahl 16 als Ergebnis der Berechnung 3 + 13 vorfinden.
Bei den bisherigen beiden Programmen haben wir im Quelltext immer den gesamten Programmcode gezeigt. In den weiteren Kapiteln werden wir den Quelltext immer auf die wirklich entscheidenden Stellen beschränken, also diese, in denen wir etwas neues lernen. Zum Beispiel werden wir dann nur den Code der Hauptfunktion zeigen und auf die Anzeige des umschließenden Klassenrahmens verzichten.
Sie brauchen den Quelltext auch nicht mühevoll manuell abzutippen. In den Begleitmaterialien zum Buch können Sie den gesamten Beispielcode, der im Tutorial verwendet wird, herunter laden. Sie finden dort auch eine Anleitung, wie Sie den Code in Visual Studio importieren können. Der zum Download bereitgestellte Code ist natürlich auch vollständig und lauffähig, d.h. auch die Codeteile, die wir in der Darstellung innerhalb der einzelnen Kapitel auslassen, sind dort enthalten.
Über diesen Kurs
Dieses Tutorial richtet sich an Einsteiger, die C# programmieren lernen wollen. Die ersten 4 Kapitel des Tutorials, in denen die Grundlagen erklärt werden, können Sie bereits auf der Webseite lesen.
Die Einführung für Anfänger umfasst unverzichtbare Elemente der Programmiersprache wie Bedingungen und Schleifen, Variablen und Datentypen.
Die komplette Version des Tutorials kann in Buchform erworben werden. Sie steht sowohl als gedrucktes Buch als auch als eBook zur Verfügung. In diesem erweiterten C#-Tutorial für Einsteiger, die Programmieren lernen wollen, werden viele weitere Themen wie Operatoren, Ausdrücke, Klassen und Vererbung anfängergerecht präsentiert. Zudem werden auch fortgeschrittene Themen wie die Erstellung von grafischen Benutzeroberflächen mit der Windows Presentation Foundation (WPF) und Netzwerkprogrammierung angeschnitten. Des weiteren enthält enthält das Komplett-Tutorial umfangreiche Begleitmaterialien wie eine Download-Möglichkeit des Beispielcodes, Übungen und Lösungsvorschläge für die Übungen.
Ab 6 Euro
Zufriedenheitsgarantie: Sie können sich den Kaufpreis über Amazon erstatten lassen, wenn Sie mit dem Tutorial nicht zufrieden sind.
Zu Amazon
Teil 2 des C#-Tutorials: Erste Schritte in C#
Zu Teil 3 des C#-Tutorials: Ablaufsteuerung in C#
Zu Teil 4 des C#-Tutorials: In C# integrierte Datentypen
Eine ausführliche Liste unserer Buchempfehlungen für C# finden Sie hier.
Unsere Buchempfehlungen
Wir haben auch eine Empfehlung für einen C#-Fernkurs parat.