Autodesk Inventor FAQ: Programmieren in Visual Basic – Eine Einführung für Inventoranwender

Hier meine Programmieranleitung für Inventoranwender die noch keine Ahnung vom Programmieren haben (so wie ich ;) ). Die Anleitung ist schon etwas älter, aber vielleicht hilft sie ja dem einen oder anderen.

Teil 1

Ich habe mich entschlossen, das Thema VB-Programmierung anzugehen. Und weil es sicherlich noch andere FAQ-Besucher gibt, die sich gerne mal ans Programmieren wagen wollen, mache ich daraus eine Artikelreihe in der Inventor FAQ.

So ein Artikel birgt natürlich ein gewisses Risiko, den erstens bin ich kein Programmierprofi sondern steige gerade in das Thema ein und somit ist die Gefahr groß, Unsinn zu schreiben (und wer schreibt schon gerne wirres Zeugs in der Öffentlichkeit) und zweitens werden ich, wie bei allem, was die Inventor FAQ betrifft, nichts erzwingen, d.h. wenn ich merke, das mir das Programmieren (und/oder darüber schreiben) keine Spaß mehr macht, ist die Artikelreihe schnell wieder vorbei. Wenn einer also schon mehr Programmierungerfahrung hat, nicht zögern und mit der Kommentarfunktion Tipps, Tricks und Korrekturen angeben!

Ich bin mir über den Umfang und den Inhalt dieser Artikelreihe noch gar nicht ganz im Klaren, d.h. die Artikelreihe ist eher als ein “Ich lern jetzt VB”-Tagebuch zu sehen. Wir werden sehen, wo die Reise hin geht.

Das brauchen wir für den erfolgreichen Start

Die Entwicklungsumgebung

Um Programmieren zu können, braucht man ein Programmierumgebung. Die gibt es von Microsoft kostenlos, nennt sich “Visual Basic 2005 Express Edition” und kann hier heruntergeladen werden. Zur Aktivierung ist ein Live-Account notwendig, den man sich kostenlos einrichten kann.

Was unterscheidet die “Express Edition” von einer kostenpflichtigen Vollversion? Das sagt Microsoft dazu:

Visual Basic Express Edition ist ein leistungsstarkes Tool, mit dem Sie vollständig funktionale Anwendungen und Komponenten erstellen können, die für andere Benutzer freigegeben werden können. Es ist jedoch nicht für professionelle Entwickler oder Programmierer konzipiert, die in einer Teamumgebung arbeiten. Andere Versionen von Visual Basic enthalten Features, die den umfassenderen Anforderungen der professionellen Entwicklung im Team gerecht werden.

Wenn Sie Anwendungen schreiben müssen, die mit einer im Netzwerk verwalteten Datenbank verbunden werden müssen, die mit Microsoft Office interagieren müssen, die tragbare Geräte oder 64-Bit-Betriebssysteme unterstützen müssen oder Remotedebuggen erfordern, benötigen Sie eine komplexere Version von Visual Basic.

(Quelle: http://msdn2.microsoft.com/de-de/library/we1f72fb(VS.80).aspx)

Wir sehen, dass die Express Edition für uns ausreichend sein dürfte.

Ein bischen Literatur

Onlineresourcen

VB Buch als PDF Dokument: http://www.galileocomputing.de/openbook/vb_net/ unten links findest du den Downloadlink für das Buch.
VB Tutorial in deutsch: http://www.activevb.de/rubriken/vbdotnet/introvbnet/introvbnet.html
Online-Anleitung von MS: http://msdn2.microsoft.com/de-de/library/90h82b3x(VS.80).aspx

Bücher

Wem es so geht wie mir, der arbeitet lieber mit einem gedruckten Buch, z.B. einem von diesen:

Sobald das Visual Basic 2005 Express Edition heruntergeladen und installiert ist, geht’s weiter mit Teil 2 von Programmieren in Visual Basic – eine Einführung.

PS: Wenn du bereits mehr VB-Erfahrung gesammelt hat, kannst du dich gerne als Gastautor an dieser Artikelreihe beteiligen. Nimm dazu einfach Kontakt mit mir auf.

PPS: Wenn einer seine Erfahrungen und Meinung zu diesem Thema loswerden will, einfach einen Kommentar hinterlassen.

Programmieren in Visual Basic – Eine Einführung – Teil 2

Es ist wie im Inventor – Am Anfang ist das Projekt

Wenn du die Entwicklungsumgebung (IDE) heruntergeladen und installiert hast und Anfangen willst zu programmieren, dann mach das gleich wie im Inventor: Mach ein neues Projekt (Da fühlt man sich doch gleich „wie zu Hause” ;) ). Die Funktion dazu findest du im Menü Datei > Neues Projekt (STRG+N). Daraufhin öffnet sich das Projektfenster und du kannst den gewünschten Projekttyp wählen und unten den Namen des Projekts eingeben. Wenn du das vergisst, ist es auch kein Problem, denn wenn du auf „Alles Speichern” klickst (oder im Menü „Datei” aufrufst) kannst du deinem Projekt einen Namen geben und den Speicherort angeben. Willst du einen Standardspeicherpfad einstellen, gehen in das Menü Extras > Optionen und dort Links auf „Projekte und Projektmappen”. Nun kannst du im rechten Fensterbereich bei „Speicherort der Visual Studio-Projekte” einen Standardspeicherort für all deine VB-Projekte einstellen.

Mein erstes Programm

Wähle als Projekttyp eine „Konsolenanwendung” (Das sind die „Dinger”, die in der Befehlszeile (Start > Ausführen > cmd) ausgeführt werden, z.B. die ganzen DOS-Befehle wie „dir” oder „copy”) und drücke OK. Nun hast du ein VB-Projekt und rechts den Projektmappen-Explorer, der, wieder ähnlich dem Inventor Featurebaum, die Elemente des Projekt enthält. Mach einen Doppelklick auf „Module1.vb” und du siehst das Grundgerüst deines ersten Programms.

Das erste Modul einer Konsolenanwendung heißt immer „Module1″ und hat die Dateiendung „.vb”. Innerhalb des Quellcodes unseres Grundgerüsts gibt es ein Modul und darin wiederum eine Prozedur Sub Main, in der die eigentliche Programmlogik definiert wird. Die Prozedur „Main” muss in einer Konsolenanwendung immer enthalten sein, weitere dürfen definiert werden allerdings nicht mehr unter dem Namen „Main”. Eine Prozedur hat immer einen Prozedurdefintion (z.B. Sub Main () ) und eine Ende (End Sub).

Module Module1

Sub Main()
End Sub
End Module

EDV = Elektronische Daten Verarbeitung

Unser Programm, wie so ziemlich alle Programme auf dieser Welt, soll Daten verarbeiten. Damit es das kann, muss es Daten irgendwo abspeichern. Diesen Ort nennt man „Variable”. Variablen haben bestimmte Eigenschaften, nämlich einen Namen, den sog. „Bezeichner”, einen Datentyp (=welche Art von Informationen nimmt die Variable auf? Zahlen, Text,…) und einen „Wert” oder Inhalt. In VB müssen (bzw. sollten, es geht auch ohne vgl. explizite/implizite Deklaration) Variablen zuerst „deklariert” werden um ihnen dann einen Wert zuzuweisen. Das ist so ähnlich wie in Mathe (na, sagen wir grob). Erst wird die Variable deklariert

Dim x as Integer

(Dim ist der Befehl für die Deklaration, x der Variabelname (=Bezeichner), as= engl. für „als” und „Integer” als Datentyp was einer Ganzzahl entspricht.)

Dann kann ich der Variable einen Wert zuweisen z.B.

x = 5

Wenn wir das nun in unserem Programmcode eintragen, dann haben wir schon ein prima Programm:

Module Module1

Sub Main()
Dim x As Integer
x = 5
End Sub
End Module

EVA – Erste Frau und Prinzip unseres Programms

EVA steht für Eingabe, Verarbeitung, Ausgabe (So ein Käse hab ich mal in der Schule gelernt). In unserem Fall haben wir bereits eine Eingabe im Programm gemacht, nämlich der Variable „x” den Wert 5 zugewiesen. Jetzt machen wir uns an die Verarbeitung. In unserem Fall wollen wir den Wert von x quadrieren.

x = x * x

Und nun die Ausgabe. Der neue Wert für x soll in der Befehlszeile ausgegeben werden. Dazu nutzen wir gleich mal ein „Objekt” bzw. eine „Klassendefinition” (was immer das auch sein soll. Dazu kommen wir sicherlich noch ;) ).

Die Klassendefinition heißt „Console” (das englische Wort für das DOS-Fenster). In dieser Console wollen wir was machen, nämlich den Wert von x ausgeben.

Console.WriteLine("Wert = {0}", x)

Das bedeutet im Einzelnen: Wir sagen dem Objekt „Console” das wir von ihm was wollen, nämlich dass es einen Wert ausgibt. Das ist macht die Angabe „WriteLine” die durch einen Punkt vom Objekt getrennt wird. Dann wird in Klammer ein Ausgabetext angegeben („Wert = {0}” wobei die Null ein Platzhalter für den eigentlichen Variablenwert ist, der nach dem Komma steht). Das kann man sich auch so vorstellen: Wenn Frau das „Objekt” ist dann ist „BierHolen” die Methode und die Angabe in Klammer welche Biersorte man gerne hätte.

Frau.BierHolen („Weizen")

(Sollte eine Frau mitlesen, ersetzen Sie Frau durch Mann und BierHolen durch MuellRausbringen)

(An alle Programmierprofis: Ich hoffe, der Vergleich hinkt nicht zu sehr)

Unser Programm sieht jetzt so aus:

Module Module1

Sub Main()
Dim x As Integer
x = 5
x = x * x
Console.WriteLine("Wert = {0}", x)
End Sub

End Module

Nun starten wir unser erstes Programm indem wir einfach „F5″ drücken. Wenn es dir so geht wie mir, dann kommt jetzt eine wilde Fehlermeldung wg. Sicherheit. Mach dann im Projektmappen-Explorer rechts einen Doppelklick (sollte der nicht da sein, drücke STRG+R), mach dann einen Doppelklick auf „My Project” und klicke in der Dialogbox die folgt links auf „Sicherheit” und dann rechts im Fenster auf „ClickOnce Sicherheitseinstellungen aktivieren” und wähle die Option „Voll vertrauenswürdige Anwendung”. Damit wurde zumindest bei mir die Sicherheitsmeldung abgeschaltet. Wenn du nun das Programm nochmals ausführst, wird kurz ein DOS-Fenster geöffnet und sofort wieder geschlossen. Also fügen wir noch eine Eingabeanfrage hinzu.

Console.ReadLine()

Wir sagen dem Consolen-Objekt, das es eine Eingabe anfordern soll, d.h. die DOS-Box bleibt auf, bis wir die Eingabetaste drücken.

Übrigens: Kommentare in Quelltexten sind wichtig. Die schreibt man mit einem Hochkomma davor.

'mein erstes VB.NET Programm

OK, das wars für heute. Das ist das Programm…

Module Module1Sub Main()
'mein erstes VB.NET Programm
Dim x As Integer
x = 5
x = x * x
Console.WriteLine("Wert = {0}", x)
Console.ReadLine()
End Sub
End Module

…Und das das Ergebnis

Ich finde, das ist doch gar nicht so übel. Besser als „Hallo Welt” ;)

Bis demnächst im dritten Teil von „Programmieren in Visual Basic”.

Programmieren in Visual Basic – Eine Einführung – Teil 3

Los geht’s mit Teil 3 unseres kleinen “Programmierkurses” für VB. Solltest du neu eingestiegen sein, schau dir vorher Teil 1 und 2 an.
Beim letzten mal haben wir ein Konsolenprogramm erstellt, das so aussah:

Module Module1Sub Main()
'mein erstes VB.NET Programm
Dim x As Integer
x = 5
x = x * x
Console.WriteLine("Wert = {0}", x)
Console.ReadLine()
End Sub
End Module

Das Programm enthielt eine Variable “x” der der Wert “5″ zugewiesen wurde. Dann würde die Variable mit sich selbst multipliziert und anschließend ausgegeben.

Kommentieren, Kommentieren, Kommentieren

Wie du dir sicherlich vorstellen kannst, liest sich der Quelltext eines Programmes für die meisten nicht wie ein Asterix-Heftchen, d.h. nicht immer weisst du, welche Stelle in dem Programm was macht. Damit du und andere später noch durchblicken, setzen Kommentare in den Quelltext. Das machst du, indem du ein Hochkomma vor den Text stellst also z.B.

'Hier berechnen ich den Umfang der Erde anhand der Mondphasen

Lieber setzt du einen paar Kommentare zuviel, als zu wenige!

Quelltext und dessen Darstellung

Normalerweise interpretiert VB den Zeilenumbruch als Anweisungsende. Willst du mehrere Anweisungen in eine Zeile schreiben, trenne Sie mit einem Doppelpunkt:

Dim x As Integer : x = 5 : x = x * x

Wird eine Anweisungszeile sehr lange, kannst du Sie auch in mehrere Zeilen umbrechen und zwar, indem du einen Unterstrich ans Zeilenende setzt. Allerdings darfst du den nicht mitten in einer Zeichenfolge setzen:

Console.WriteLine _
("Wert = {0}", _
x)

Variablendeklaration

“Hey, das Thema hatten wir doch schon” denkst du jetzt vielleicht. Stimmt, aber noch nicht ausführlich genug. Wie wir wissen ist das “x” oben in dem Programm eine Variable. Jetzt stell dir vor, du schreibst ein CAD-Programm. da brauchst du vielleicht tausenden von Variablen. Willst du die alle x,y,z,a,b,c,d,e,f,g,… nennen? Spätestens nach der 15ten Definition weisst du nicht mehr, für was x,y,z,a,b,c,d usw. stand. Am besten man vergibt “sprechenden Namen” (so wie bei den Parametern in Inventor eben. Also anstatt d3 laenge und anstatt d47 eben bohrungsabstand_x). Machs also so wie in Inventor und du weisst, was was ist. Zudem dürfen Variablen nicht mit Zahlen anfangen, nur aus Zahlen, Buchstaben und dem Unterstrich bestehen usw. Also einfach vernüftige Namen vergeben. Zudem ist es üblich, einen Prefix an den Variablennamen zu stellen, der den Variablentyp definiert. Unser “x” sollte also richtigerweise so deklariert werden:

Dim intZahl As Integer

Zudem kann sofort der Wert der Varible definiert werden, also z.B.

Dim intZahl As Integer = 5

Zu diesem Thema gibt es von Microsoft eine Empfehlung. Lass dich aber nicht mehr verwirren davon:http://support.microsoft.com/kb/110264 (Abschnitt: Namenskonventionen für Variablen und Routinen)

Übrigens: Dezimalzahlen schreibt man gleich wie in ACAD auch, nämlich mit einem “Punkt”.

Dim sngKommazahl As Single = 12.433

(sng = Datentyp “Single”).

Globale und lokale Variabledefinitionen

So, jetzt wird es noch eine Ecke abgefahrener: Wir können Variablen im Modul definieren oder in einer Prozedur. Definieren wir eine Variable auf Modulebene haben wir 2 Möglichkeiten: Wir definieren Sie mit dem Schlüsselwort “Private” so gilt sie in dem Modul und allen Prozeduren. In diesem Bsp. kann die Variable “strName” in alle allen Prozeduren innerhalb des Moduls “Module1″ genutzt werden also in “Main” und “nocheine”.

Module Module1
Private strName As String
Sub Main()
strName = "Juergen"
End Sub
Sub nocheine()
strName = "Seppel"
End Sub
End Module

Wird die Variable als Public definiert, kann Sie sogar in allen Modulen genutzt werden.

Wenn wir innerhalb einer Prozedur eine Variable definieren, dann kann diese mittels “Dim” und “Static” definiert werden. Dim definiert eine Variable (das haben wir ja schon gemacht). Wird die Prozedur verlassen wird der Variblenwert gelöscht. “Static” definiert ebenfalls eine Variable, nur das der Variablenwert nach dem Verlassen der Prozedur gespeichert bleibt. (Puuh, ist das heute viel Theorie…).

Mein zweites Programm

Jetzt wird es Zeit für ein bischen Praxis! Wir wollen unser Programm ein wenig ausbauen. Momentan heisst die Variable noch “x” und das ist, wie wir gelernt haben, nicht so toll. Also benennen wir diese um und deklarieren Sie als Datentyp “Single” dann kann sie auch Dezimalwerte annehmen.

Dim sngZahl As Single

(sng = Angabe was für ein Var.Typ es ist. Das ist kein Muss, macht es aber anscheinend leicher, den Quelltext zu lesen)
Zudem wollen wir einen Wert eingeben und nicht mehr nur, das die Zahl 5 mit sich selbst multipliziert wird. Dazu nutzen wir eine “Funktion”, die wir schon kennen, nämlich “Console.ReadLine”. Den Wert, der dieser Befehl abfragt weisen wir der Varible “sngZahl” zu. Das passiert mittels

sngZahl = Console.ReadLine

Nun lassen wir den Kollege Computer wieder rechnen und schon haben wir einen “Taschenrechner für Arme” der so aussieht:

Module Module1Sub Main()
'mein zweites VB.NET Programm
'Variablendeklaration
Dim sngZahl As Single
'auslesen der Befehlszeile und Übergabe des Wertes an die Variable
sngZahl = Console.ReadLine
'Variable mit sich selbst multiplizieren
sngZahl = sngZahl * sngZahl
'Ergebnis ausgeben
Console.WriteLine("Wert = {0}", sngZahl)
'DOS Fenster offen lassen, bis der Benutzer die Eingabetaste drückt
Console.ReadLine()
'Fertig!
End Sub
End Module

Heute hatten wir viel Theorie, aber auch das muss leider sein. Ich hoffe, ihr seit allen noch dabei. Bis zum nächsten mal!

Programmieren in Visu al Basic – Eine Einführung – Teil 4

Los geht’s mit Teil 4 unseres kleinen “Programmierkurses” für VB. Solltest du neu eingestiegen sein, schau dir vorher die Teile 1 – 3 an.

Operatoren

Heute geht es um Operatoren, d.h. Funktionen, die es uns erlauben Variable zu verarbeiten. Wir haben in unserem letzten Projekt schon den Operator “*” genutzt um einen Wert mit sich selbst zu multiplizieren.

Arithmetische Operatoren

Arithmetische Operatoren dienen zum “verwusten” von Zahlen. Die gängigen sind, wer hätte es gedacht, +,-,*,/ und ^ (quadrieren). Schauen wir uns das erste Programm heute an:

Sub Main()
Dim sngZahl1 As Single = 12
Dim sngZahl2 As Single = 4
Console.WriteLine("Der Operator / ergibt folgendes Ergebnis für die Zahlen {0} / {1} = {2}", _
sngZahl1, sngZahl2, sngZahl1 / sngZahl2)
Console.ReadLine()
End Sub

Wie der geneigte “Programmieren in VB” Kursteilnehmer unschwer erkennen kann werden 2 Variablen vom Typ “Single” definiert denen gleich ein Zahlwert zugewiesen wird. Über Console.WriteLine lassen sich Texte in der Console ausgeben und auch Ergebnisse einer Berechnung. In diesem Codebeispiel ist das eine Division (/). Für was die geschweiften Klammern mit den Zahlen drin stehen, weisst du hoffentlich noch, oder? Falls nicht, zieh dir nochmals Teil 2 der Kurses rein. So schaut dann das Ergebnis aus:

Zusätzlich zu den “Grundrechenarten” gibt es noch den Backslash “\” und “Restwertoperator mod”. Der “\” liefert den ganzzahligen Anteil einer Division. 11 \ 4 = 2 (die .75 fallen weg). MOD liefert den Rest einer Division. Nehmen wir 100 mod 17 ergibt sich als Ergebnis 15, weil 17 5 mal in 100 geht (=85) und die Differenz von 100 zu 85 ist 15.

Vergleichsoperatoren

Diese Operatoren sind sehr wichtig, weil man prüfen kann, ob ein Wert gleich, größer, kleiner einem anderen Wert ist. Auch diese sollten uns vor keine großen Herausforderungen stellen. Nehmen wir an, a=5 und b=10. Wer wir nun in unserem Programm a=b setzen wird “True” zurückgegeben, wenn das der Fall und “False” wenn es nicht so ist. Da a und b nicht gleich sind, bekommen wir als Rückgabewert “False”. Man unterscheidet die Operatoren: =, <>, <, >, <=, >=

Logische Operatoren

Wer mal was mit Digitaltechnik am Hut hatte, der kennt sie, die logischen Operatoren: AND, OR, XOR. Es werden boolsche Werte verglichen, als 0 und 1 bzw. True und False.

Zuweisungen

Die Zuweisungsoperatoren kennen wir schon. x = y weisst x den Wert von y zu. für x = x - y kann man auch schreiben x -= y (logisch oder. Also ich schreib das so, wie ich es schon die letzten 36 Jahre gemacht habe. Den Schmarren mit “-=”, “+=”, “/=” usw. lassen wir weg ; ) )

Stringverkettung

Strings, also Texte, werdem mittels kaufmännischem Und “&” verketten. Plus ginge auch, ist aber fehleranfälliger. Hier ein kleines Beispiel:

Sub Main()
Dim strText1, strText2, strText3 As String
strText1 = "Visual Basic lernen macht... "
strText2 = "saumäßig Spaß. Ich könnten singen vor Freude"
strText3 = strText1 & strText2
Console.WriteLine(strText3)
Console.ReadLine()
End Sub

Das wars mal bis hier mit den Operatoren.

Kontrollstrukturen

Ich nehme an, es wird wohl kaum ein ersthaftes Programm geben (ausser die unseren bisher ;) ) die ohne eine Konstrollstruktur auskommen. Es ist einfach so, dass das Programm abhängig von einer bestimmten Eingabe/Situation unterschiedlich reagieren sollte. Gehen wir gleich an das erste Beispiel. Wir machen ein Programm, in dem der Benutzer angibt, ob der Inventor oder ein anderes CAD einsetzt und abhängig davon wird eine Meldung ausgegeben.

Die IF-Anweisung

If heisst “wenn”. Und so wie sich die Funktion anhört, so arbeitet sie auch. Die Struktur des Befehl sieht so aus:

If (Bedienung) Then
….
Else
….
End If

Machen wir uns gleich an unser Programmbeispiel:

Sub Main()
Dim strCAD As String
Console.WriteLine("Haben Sie Inventor so geben Sie '1' ein wenn Sie ein anderes CAD-System haben '2'")
strCAD = Console.ReadLine
If strCAD = 1 Then
Console.WriteLine("Inventor, im Einsatz. Das ist gut! :) ")
Else
Console.WriteLine("Kein Inventor, im Einsatz. Das ist schlecht! gleich einen kaufen!!")
End If
Console.ReadLine()
End Sub

Wie wir sehen, wird geprüft, ob die Variable StrCAD = 1 ist. Ist das der Fall wird die Anweisung nach dem “Then” ausgeführt ansonsten die Anweisung nach dem “Else”. Das bedeutet aber auch, das die Eingabe von “2″ gar keine Auswirkung hat, da wir ja nur prüfen ob strCAD = 1 ist. Die If-Anweisung wird mit “End If” abgeschlossen.

Select Case Anweisung

Da wir den Anwender unseres Programmes, der “2″ eingibt nicht auflaufen lassen wollen und zudem noch etwas differenzierter zu Werke gehen wollen, nutzen wir die nächste Fuktion: “Select Case”. Die ist selbsterklärend.

Sub Main()
Dim strCAD As String
Console.WriteLine("Haben Sie Inventor so geben Sie 'i' ein wenn Sie SolidWorks haben 's' und wenn Sie Pro/E haben 'p'")
strCAD = Console.ReadLine
Select Case strCAD
Case "i"
Console.WriteLine("Inventor, im Einsatz. Das ist gut! :) ")
Case "s"
Console.WriteLine("Soso, SolidWorks also, na ja...")
Case "p"
Console.WriteLine("Pro/E: Dafür gibt es für Inventor jetzt eine Direktschnittstelle unter labs.autodesk.com")
Case Else
Console.WriteLine("Du sollst i,s, oder p eingeben!")
End Select
Console.ReadLine()
End Sub

Wird das Programm gestartet, kann der Benutzer irgendwas eingeben. Durch die Case-Anweisung erfolgt eine Auswertung, was eingeben wurde. Für jeden “Case” (=Fall) kann dann eine Anweisung definiert werden, hier die Ausgabe einer Textzeile. Wird weder i,s noch p eingegeben tritt die “Case Else” Anweisung in Kraft wo z.B. gefragt werden kann, ob der Anwender so ein Schnarchnase ist, das er nicht mal in der Lage ist, i,s, oder p einzugeben ;)

Ok, das wars für heute mit “Programmieren mit Visual Basic”. Bald machen wir unser erstes richtiges Windowsprogramm – noch etwas Geduld.

Programmieren in Visual Basic – Eine Einführung – Teil 5

Hier ist der fünfte Teil des VB-Kurses.

Immer und immer wieder – Schleifen in VB

Ein weiteres Standardelement in der (VB-) Programmierung sind Schleifen. Schleifen werden immer dann eingesetzt, wenn ein Anweisung mehrmals ausgeführt werden soll.

For-Next-Schleife

Dieser Schleifentyp wird immer dann eingesetzt, wenn Du weisst, wie oft eine Anweisung ausgeführt werden soll. Wir wollen gleich mal mit einem Beispiel starten. Ihr kennt alle die “Schachbrettgeschichte” wo einer auf das erste Quadrat ein Reiskorn legt und auf jedes weitere doppelt soviele wie auf dem Quadrat davor. Wieviele Reiskörner sind das am Ende bei 64 Schachbrettfeldern?

Sub Main()
'Variablendeklaration
Dim dblZahl As Double = 1
Dim intFelder, intZaehler As Integer
'Abfrage der Anzahl der Schachbretter
Console.WriteLine("Wieviele Felder hat dein Schachbrett?")
intFelder = Console.ReadLine()
'Schleife, die so oft durchlaufen wird, wie Felder angegeben wurden
For intZaehler = 1 To intFelder
'Diese Zeilen brauche ich, damit nicht sofort mit 2 Reiskörnern angefangen wird
If dblZahl = 1 Then
Console.WriteLine("Feldnr. {0} = Anzahl Reiskörner {1}", intZaehler, dblZahl)
End If
'Anzahl der Resikörner verdoppeln
dblZahl = dblZahl * 2
'Werte ausgeben
Console.WriteLine("Feldnr. {0} = Anzahl Reiskörner {1}", intZaehler, dblZahl)
Next
'Nach der Ausgabe Returntaste abfragen, damit das DOS-Fenster nicht sofort zu geht
Console.ReadLine()
End Sub

Das neue an diesem, schon nicht mehr ganz nutzlosen, Programm ist die For-Next-Schleife die einen Befehlsblock mehrmals abarbeitet. Die Grundstruktur ist For x = 1 to y …. Next. Die Schleife fangt bei 1 an zu zählen und wird sooft durchlaufen bis der Wert y erreicht ist. Wie ihr seht, verwende ich intZaehler zur Ausgabe des aktuellen Schachbrettfeldes. Wenn ihr mal mit einem Befehl nicht klar kommt, setzt den Cursor auf den Befehl (z.B. “For”) und drückt F1 und es wird die Hilfe geöffnet die entweder online oder offline liegen kann.

Die Do-Loop-Schleife

Bei der For-Next-Schleife steht bereits zu beginn fest, wie oft sie durchlaufen werden soll. Die Do-Loop-Schleife dagegen wird sooft durchlaufen, bis eine bestimmte Bedingung erfüllt ist. Stell dir vor, wir würden ein Inventortool programmieren (womöglich machen wir das auch mal irgendwann :) ) bei dem ein Maß solange geändert wird, bis sich ein bestimmtes Volumen am 3D Modell ergibt. Dann muss die Schleife solange durchgemacht werden, bis die Bedingung “Volumen = gewünschter Wert” eintritt. Das kann 5 mal sein oder 2000000 mal.

In unserem zweiten Beispiel tuen wir mal so, als könnten wir keine Formeln umstellen. Wir haben hier ein Programm, dass Aufgund der Angabe eines Flächeninhaltes und einer Kantenlänge die zweite Kantenlänge ermittelt, die nötig ist, um den Flächeninhalt zu erreichen.

Sub Main()
Dim intKante1, intKante2, intFlaeche1, intFlaeche2 As Integer
Console.WriteLine("Fläche")
intFlaeche1 = (Console.ReadLine)
Console.WriteLine("Kantenlänge")
intKante1 = (Console.ReadLine)
intKante2 = 0
Do Until intFlaeche2 = intFlaeche1
intFlaeche2 = intKante1 * intKante2
Console.WriteLine("Kantenlänge2: {0} ergibt Fläche von {1}", intKante2, intFlaeche2)
intKante2 = intKante2 + 1
Loop
Console.ReadLine()
End Sub

In unserem Beispiel wird die “Do Until” Schleife solange durchlaufen, bis die errechnete Fläche intFlaeche2 gleich der eingegeben Fläche intFlaeche1 ist. Das Ergebnis sieht da so aus:

Das wars für heute. Wer sich noch etwas näher mit dem Thema befassen will, kann sich mal in der Hilfe der VB Entwicklungsumgebung umsehen.

Programmieren in Visual Basic – Eine Einführung – Teil 6

Formularende

Das ist der sechste Teil des VB-Kurses.

Objektorientierte Programmierung

Jetzt geht es so langsam ans Eingemachte. Wenn das Thema “Objektorientierte Programmierung” aufkommt, dann sind 2 Begriffe wichtig: “Klassen” und “Objekte“.

Hier die wikipediamäßige Erklärung zu Klassen:
“Klasse ist in der Objektorientierung ein abstrakter Oberbegriff für die Beschreibung der gemeinsamen Struktur und des gemeinsamen Verhaltens vonObjekten (Klassifizierung). Sie dient dazu, Objekte zu abstrahieren. Im Zusammenspiel mit anderen Klassen ermöglichen sie die Modellierung eines abgegrenzten Systems in der objektorientierten Analyse und dem objektorientierten Design.
Die Struktur einer Klasse bilden die Attribute (auch Eigenschaften), das Verhalten die Methoden (auch Operation, Funktion, Prozedur) der Klasse.”

Und hier die Erklärung von Wikipedia zu Objekten:
“Ein Objekt bezeichnet in der Objektorientierung ein Exemplar eines bestimmten Datentypes oder einer bestimmten Klasse. Im Kontext der Objektorientierten Programmierung spricht man meistens von “Instanzen” einer Klasse.”

Alles klar? Also mir nicht, deswegen mein “inventorlastiger” Erklärungsansatz:
Eine iPart-Mutter (aus der dann die iPart-Kinder beim Einfügen abgeleitet werden) wäre in dem Terminus oben für meine Begriffe eine Klasse weil die iPart-Mutter die “gemeinsame Struktur” und das “gemeinsame Verhalten” der iPart-Kinder definiert. Das iPart-Kind, das durch das Einfügen einer iPart-Mutter in eine Baugruppe durch die Benutzerauswahl entsteht, wäre dann das “Objekt”. Anstelle von Objekt kann auch der Namen Klasseninstanz oder Instanzauftauchen. Ist alles das gleiche. Ich hoffe, jetzt sind die 2 Begriffe etwas verständlicher. (Und darum machen die Programmierer so ein “Geschiss” ; ) ). Wenn ein Klasse definiert wird, dann ist es notwendig dieser Klasse bestimmte Eigenschaften mitzugeben (wie einem iPart eben auch). Würde wir eine Klasse “Lebensmittel” definieren dann würden wir dieser Klasse z.B. die Eigenschaft “Geschmack” zuweisen. In VB sieht das dann so aus:

Module Module1
Class Lebensmittel
Public Geschmack As String
End Class
Sub Main()
Dim Kartoffel As New Lebensmittel
Kartoffel.Geschmack = "Kartoffelig. mehlig, leicht im Abgang"
Console.WriteLine(Kartoffel.Geschmack)
Console.ReadLine()
End Sub
End Module

Objekte haben aber nicht nur Eigenschaften, sondern auch “Methoden”, d.h. die können auch was machen. In unserem Beispiel können Lebensmittel nicht nur einen Geschmack haben sondern auch gasförmige Verdauungsprodukte entwickeln die sicherlich abhängig von der konsumierten Menge und mancher spezifischen Eigenschaft des zugeführten Lebensmittels ist. Das könnte dann so aussehen:

Module Module1
Public Class Lebensmittel
Public Geschmack As String
Public Menge As Integer
Public Pupsfaktor As Integer

Public Function Gasausscheidung() As Integer
Dim Pups As Integer = Menge * Pupsfaktor
Return Pups

End Function

End Class

Sub Main()
Dim Kartoffel As New Lebensmittel()
Kartoffel.Geschmack = "Kartoffelmäßig"
Kartoffel.Menge = 5
Kartoffel.Pupsfaktor = 2
Console.WriteLine(Kartoffel.Geschmack)
Console.WriteLine(Kartoffel.Gasausscheidung)
Console.ReadLine()
End Sub

End Module

Pups = Furz (”einen fahren lassen”) für alle, die sich fragen, was “Pups” schon wieder für ein Fachbegriff ist ;)

Ich weiss, dass das Thema schon etwas “seltsamer” ist, was die Programmierung anbelangt aber da müssen wir durch. Wenn du die letzten 5 Kurse durchgemacht hast, verstehst du den Code oben.

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

Programmieren in Visual Basic – Eine Einführung – Teil 7

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!

Programmieren in Visual Basic – Eine Einführung – Teil 8

Das ist der achte Teil des VB-Kurses.

Inventor aus Visual Basic “ansteuern”

Die Inventor FAQ ist keine Visual Basic Seite, sondern eine Inventor Seite. Deswegen wird es Zeit, dass der Inventor ins Spiel kommt. Wir wollen in diesem Teil unseres Kurses ein Windowsprogramm basteln und aus diesem Programm den Inventor “ansteuern”. Ich dachte bis vor kurzem, das wäre sicherlich sehr schwer, aber ich kann euch beruhigen, es war wesentlich einfacher als ich dachte :). Wie ihr euch vielleicht noch aus Teil 6 erinnern könnte, war da was mit Objekten und ihren Eigenschaften. Unser Programm soll ein in Inventor geöffnetes Bauteil schließen. Dafür brauchen wir bestimmte Voraussetzungen:

Das Programm muss bestimmte Inventorfunktionen beherrschen
Es muss sich den Inventor suchen
Es muss das aktive Dokument schließen

VB den “Inventordialekt” beibringen

Egal welches Programm wir ansteuern wollen, Visual Basic muss mit diesem Programm kommunizieren und dazu muss es dessen Sprache sprechen. Wir würde ein Wörterbuch nehmen, in Visual Basic nimmt man dazu “Verweise”. Aber der Reihe nach. Lege, wie im Teil 7 beschrieben, eine neue Windowsform an und erzeuge darin einen Button den du dann benennst wie es dir beliebt. Das könnte dann so ausschauen:

Nun geben wir dem VB das “Inventorwörterbuch” oder, in der VB-Terminologie, “Verweis”. Mache dazu rechts in der VB-IDE einen Doppelklick auf “My Project” und klicke dann im Register links auf “Verweise”. Nun unten auf “Hinzufügen” und dann, in der nächsten Dialogbox in das Register “COM” wechseln und dort die “Autodesk Inventor Object Library” auswählen.

Jetzt kennt VB die Inventorbefehle. Easy oder?! Nun müssen wir dem Visual Basic aber noch ein Inventor- und ein Dokument-Objekt definieren. Das machen wir bei Public Class weil diese Objekte dann für alle Steuerelemente gelten. Würde wir das bei Privat Sub des Buttons machen, könnten wir die Objektdefinitionen nicht in einer weiteren Private Sub benutzen. Falls sich das alles “wirr” anhört hier 2 Screenshot dann wird es sicherlich klarer (Ich habe dazu einen zweiten Button ins das Form eingefügt, den Button1):

Objekte in Public Class deklariert (gut):

Objekte in Private Sub deklariert (böse):

Auch klar oder? OK, dann geht’s weiter. Wir müssen also die Objekte in Public Class definieren und zwar ein Inventor Anwendungsobjekt, weil wir mit dem “Reden” wollen und ein Dokumentobjekt, genauer ein Inventor Bauteildokument. Das machen wir mit diesen 2 Zeilen

Dim oInventorApp As Inventor.Application
Dim oDoc As Inventor.PartDocument

Wir definieren 2 Variablen vom Typ “Objekt” (ihr erinnert euch an die Sachen mit den Präfixen?). Die können heißen wie sie wollen, aber oInventorApp für “Objekt Inventor Applikation” sagt einfach mehr aus als “x”.

Wenn das erledigt ist, dann weisen wir dem “Bauteil schließen” Button die im angedachte Funktion zu. Dazu müssen wir den Objekten einen Inhalt zuordnen. So wie eine Variable vom Typ Integer den Wert 5 enthalten kann, kann eine Variable vom Typ Inventor.Application den ganzen Inventor enthalten. Jetzt kommt die Zeile, die der “Variable” oInventorApp den Inventor “als Wert” zuweist. Und diese Zeile sieht so aus:

oInventorApp = System.Runtime.InteropServices.Marshal.GetActiveObject("Inventor.Application")

Wenn du dich jetzt fragst, wie ich da drauf gekommen bin: Ich hab mir das in der Programmierhilfe bzw. ein Sample abgeschaut den da wäre ich selbst im Leben nicht draufgekommen ;). Im Prinzip lese ich das so: Das Systemobjekt soll mal schauen ob eine “Inventor Anwendung” läuft und diese dann dem Objekt oInventorApp zuweisen. Das heißt aber auch: Wenn kein Inventor gestartet ist, während wir auf den Button klicken, dann bekommen wir eine Fehlermeldung. Nun wollen wir ja nicht am ganzen Inventor “rummachen” sondern ein darin geöffnetes Bauteil schließen. Deswegen weisen wir dem oDoc jetzt das aktuelle Dokument in Inventor zu.

oDoc = oInventorApp.ActiveDocument

Also im Prinzip: Nimm den ganzen Inventor und davon das aktuelle Dokument. Was, wenn das aktuelle Dokument kein Part ist (Wir haben oDoc als Inventor.PartDocument definiert!). Auch dann bekommen wir eine Fehlermeldung. Also nachher beim probieren Inventor auf und ein neues Bauteil erstellen, sonst gibt ne Fehlermeldung!

Und jetzt machen wir was mit dem oDoc. Wir sagen dem Objekt, das es die Methode “Close” auf sich ausführen soll.

oDoc.Close()

Fertig ist das erste “Windows unterhält sich mit Inventor” Programm das fertig so aussieht:

Public Class Form1
Dim oInventorApp As Inventor.Application
Dim oDoc As Inventor.PartDocument
Private Sub ivschliessen_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles ivschliessen.Click
oInventorApp = System.Runtime.InteropServices.Marshal.GetActiveObject("Inventor.Application")
oDoc = oInventorApp.ActiveDocument
oDoc.Close()
End Sub
End Class

Und, war doch wirklich nicht so schwer oder?
Das war’s für heute zum Thema VB. Bis demnächst!

Programmieren in Visual Basic – Eine Einführung – Teil 9

Im achten Teil unseres kleinen Programmierkurses haben wir aus Visual Basic den Inventor angesteuert und auf Knopfdruck eine ipt geschlossen. Das war schon gar nicht schlampig – aber da geht sicherlich noch mehr. Vielleicht sogar irgendwann mal ein “Add-in” für den Inventor, wer weis… ;)

Skizzen, Kreise und Extrusionen

Aber vorerst backen wir noch kleine Brötchen und in diesem Fall heißt es, dass wir so anfangen, wie jeder Inventoranfänger: Mit einer ipt und einer Skizze. Was wir sicherlich wieder brauchen werden, sind die Objekte Inventor.Application und Inventor.PartDocument weil wir wieder im Inventor “rumfuhrwerken” und das in einem Bauteil. D.h. es geht gleich los, wie in Teil 8 mit dem Anlegen einer neuen Windows Anwendung und dem Einbinden des “Inventors”. Solltest du nur Bahnhof verstehen, lies dir das nochmals durch: VB den “Inventordialekt” beibringen. Alle anderen – los geht’s! :)

Nach dem die Objekte wie im Beispiel vorher definiert sind, erstellen wir einen Button, den wir “Kreis” nennen und der dann später in Inventor einen Kreis zeichnen soll der dann auch noch extrudiert wird, sodass wir einen wunderbaren Zylinder haben und das, ohne das wir in Inventor irgendwas anklicken.

Das erste neue Objekt ist das “Transient Geometry” Objekt. Mit diesem Objekt können wir in Inventor Punkte definieren, z.B. die Mittelpunktkoordiante unseres Kreises. Unsere Objektdefinition sieht also bisher so aus:

Public Class Form1
Dim oInventorApp As Inventor.Application
Dim opartDoc As Inventor.PartDocument
Dim oTG As Inventor.TransientGeometry

In unserem Windowsprogramm brauchen wir noch 2 Textboxen wo der Kreisradius und die Zylinderhöhe eingegeben werden kann und dazu 2 Labels als Beschriftungen damit der Anwender unseres Tools auch weis, was er wo eingeben muss. Ich habe die Beschriftung meines Buttons noch auf “Zylinder erstellen” gesetzt, schließlich wollen wir ja dem Anwender sagen, was passiert, wenn er drauf drückt ;). Bei mir sieht das Fenster dann so aus:

Nun weisen wir dem Button “Kreis” die Funktionen zu, das ein Zylinder entsteht. Mache einen Doppelklick auf den Button und schon bist du im Codefenster beim “Click”-Ereignis “Kreis-Click” des Knopfes. Wie beim letzten Beispiel gehen wir davon aus, das der Inventor läuft, ein Bauteil öffnen ist und darin ein Skizze aktiv ist. Wir weißen also den Objekte, die wir bereits definiert haben, ihren “Inhalt” zu:

oInventorApp = System.Runtime.InteropServices.Marshal.GetActiveObject("Inventor.Application")
opartDoc = oInventorApp.ActiveDocument
oTG = oInventorApp.TransientGeometry

Neu ist hier die Zuweisung an das “TransientGeometry” oTG-Objekt. Das ist einfach so und das brauchen wir auch, damit wir einen Kreismittelpunkt definieren können. Nun wollen wir ja auf eine Skizze einen Kreis zeichnen, also brauchen wir erstmal eine Skizze und das heißt … Objekt deklarieren und eine Zuweisung vornehmen. Wir wollen auf die bereits in Inventor aktive Skizze zugreifen (das ist am wenigsten Programmierarbeit ;) ) und das schaut dann so aus:

Dim osketch1 As Inventor.PlanarSketch
osketch1 = oInventorApp.ActiveEditObject

Ich denke, dass ist soweit klar, oder, ist ja langsam immer das gleich Spiel. Wir deklarieren ein Objekt eines bestimmten Typs und dann weisen wir dem Objekt seinen Inhalt zu. In diesem Fall eben die eben aktive Skizze.

Da wir den Kreisradius in der Box eingeben können, müssen wir den Inhalt der Textbox auch wieder auslesen. Zuvor kommt aber wieder die Definition eine Variable.

Dim dblRadius As Double
'der Var. wird der Inhalt der Textbox "KR" zugewiesen und durch 10 geteilt, da wir ja intern in cm rechnen
dblRadius = KR.Text / 10

Mein Kreisradiustextfeld heißt “KR” und wir wollen den Text daraus haben den wir dann der Variable dblRadius (dbl = Double = Typ der Variable) zuweisen. Da Inventor intern mit Zentimeter rechnet, müssen wir den eingegebenen Wert (der aller Voraussicht nach vom Anwender ja in mm eingegeben wird) in cm umrechnen.

Wenn wir den Kreisradius haben, können wir den Kreis in die Skizze zeichnen. Es wird langsam langweilig den wir definieren wieder ein Objekt, dieses mal vom Typ “Inventor.SketchCircle” – es soll ja ein Kreis werden – und dann weisen wir dem Objekt seinen Inhalt zu, der in diesem Fall im gleichen Schritt definiert wird:

'Kreis zeichnen auf 0,0 mit Radius 1 ZENTIMETER (Inventor scheint intern in CM zu rechnen!)
Dim okreis As Inventor.SketchCircle
okreis = osketch1.SketchCircles.AddByCenterRadius(oTG.CreatePoint2d(0, 0), dblRadius)

osketch1 ist das Objekt “PlanarSketch” das wir oben definiert haben und auf der Skizze erzeugen wir mittels “SketchCircles” (also in etwa “skizziere Kreise”) und der Methode “AddByCenterRadius” (also “füge hinzu durch Angabe von Mittelpunkt und Radius) einen Kreis. Und hier kommt die, mir etwas suspekte, “TransientGeometry” ins Spiel, über die wir den Kreismittelpunkt angeben. oTG haben wir bereits als Objekt definiert und nun sagen wir dem Objekt, das wir einen 2D Punkt brauchen und geben dessen Koordinaten 0,0 an. Falls du dich fragst, warum man da nicht einfach 0,0 schreiben kann – das frage ich mich auch ;)

Wenn der Kreis in der Skizze ist, dann wird er bemaßt:

'Kreis bemaßen
Dim oBemassung_kreis As Inventor.DiameterDimConstraint
oBemassung_kreis = osketch1.DimensionConstraints.AddDiameter(okreis, oTG.CreatePoint2d(1.5, 1.5))

Objekt definieren und dann wieder angeben das auf die Skizze ein Bemaßung soll (DimensionConstraints.AddDiameter) und zwar an das Objekt Kreis und wieder die “TransientGeometry” die die Ausrichtung der Bemaßung angibt (Setze die Werte mal von 1.5 auf 0, dann wirst du sehen, was ich meine).

Wenn der Kreis erstellt und vermaßt, ist können wir in Extrudieren. Dazu müssen wir wieder ein paar Objekte definieren, die den Wert der Textbox “zylhoehe” auslesen und dann extrudieren.

'Kreis extrudieren
Dim oZylinderext As Inventor.ExtrudeFeature
Dim oprofil As Inventor.Profile
Dim opartcompdef As Inventor.PartComponentDefinition
Dim dblzylhoehe As Double
dblzylhoehe = zylhoehe.Text / 10
opartcompdef = opartDoc.ComponentDefinition
oprofil = osketch1.Profiles.AddForSolid(False)
oZylinderext = opartcompdef.Features.ExtrudeFeatures.AddByDistanceExtent(oprofil, dblzylhoehe, _
PartFeatureExtentDirectionEnum.kNegativeExtentDirection, PartFeatureOperationEnum.kJoinOperation)

Wieder werden Objekte definiert, z.B. das “oZylinderext” Objekt das der Extrusion entspricht. Die ganzen Angaben mit “k” sind die Extrusionsoptionen, also z.B. die Richtung mittels PartFeatureExtentDirectionEnum.kNegativeExtentDirection”. Das ist ein Punkt im Programm, da würde ich ohne ein Beispiel, wie das im Verzeichnis “C:\Programme\Autodesk\Inventor 2008\SDK\Samples\Vb.net\Standalone Applications\Inventor\PartFeatures” schlecht aussehen. Es gilt also, wie überall: Lerne aus den Beispielen anderer!

Hier das Programm am Stück:

Public Class Form1
Dim oInventorApp As Inventor.Application
Dim opartDoc As Inventor.PartDocument
Dim oTG As Inventor.TransientGeometryPrivate Sub Kreis_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Kreis.ClickoInventorApp = System.Runtime.InteropServices.Marshal.GetActiveObject("Inventor.Application")
opartDoc = oInventorApp.ActiveDocument
oTG = oInventorApp.TransientGeometry'Auf der AKTIVEN SKIZZE geht's los!
Dim osketch1 As Inventor.PlanarSketch
osketch1 = oInventorApp.ActiveEditObjectDim dblRadius As Double
dblRadius = KR.Text / 10 'der Var. wird der Inhalt der Textbox "KR" zugewiesen und durch 10 geteilt,
'da wir ja intern in cm rechnen
'Kreis zeichnen auf 0,0 mit Radius 1 ZENTIMETER (Inventor scheint intern in CM zu rechnen!)
Dim okreis As Inventor.SketchCircle
okreis = osketch1.SketchCircles.AddByCenterRadius(oTG.CreatePoint2d(0, 0), dblRadius)'Kreis bemaßen
Dim oBemassung_kreis As Inventor.DiameterDimConstraint
oBemassung_kreis = osketch1.DimensionConstraints.AddDiameter(okreis, oTG.CreatePoint2d(1.5, 1.5))

End Class

Wenn du das Programm ausführst (Bauteil mit Skizze vorher aktivieren!) dann wirst du feststellen, dass du eine Extrusion hast, aber immer noch die Skizzenbearbeitung aktiv ist. Also musst du am Ende des Programmes die Skizze verlassen. Und das ist deine Hausaufgabe. Wie heißt die Zeile Code die veranlasst, die Skizze zu verlassen? Ein kleiner Tipp: schreibe osketch1. und schaue in der Liste, was nach dem Beendet des Editierens der Skizze ausschaut.

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