Programmieren lernen Kapitel 6 Windows Forms

Tutorials zu verschiedenen Softwarenutzungen

Moderator: Moderatoren

Benutzeravatar
Jaegerfeld
Tribunus Angusticlavius
Tribunus Angusticlavius
Beiträge: 3571
Registriert: 10. November 2010 21:15
Wohnort: AudiCity
:
Pfeiler der Community Gewinner Userwahl

Programmieren lernen Kapitel 6 Windows Forms

Beitragvon Jaegerfeld » 12. Dezember 2010 15:54

Kapitel 6

Windows Forms


In diesem und den folgenden Kapiteln wollen wir unserem Rechner endlich eine grafisch ansprechende Oberfläche verpassen.

Um euch schon mal ein wenig mit Vorfreude zu erfüllen, hier ein Screenshot des fertigen Produktes:

Bild


Sieht doch recht ansprechend aus? Jedenfalls, wenn man weiß dass ich dafür ca. 15 Minuten benötigt habe.Für das reine Design sogar nur zwei.

Bevor wir uns aber in die Arbeit stürzen, will ich hier den Taschenrechner noch einmal kurz umreissen.
Er wird die 4 Grundrechenarten beherrschen.
Er wird mehr als eine Operation am Stück abarbeiten können.
Er wird das Ergebnis von links nach rechts berechnen. Punkt vor Strich oder so findet nicht statt.

Damit ist er zwar kein vollwertiger Ersatz für den Windows bordeigenen, aber das sollte auch niemals das Ziel sein.

Wer trotzdem daran weiterarbeiten will, kann das später gerne mit mir diskutieren, Auch ein Graphenplotter wie bei echt teuren Rechnern ist kein wirklich großes Problem. Wir wollen uns aber nur ein wenig beüben, um dann in 2-3 Wochen einen schönen Editor für unser Adventure erstellen zu können.

Wie habe ich das nun gemacht?

Die Lösung ist relativ einfach, .NET bringt nämlich schon eine Menge Klassen mit, die sich um die Darstellung und Erschaffung einer schönen GUI kümmern. Um dem ganzen die Krone aufzusetzen gibt es auch noch einen netten Point & Click Editor, mit dessen Hilfe wir das Nötigste sehr rasch zusammenbasteln können.

Startet ein neues Projekt und wählt diesmal Windows Forms-Anwendung.

Bild

WPF ist übrigens auch etwas, mit dem wir eine GUI erschaffen können. Damit würde die sogar noch VIEL schöner werden. Leider müssten wir uns dann auch noch mit einer zweiten Sprache (XAML) herumschlagen. Das ist ein wenig viel für den Anfang, wir nehmen uns erst mal die Basics vor.

Nach dem Laden des Projektes fällt erst mal auf, das VS schon eine Menge vorarbeit geleistet hat und es so etwas wie ein Editorfesnster gibt.

Bild

Wenn wir uns den Projektmappen Explorer genau ansehen, erkennen wir zwei .cs Dateien. da steht ja unser Code drinn, nur seltsamer Weise ist die eine (Form1.cs) offenbar geteilt, denn wenn wir auf das kleine Dreieck klicken geht ein Baum auf und offenbart uns zwei neue Dateien.

Schauen wir uns aber zuerst mal die programm.cs(2) an. Klickt einfach mal drauf und begutachtet den Code.

Eigentlich steht da fast gar nichts drinn:

Code: Alles auswählen


static class Program
{
/// <summary>
/// Der Haupteinstiegspunkt für die Anwendung.
/// </summary>
[STAThread]
static void Main()
{
  Application.EnableVisualStyles();
  Application.SetCompatibleTextRenderingDefault(false);
  Application.Run(new Form1());
}

}


Es gibt eine main Methode, das ist der Punkt an dem unser Programm beginnt. Offenbar gibt es sowas wie eine Applikation und mit der geschieht etwas.

Jetzt sind wir voll in der objektorientierten Programmierung (OOP) angekommen und es wird nötig das Konzept dahinter kurz zu erläutern.

OOP ist nichts böses (wie manche uralt Programmierer immer noch meinen), sondern erleichtert das Entwickeln von komplexen Programmen ungemein. Bisher habt ihr einfach Code aneinander gereiht, alles war in einer Datei und wenn man jetzt darüber nach denkt wie groß eine Datei mit 1 Million Zeilen sein müsste und wie gut man sich darin zurechtfinden würde...........

....... das wird nichts, das haben die Informatiker in den 80er/90ern auch erkannt.

Also hat man versucht den Code in kleine, handhabbare Häppchen zu zerteilen.

OOP versucht nichts anderes als alle Funktionalität in logisch zusammenhängende Häppchen zu teilen und sie voneinander unabhängig zu machen. Es gibt eine Klasse, die sich um Texteingaben kümmert, eine berechnet Ergebnisse und eine andere speichert das dann auf die Festplatte. Miteinander verbunden werden die einzelnen Module über Schnittstellen. Das hat den Vorteil, dass man jederzeit den Code IN einer Klasse verändern kann, Hauptsache die Schnittstelle bleibt gleich. Mein Code wird also sehr viel wartbarer und vor allem können wir so später einfach neue Funktionalität hinzu nehmen ohne alles neu schreiben zu müssen.

Der ganze Vorgang nennt sich Kapselung. Man gibt eine Aufgabe an eine Klasse und die macht dann etwas mit den empfangenen Daten.

WAS und WIE sie das macht sieht man von aussen nicht. Von außen betrachtet gibt man ihr nur was und empfängt dann irgendwann das Ergebnis.

Eine Klasse DATA könnte zum Beispiel am Anfang einer Entwicklung empfangene Daten auf der Festplatte ablegen.

DATA.save(daten) würde also die Daten einfach auf die HD speichern.

Später wollen wir vielleicht aber in einen Datenbank speichern. Haben wir sauber OO programmiert müssen wir nur die methode save() der Klasse DATA ändern. Ab da wird dann bei DATA.save(daten) alles in die Datenbank geschoben. Wir müssen also nicht hunderte von Files durchsuchen wo überall mal was abgespeichert wird. Das ist eine riesen Zeitersparnis und hat außerdem den Vorteil, dass sich der Mensch mit solchen Modulschemas viel einfacher tut als mit klassischer Programmierung. Unser Gehirn arbeitet ähnlich.

Das .NET Framework besteht aus tausenden solcher Klassen, die alle ganz bestimmte Aufgaben übernehmen.
Ihr kennt schon Console, diese Klasse kümmert sich um alles was die Konsole betrifft.
Eine Klasse ist aber nicht weiteres als ein Bauschema, sie sagt uns wie man ein Konstrukt erschaffen könnte das die benötigte Funktionalität bereit stellt. Sozusagen der Bauplan.
Nun kann man aber in einem Bauplan nur sehr eingeschränkt wohnen :-), ein echtes Haus wäre schon fein.

Will man ein Modul erzeugen, das die in der Klasse (Bauplan) beschriebenen Funktionen beherrscht, so muss man ein Objekt(Haus) der Klasse erzeugen. Das geht denkbar einfach, man muss nur das Object wie einen ganz normalen Datentyp deklarieren und anschließen initialisieren.

Also einfach so etwas:

Code: Alles auswählen

Object neuesObject;


Die Initialisierung ist da schon um einiges komplizierter, jede Klasse ist anders und so ist es schwer im Vprgriff zu wissen wieviel Speicher das Objekt benötigen wird.
Wir müssen das dem Rechner sagen, das geschieht einfach hiermit:

Code: Alles auswählen

neuesObject = new Object();


new sagt dem Rechner, dass wir eine Instanz der Klasse Object erzeugen wollen. Die () hinter Object rufen den Konstruktor der Klasse auf.
Der Konstruktor ist eine besondere Methode, die jedes Objekt hat. Er initialisiert unser Objekt mit sauberen Werten.
Wir werden das später genauer betrachten, hiermit kann man nämlich Objekte mit Werten vorbelegen usw.
Ist also gar nicht so sehr anders wie bei den sogenannten primitiven Datentypen int, double etc. .
danach kann man über den . (Punkt) auf die Methoden eines Objektes zugreifen.
Wenn man Methoden oder Variablen benötigt, die auch ohne ein echtes Objekt funktionieren sollen, so muss man vor den Rückgabetyp der Methode das Schlüsselwort static setzen.
Dann wird dieses EINMAL für ALLE Objekte dieses Typs im Speicher abgelegt und alle greifen auf dieses zu. Damit wäre auch das Rätsel des static gelöst.

So werden zum Beispiel Mathematik - Klassen gelöst.
Die Klasse Math stellt und z.B. den Sinus zur Verfügung. Jetzt will man aber nicht immer erst ein Object der Klasse Math erzeuge, wenn man mal kurz den Sinus eines Winkels benötigt.
Also sind die Methoden der Klasse Math static.

Wenn wir uns jetzt noch einmal die main Methode der Klasse Programm ansehen, sehen wir das dort drei Methoden der Klasse application aufgerufen werden.

Die letzte nennt sich run und startet sozusagen die GUI.
Als Parameter wird ihr ein soeben erzeugtes Object der Klasse Form1 übergeben.

Dann schauen wir uns die doch gleich mal an.

Die Klasse Form1 ist seltsamerweise geteilt. Das liegt daran, dass in Windows Forms strikt die grafische Darstellung (also das Fenster mit den Buttons etc.) von der Programmlogik (also das was passiert wenn wir einen Button anklicken) getrennt ist.
Der Code, der zur Darstellung der einzelnen Buttons etc. (Komponenten genannt) dient ist in der Datei Form1.Designer.cs.
Momentan steht da noch nicht viel und die gute Nachricht ist: VS füllt die ganz alleine aus, wir müssen uns erst mal nicht um die kümmern.

Wenn wir auf Form1.cs im Explorer doppelklicken geht das Entwurfsfenster(1) aus, das ist jetzt das Herzstück unseres GUI Designers.

Bild

Ganz links sehen wir einen Karteireiter, der sich Toolbox nennt. Geht mal mit der Maus drauf und bestaunt eure GUI Komponenten.
All die Dinge die wir hier sehen können wir per einfachem Drag & Drop in unsere GUI übernehmen. Zieht einfach mal einen Button in das Fenster und staunt.
Wenn die erste Freude verflogen ist, versucht ein Fenster wie ganz oben gezeigt zu designen.

Ihr benötigt hierzu 17 Buttons und 1 Textbox. Die ganzen Komponenten werden übrigens auf MSDN ausführlich erklärt.

Jede Komponenten hat auch viele Einstellmöglichkeiten, klickt einfach mit der rechten Maustaste auf eine Komponente in der GUI und wählt Eigenschaften.

Bild
Mit dem Feld "Text" kann man die Beschriftung eines Buttons verändern. Ganz oben in der Liste befindet sich auch der Name der Komponente.

Ich habe die Namen

  • Button0 bis Button9
  • ButtonErgebnis
  • ButtonPlus
  • ButtonMinus
  • ButtonMal
  • ButtonGeteilt
  • ButtonClear
  • ButtonBack und
  • TextboxAnzeige
vergeben.

Nennt die auch so, dann tut ihr euch später leichter meinen Code zu übernehmen.


Habt ihr das alles geschafft, ist unsere GUI auch schon fertig.
Ihr könnt das ausprobieren indem ihr das Programm mit dem grünen Pfeil startet.
Sieht schon mal toll aus, fehlt nur noch die Funktionalität.

Die kommt im nächsten Kapitel.
„Ich schätze mal, das kann jeder Online-Community passieren. Irgendwann stellen die höflichen und vernünftigen Leute fest, dass sie sich in dieser Gruppe nicht mehr aufhalten wollen. Also verschwinden die. Und diejenigen die übrig bleiben, erfahren nur noch die Leute die genau so wie sie drauf sind.“

=== David Gaider, Bioware ===