Kapitel 2
Hello World
Hello World
Hallo und herzlich willkommen beim zweiten Teil unseres kleinen Tutorials.
In diesem Kapitel werden wir unser erstes kleines Programm entwickeln. Es kann zwar nicht viel, bringt aber alles mit was ein Stück Software so ausmacht.
Bisher sollte ihr folgendes erledigt haben:
- Visual C# Express 2010 installiert
- Windows mit .NET 4.0 und XNA 4.0 versehen
Ich habe meine Karriere als Programmierer 1988 mit BASIC begonnen.
Ein nettes kleines Programm in BASIC sieht ungefähr so aus:
Code: Alles auswählen
10 INPUT "Geben Sie bitte Ihren Namen ein"; A$
20 PRINT "Guten Tag, "; A$
BASIC ist eine imperative Sprache, d.h. man sagt dem Rechner WIE er vorgehen soll.
Befehl für Befehl arbeitet der Rechner ein Programm ab und kommt so (hoffentlich) zu einem Ergebnis.
Es gibt noch völlig andere Ansätze, die deklarative Programmierung sagt dem Rechner z.B. WAS als Ziel erwünscht ist.
Den Weg dahin findet er dann selbst. Das ist genau so freakig wie es sich anhört und wird hier sicher nicht Gegenstand der Tutorials sein.
Bei BASIC fällt als erstes auf, dass die Zeilen durchnummeriert sind. Der Rechner startet immer ganz oben und arbeitet sich nach unten durch. Das ist für den Anfänger beruhigend, stößt aber schnell an Grenzen. Das obige Programm gibt einfach die kleine Zeile
Guten Tag, [eingegeber Name]
an einer Konsole(Das ist das kleine schwarze Ding, dass ihr als "Eingabeaufforderung" kennt) aus.
Alles gut und schön, aber wenn man so vorgeht muss man sich wiederholende Programmteile immer wieder erneut eingeben. Was die Lesbarkeit nicht gerade erhöht. Deshalb hat man sehr schnell sogenannte Sprungbefehle erfunden, mit deren Hilfe man zu einer früheren Zeile zurückkehren konnte. Mit 30 GOTO 10; wäre man z.B. wieder am Anfang und das Programm würde erneut von vorn beginnen.
Spätere Sprachen wurden dann immer komplexer, und ständig kamen neue Befehle hinzu. Sehr bald schon löste man sich vom starren Festhalten an Zeilennummern und heutzutage kann man den Code fast in beliebiger Reihenfolge schreiben. Wichtig ist der logische Zusammenhang, nicht ein paar Nummern die am Anfang der Zeile stehen.
Die Komplexität nahm immer mehr zu und in den 90ern kam es dann zur sogenannten Softwarekrise. Fast niemand konnte mehr seinen eigenen Programme verstehen und Fehler waren an der Tagesordnung. Schaut euch HOI3 an und ihr seht ein typisches Beispiel hierfür (auch wenn es 15 Jahre später released wurde). Da man nicht auf einmal wieder kleinere Programme schreiben wollte, mussten neue Lösungsansätze her. Aus dieser Zeit stammen JAVA, von dem ihr sicher schon gehört habt, und eben C#.
Diese Programmiersprachen haben zwei wesentliche Standbeine:
- Programmcode aus diesen Sprachen wird nicht direkt in Maschinencode übersetzt, sondern läuft IMMER auf einer virtuellen Zwischenschicht( das ist die JRE bzw. JVM die ihr vielleicht kennt). Der Programmierer greift also nicht direkt auf die Hardware zu, sondern sagt jemand anderem was er gerne machen würde. Dieser jemand prüft ob er auch das richtige macht und greift ggf. helfend ein. In Wirklichkeit ist es natürlich bedeutend komplizierter, aber für den Anfang reicht das. Hiermit werden schon mal unglaublich viele Fehler von Haus aus ausgeschlossen. Memory Leaks z.B.
- Beide Sprachen setzen auf sogenannte Klassenbibliotheken. Irgendwann ist man zu der Einsicht gelangt, dass man nicht immer wieder dasselbe programmieren will. Ein Datei Öffnen Dialog sieht eigentlich immer gleich aus, warum sollte man sich damit aufhalten?
C# und Java verfügen über tausende Klassen, die die immer wieder benötigten Funktionen bereitstellen. Man muss nur wissen dass es sie gibt und wie sie benutzt werden. Das Schreiben kleinerer Programme ähnelt mehr dem Blättern in einem Lexikon als dem was man sich so unter Softwareentwicklung vorstellt. Damit hat der Informatiker Zeit, sich mit den echten Problemen zu beschäftigen und vielleicht mal ein paar Tests mehr zu machen.
Lasst uns also beginnen:
Startet Visual C# Express 2010 (in Zukunft: VS2010 genannt) und ihr werdet folgenden Bildschirm (ohne das Auswahlfenster, das kommt gleich) sehen:
Alles ist bei VS2010 in Projekten organisiert. In diesen versammeln sich alle relevanten Dateien, die dann irgendwann in lauffähigen Code gegossen werden.
Um zu starten brauchen wir also erst einmal ein Projekt. VS2010 stellt uns eine Fülle zur Auswahl. Wem das nicht genug ist, der kann auch noch viele neue aus dem Inet laden. Solche Vorlagen sind kein Muss, sie erleichtern aber die Arbeit ungemein.
Wir erstellen also ein neues Projekt (1), wählen eine C# Vorlage (2) und zwar die gute alte Konsolenanwendung (3).
Zu guter Letzt geben wir dem Ding noch einen Namen (4) und bestätigen das Ganze mit OK (5).
Hier haben wir auch schon die erste Lektion: NAMEN kommen in Programmiersprachen eine sehr große Bedeutung zu.
Alle Namen sind eindeutig und unterliegen ganz bestimmten Konventionen. Die meisten Programmiersprachen sind case sensitiv.
Das bedeutet, dass sie zwischen Klein- und Großschreibung unterscheiden. HelloWorld und helloworld sind also NICHT dasselbe.
Als Deutscher ist man so was aber gewöhnt.
Dazu kommt noch, dass es fast immer verboten ist an den Anfang eines Namens eine Zahl oder ein Sonderzeichen zu setzen. 2HelloWorld ist verboten HelloWorld2 aber nicht. Prinzip verstanden?
Dazu sollte ihr euch gleich zu Anfang angewöhnen Namen immer zusammen zu schreiben, zwei Wörter sind genau das was sie sind: 2 Namen für irgend etwas. Wenn ihr mehr als ein Wort benötigt um einen treffenden Namen zu definieren, so nutzt die sogenannte Camel Notation. Diese ist wirklich intuitiv und übersichtlich, ich habe sie oben verwendet. HelloWorld ist in Camel notation geschrieben.
Man benutzt einfach bei Beginn eines neuen Wortes einen Großbuchstaben.
(Warum CAMEL? Seht euch die Wörter genau an, sieht wie 'ne Kamelkarawane aus. Nerds sind Scherzkekse)
Mittlerweile sollte sich die Ansicht verändert haben und ihr die Basisklasse unseres kleinen Projektes sehen (1):
Bei (2) ist ein kleiner Dateiexplorer mit allem was unser Projekt ausmacht. Was das genau ist braucht euch momentan nicht zu interessieren. Wichtig ist momentan nur, das es die Datei Programm.css gibt. das ist die Hauptklasse unseres Programms.
KLASSEN
In C# dreht sich alles um die sogenannten Klassen. Das hat jetzt eher wenig mit Schule zu tun sondern mehr mit Fahrzeugklassen.
Man könnte sie auch Kategorien nennen, sie fassen Funktionen geordnet zusammen. Wir beschäftigen uns später näher mit ihnen, wenn wir über Vererbung sprechen. Momentan ist nur wichtig, dass sie sozusagen das Grundgerüst eines Programms bilden und verschiedene Klassen miteinander arbeiten können, wenn sie sich kennen.
Beginnen wir mal einfach damit, dass ich euch kurz erkläre was die ganzen tollen Sachen in unserer Klasse Programm bedeuten.
VS2010 hat die selber angelegt, ist sozusagen der Grundstock für unser Programm, und bereits so voll lauffähig.
Ihr werdet noch öfter sehen, dass die Entwicklungsumgebung erkennt was ihr gerade machen wollt und euch Sachen vorschlägt oder sogar selbständig Code erzeugt. Alles sehr bequem. Hier greift wieder das System: warum selber machen, wenn es eh ständig dasselbe ist?.
Bei (3) sehen wir 4 Zeilen die mit using beginnen. Wie bereits erwähnt besteht .NET aus tausenden schon vorgefertigten Klassen.
Alle mit bedeutend mehr Funktionen als das was wir hier heute machen wollen. Um diese Funktionen nutzen zu können, müssen wir unserem Programm aber diese Klassen bekannt machen. Wir müssen sie sozusagen einander vorstellen.
Das geschieht mit dem Schlüsselwort using. Nach Zeile 4 können wir alle Klassen nutzen die sich unter System,
System.Collections.Generic, System.Linq und System.Text verbergen. Was die genau machen ist jetzt unerheblich. Ihr braucht sie auch momentan nicht wirklich. Nur sind das die üblichen Kandidaten, deshalb schreibt VS2010 die automatisch da hin.
Wenn man sich die Wörter genau anseht stellt man fest, das die unteren drei auch mit System anfangen, aber nach jeweils einem PUNKT noch weitere Wörter folgen. Bei Systems.Collections.Generic sind es sogar zwei Punkte. Dahinter verbirgt sich eine unglaubliche Arbeitsersparnis und ein grundlegendes Konzept der objektorientierten Sprachen wie C# oder Java.
Alles ist schön geordnet nach Funktionen und logischen Zusammenhängen. Systems ist so etwas wie die Basisfunktionalität.
Benötige ich eine Liste um meine Daten schön zu sortieren, so suche ich unter System.Collections .Eine Liste ist ja nichts anderes als eine Sammlung von Daten. Collection = englisch für Sammlung. Heutzutage schwört man auf generics (erklär ich mal später).
Wenn man also eine Collection braucht, die generics unterstützt, sucht man unter collections. den Eintrag generics und schon ist man am Ziel. Es ist wirklich so einfach, für das was wir demnächst vorhaben gibt es schon tausende von Klassen, die uns viel Arbeit abnehmen werden.
Bei (4) kommt dann schon wieder etwas neues:
namespace
Ein Namensraum (namespace) ist etwas sehr wichtiges und mächtig noch dazu. Für heute soll diese kurze Erklärung reichen:
Wenn viele Entwickler an einem Projekt arbeiten kann es sehr schnell vorkommen, dass sie versehentlich zweimal denselben Namen für etwas vergeben. Es liegt zum Beispiel nahe einen OpenFileDialog (zum Datei öffnen) auch genau so zu benennen. Nur doof, wenn es den schon gibt, Namen sind eindeutig und wenn man ihn trotzdem doppelt vergibt kommt es zu einer Fehlermeldung. Um das ganze jetzt trotzdem handhabbar zu machen hat man die Namensräume erfunden. Alles was in einem solchen Raum ist, gehört zusammen. IN einem namespace kann es jeden Variablennamen nur einmal geben, AUSSERHALB so oft wie nötig.
Ihr lasst den mal schön so wie er ist, mehr brauchen wir momentan nicht.
Eine Zeile weiter sehen wir eine geschweifte Klammer { (Alt Gr + 7 ).
Klammern sind ein wichtiges Konzept der meisten Programmiersprachen, sie fassen Code zu einzelnen Bausteinen (Blöcken) zusammen.
Diese Klammer gehört zu namespace HelloWorld . Sie, und ihr Kollege weiter unten ( } in der letzten Zeile) umklammern den gesamten namespace. (Das ist so nicht ganz richtig, reicht aber erstmal)
VS2010 rückt uns die einzelnen Klammern immer schön ein, so sehen wir wer zu wem gehört. Wenn man eine Klammer aufmacht, muss diese auch IMMER wieder zu gehen. Keine Angst, wenn ihr es einmal vergesst nervt VS2010 schon lange genug damit ihr es bemerkt.
Bei (5) steht dann class Programm
Genau so , wie wir gerade eben einen namespace eröffnet haben, beginnen wir hier die eigentliche Klasse.
Dazu sagen wir einfach was wir wollen: hier class als Schlüsslwort das der Entwicklungsumgebung sagt, dass jetzt ne Klassendefinition kommt, und Programm als Name derselben. Alles was jetzt zwischen den beiden Klammern kommt gehört zur Klasse Programm.
Soweit verstanden?
Bei (6) geht es dann endlich mit dem eigentlichen Programmieren los.
Im letzten Kapitel hatten wir uns mal kurz BASIC und seine Zeilennummern angesehen. Das das Programmieren so sehr umständlich gestaltet hat, musste man sich etwas neues einfallen lassen um alles ein wenig besser zu organisieren.
Erste Idee waren sogenannte Methoden und genau so eine sehen wir hier.
Methoden sind kleine Miniprogramme, die einen ganz bestimmten Zweck dienen. So könnte man eine Methode ADDIERE erstellen, die zwei Ganzzahlen (Integer) addiert.
Würde dann ungefähr so aussehen
Code: Alles auswählen
int addiere(int zahl1, int zahl2)
{
return zahl1 + zahl2;
}
Die Methode macht nichts anderes als die beiden Integerzahlen zahl1 und zahl2 zu addieren und das Ergebnis als Ganzzahl zurück zugeben. So kann man ständig benötigten Code einmal schreiben und tausend mal verwenden. Sehr praktisch.
Methoden werden auch Prozeduren oder Funktionen genannt. Eigentlich gibt es da feine Unterschiede, aber oft wird einfach nicht unterschieden. Wundert euch also nicht, wenn ihr wo anders von Funktionen lest.
Wir haben in unserem Programm eine Methode mit Namen Main, das ist die Hauptmethode unseres Programms und unbedingt notwendig.
Wen wir später auf die .exe klicken sucht das Programm nach genau dieser Methode und fängt mit dem in ihr enthaltenen Code an.
Da wir ja keine Zeilennummern mehr haben, müssen wir eben so kundtun wo der Anfang ist.
void bedeutet, dass die Methode kein Ergebnis zurück kommt. Das ist logisch, da das Programm beim erreichen der letzten Klammer schließt. Ein Ergebnis hätte gar keinen Sinn, da niemand mehr da ist der etwas damit anfangen könnte.
static bedeutet, dass die Methode statisch ist, das ist momentan für uns uninteressant. Erkläre ich viel später, akzeptiert es einfach.
in den runden Klammern () verbergen sich Parameter, die der Methode beim Aufruf mitgegeben wurden. Beim addiere Beispiel oben waren dies die beiden Operanden der Addition. Irgendwo her muss die Methode ja wissen WAS sie addieren soll.
Hier haben wir etwas, dass sich string[] args nennt. Das ist etwas kryptisch, wird aber gleich klar.
string bezeichnet eine Zeichenkette, eine Folge von Buchstaben also. Immer wenn wir uns ein Wort im herkömmlichen Sinn merken wollen verwenden wir eine Variable ( sozusagen eine kleinen Bereich im Speicher) vom Typ string. Der Rechner weiß dann selber, wie viel Speicher er dafür reservieren soll und was man mit so was überhaupt machen kann. Wenn man zwei Wörter addiert kommt zum Beispiel etwas völlig anderes dabei heraus als wenn man das gleiche mit einer Ganzzahl (Typ int) macht.
Die Buchstaben 1 + 1 ergeben 11, als int kommt aber 2 heraus.
Das [] bedeutet, dass es nicht nur ein Wort ist, sondern viele. Die beiden Klammer weisen auf eine (fast beliebig große) Reihe hin.
und args ist der name dieser Reihe. args ist kurz für Argumente und damit sind wir wieder bei dem was ihr kennt:
Fast jeder hat doch schon mal den Befehl ping 127.0.0.1 an der Eingabeaufforderung benutzt?
Er überprüft ob wir im Netz die Adresse 127.0.0.1. erreichen können. Im Hintergrund läuft dann ein kleines C++ Programm los.
Es heißt ping und bekommt als Argument 127.0.0.1 . Wir haben hier also ein Möglichkeit unserem Programm beim Start Informationen mitzugeben. Wir werden das voraussichtlich nie benutzen, aber gut zu wissen das es die Möglichkeit gibt. Ihr lasst das mal schön so wie es ist.
JETZT GEHTS LOS!
Wir wollen mit dem Klassiker aller Programme starten. "HELLO WORLD"
Es macht nichts anderes als in die Konsole (das kleine schwarze Fenster, ihr wisst schon) die beiden Wörter Hello und World auszugeben.
Nicht gerade viel, aber doch ein vollständiges Programm.
Jetzt könnte man Googel befragen wie das geht, wir wollen aber logisch vorgehen.
Ich hatte vorhin geschrieben, dass .NET eh schon fast alles kann was wir machen wollen.
Also denken wir erst einmal nach, was wir genau tun wollen.
1. an der Konsole die Zeile "Hello World!" ausgeben.
2. das Programm am Besten noch kurz anhalten damit wird die Ausgabe auch bewundern können.
Nachdem das klar ist, machen wir uns mal auf die Suche nach Klassen die genau das tun.
Console ist englisch für Konsole, also ist es wahrscheinlich, dass wir unter diesem Namen fündig werden.
Gebt einfach mal Console ein und macht einen Punkt dahinter. Was jetzt kommt ist wahre Magie und nennt sich IntelliSense.
VS2010 versucht ständig herauszufinden was ihr gerade machen wollt und schlägt euch das weiter Vorgehen vor.
Sobald ihr Console. geschrieben habt, erscheint ein Auswahlmenü, und sobald wir w auf dem Keyboard drücken springt die Auswahl nach unten in Richtung WriteLine. Das wählen wir aus und schon haben wir die Methode gefunden, die Zeichen auf die Konsole ausgibt.
Oben haben wir erfahren, dass Methoden meistens Parameter erwarten, die ihr sagen was sie genau tun soll.
Die WriteLine Methode der Klasse Console erwartet die Zeichenkette, die geschrieben werden soll, als Parameter in den runden Klammern.
Wenn ihr eine runde Klammer schreibt seht ihr folgendes:
Das aufpoppende Hilfefenster gibt uns nähere Infos darüber, welche Parameter wir der Methode mitgeben können. Hier sind es 19 Variationen, mit den Cursortasten können wir hier durchscrollen.
Wir wollen einen string (eine Zeichenkette) schreiben, also übergeben wir auch so etwas.
Schreibt:
Console.WriteLine("Hello World!");
Die beiden Ausrufezeichen sagen VS2010 dass hier eine Zeichenkette kommt. Zwischen "" sind Leerzeichen und viele Sonderzeichen erlaubt!, es ist ja nur ein bischen Text und hat nichts mit unserem Code zu tun.
Am Ende der Zeile kommt ein Semikolon (;). Dieses beendet den Befehl und ist unbedingt erforderlich.
Eine Zeile weiter schreiben wir dann noch
System.Threading.Thread.Sleep(10000);
Das bedeutet nicht anderes, als dass das System 10000 Millisekunden pausieren soll. Damit wird das schließen des Programms verzögert.
DAS WAR ES SCHON.
Die gesamte Klasse sieht nun wie folgt aus:
Code: Alles auswählen
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace HelloWorld
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
System.Threading.Thread.Sleep(10000);
}
}
}Um unser Werk zu bewundern drücken wir auf den kleinen grünen Pfeil oben in der Menüleiste, oder betätigen die Taste F5.
Damit startet der Compiler von VS2010 und führt das Programm aus nachdem er es übersetzt hat.
Wenn alles richtig funktioniert, seht ihr jetzt eine Konsole in der die Zeile Hello World! steht.
Die Konsole beendet sich nach 10 Sekunden selbständig.
Glückwunsch! Im nächsten Kapitel nehmen wir dann Fahrt auf und werden die Komplexität unserer Software deutlich steigern.
Wir werden lernen wie man Eingaben abfragt, Sachen addiert und Dinge wiederholt ablaufen lässt.