Hier findest du die neue Inventor FAQ

Das ist der siebte Teil des VB-Kurses. Was bisher geschah (als Neueinsteiger bitte erstmal diese Teile durchlesen!):

Programmieren in Visual Basic – Eine Einführung – Teil 1
Programmieren in Visual Basic – Eine Einführung – Teil 2
Programmieren in Visual Basic – Eine Einführung – Teil 3
Programmieren in Visual Basic – Eine Einführung – Teil 4
Programmieren in Visual Basic – Eine Einführung – Teil 5
Programmieren in Visual Basic – Eine Einführung – Teil 6

Objekte und Klassen

Im letzten Teil haben wir was über Klassen und Objekte kennengelernt. Ihr erinnert euch vielleicht noch an den Vergleich mit der Inventor iPart-Mutter und den Kindern, die daraus entstehen. Anscheinend ist in VB.net alles ein Objekt, selbst eine Variable, weil auch die Methoden hat. Das merkst du dann, wenn du nach dem Variablennamen einen “.” (Punkt) schreibst.

Hier mal ein Beispiel:

Sub Main()
Dim intZahl As Integer
Dim strZahlalsString As String
intZahl = 12
'"Objekt" Variable intZahl vom Typ Integer wird mittels Methode "ToString" in einen String umgewandelt.
strZahlalsString = intZahl.ToString()
'Ausgabe der String Variable
Console.WriteLine(strZahlalsString & " war mal eine Zahl")
Console.ReadLine()
End Sub

Zum Thema Objektorientierte Programmierung (OOP) liese sich noch viel sage z.B. ist in diesem Zusammenhang von Vererbung, Kapselung, “Namespaces” und “was weiss ich noch was alles” die Rede. Mich düngt das alles recht kompliziert, weswegen wir uns mal wieder auf das Programmieren besinnen wollen. Kapseln und vererben können wir dann immer noch später ;)

Forms und Fenster

Bisher haben wir “nur” Konsolenprogramme erstellt aber das wird sich jetzt ändern. Wir machen heute unser erstes Programm mit Fenstern. Los geht’s! Visual Studio starten, Datei > Neues Projekt und dann “Windows-Anwendung” wählen.

Nach kurzer Zeit erscheint ein Fenster in der ein grauer Kasten zu sehen ist – ein “Form”. Dieses Form stellt das Grundfenster unserer Anwendung dar. Mit den Griffen an den Kanten könnt ihr es großer und kleiner ziehen. Sobald ihr das macht, werden ihr sehen, das die Zahlenwerte des Eintrags “Size” rechts im Eigenschaftenfenster fett geschrieben werden. Genauso gut könnt ihr also die Größe dort pixelgenau eingeben.

So ein “Form” hat recht viele Eigenschaften die sich mittels Programmcode oder in diesem Eigenschaftenfenster ändern lassen. Die Eigenschaft “Name” gibt den Namen an, mittels dem in einem Programmcode das Form angesprochen wird. Ich ändere den mal auf “Fenster1″. Zudem gibt es noch die Eigenschaft “Text” die dem Titel des Forms entspricht. Den ändere ich auf “mein erstes Windowsprogramm”. Das war’s schon. Das Programm ist fertig und wir können es mit F5 starten. Es erscheint ein leeres Fenster das wir mit dem Kreuz oben rechts wieder schließen können. Das Programm macht noch nicht übertrieben viel, aber Programm ist Programm, oder ;).

Wir haben noch keine Zeile programmiert und schon ein Programm. Nun soll sich aber beim Start des Programmes etwas tun. Das Fenster soll sich in der Größe ändern wie wenn wir daran mit der Maus ziehen. Zum Programmcode des Form kommen wir durch einen Doppelklick auf das Form. Wir landen in der Codenansicht zu dem Form und sehen oben einen Eintrag “Fenster1-Ereignisse” und rechts davon “Load”. Darunter ein paar Zeilen Code der u.a. “Private Sub Fenster1_Load …. Handles MyBase.Load”. Warum steht das da? Weil oben “Ereignisse” und rechts davon das Ereignis “Load” steht. Denn Programmcode den wir nun eingeben, wird beim Laden des Form (”Load” = Laden des Forms) ausgeführt. Wir wollten das Fenster dynamisch vergrößern sagen wir von 200×200 auf 400×400 Pixel. Dazu brauchen wir eine For-Next-Schleife und ein ein paar Eigenschaftszuweisungen.

Public Class Fenster1
Private Sub Fenster1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
Dim x As Integer
For x = 200 To 400
Me.Size = New Size(x, x)
Me.Show()
Next
End Sub
End Class

Die Schleife ist, denke ich, klar. Wir zählen x von 200 bis 400. Innerhalb dieser Zählschleife weisen wir der Eigenschaft “Size” (die wir eben schon manuell geändert haben) des Forms den x-Wert als Größe zu und aktualisieren dann die Darstellung mittels “Me.show ()”. Da wir uns ja programmiertechnisch innerhalb des Forms befinden wird “Me”, engl. für “ich” verwendet, nach dem Motto “Ich.Größe = Neue Größe (x ,x). Wenn wir nun F5 drücken, dann wird das Fenster angezeigt und wie von Geisterhand vergrößert.

Steuerelemente

Das Salz in der Suppe eines Windowsprogrammes sind die Steuerelemente wie Buttons und Textfelder. Steuerelemente können wir über die Toolbox links in der Visual Basic IDE auswählen. Sollte die Toolbox nicht sichtbar sein, dann auf das Register rechts klicken und dann oben auf die Sicherheitsnadel. Zudem kann in dem Fenster oben über die Register zwischen dem Programmcode und der Form Entwurfsumgebung umgeschaltet werden sobald der Quelltext einmal mittels Doppelklick auf das Form aktiviert wurde.

Wir brauchen in unserem Fenster auf alle Fälle einen “Abbrechen” Button. Dazu fügen wir einen Button ein indem wir

a) Auf den Button in der Toolbox doppelklicken (er wird oben links in das Form eingefügt)
b) Den Button aus der Toolbox per Drag&Drop in das Form ziehen
c) Den Button in der Toolbox anklicken und dann im Form einen Button aufziehen.

Wie das Form hat der Button auch Eigenschaften. Die Eigenschaft “Name” (=Name des Buttons im Programmcode) und “Text” (=Buttonbeschriftung) setzen wir mal auf “Abbrechen”. Durch einen Doppelklick auf den Button wechseln wir uns Codefenster und sehen dort ein Sub das darauf achtet, ob der Button angeklickt wird (Privat Sub Abbrechen_Klick…). Wenn auf den Button geklickt wird, soll sich das Fenster schließen. Wir sagen wieder wer was machen soll oder in VB-Sprache

Me.Close

Me = das Form und Close = schließen. Logisch oder? (Hier ein spezieller Gruß an meinen Kollegen Mathias, er weiss warum ;) )

Das Programm wieder mittels F5 starten und mal den neuen “Abbrechenknopf” anklicken. Schließt sich das Programm wieder? Prima!

Den Programmcode zum Vergrößern des Fensters beim Starten können wir wieder löschen und dafür fügen wir noch einen Button und 3 Textboxen hinzu.

Der Button bekommt den Namen und Text “Addieren”. Das Programm soll gleich die Werte aus Textbox1 und Textbox2 addieren und das Ergebnis in Textbox3 schreiben. Kinderfest oder? Wichtig ist zuerst mal, zu definieren wann was passieren soll. Rechnen soll er beim Klick auf den Button “Addieren” also muss dort auch der Programmcode rein. Die ganze Fehlerbehandlung schenken wir uns in diesem Beispiel, d.h. wenn einer anstatt eines Zahlenwertes “Kartoffelsalat” eingibt wird er als Ergebnis eine Fehlermeldung bekommen.

Wir brauchen 3 Variablen die wir Wert1, Wert2 und Ergebnis nennen, natürlich mit dem entsprechenden Präfix. Den Variablen Wert1 und Wert2 weisen wir die Werte aus den Textboxen zu, addieren dann die Werte in die Variable “Ergebnis” und schreiben dann den Wert von Ergebnis in die Textbox3. So schaut das “Klickereignis” auf den “Addierenbutton” dann aus.

Private Sub Addieren_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Addieren.Click
Dim dblWert1, dblWert2, dblErgebnis As Double
dblWert1 = TextBox1.Text
dblWert2 = TextBox2.Text
dblErgebnis = dblWert1 + dblWert2
TextBox3.Text = dblErgebnis
End Sub

Das war’s für heute zum Thema VB. Bis demnächst!

Bisherige Artikel zum Thema “Programmieren in Visual Basic”:
Programmieren in Visual Basic – Eine Einführung – Teil 1
Programmieren in Visual Basic – Eine Einführung – Teil 2
Programmieren in Visual Basic – Eine Einführung – Teil 3
Programmieren in Visual Basic – Eine Einführung – Teil 4
Programmieren in Visual Basic – Eine Einführung – Teil 5
Programmieren in Visual Basic – Eine Einführung – Teil 6