Inventor .NET AddIn Erfahrungen... (Autodesk/AutoCAD ObjectARX und .NET)

Hallo Leute,

also, ich habe mich in den letzten paar Tagen mit den Beispielen von Inventor .NET auseinander gesetzt. Es gibt noch keine .NET Schnitstelle für Inventor, deswegen werde ich auf das Schreiben eines Beispiel verzichten. Ja, es wäre schon möglich, aber da der Zugriff über COM Schnittstelle erfolgt, ist es nichts anderes als in VB. Von dem her - Wurst. Die Erfahrungen, die ich aber teilen möchte, beziehen sich auf das Implementieren von einer in .NET geschriebenen DLL in Inventor. Als Beispiel werde ich eine ganz simple "Hello World" Datei nehmen, wobei ich die Grafische Oberfläche mit Objekten < 9 aufbaue. Also keinen UserInterfaceManager, da ich das Gefühl habe, dass es noch ein wenig bugy ist. Aber sobald ich ein wenig mehr Zeit habe, stelle ich auch ein Beispiel mit neuen Objekten von Inventor 9 rein. Möglicherweise werden sich hier der Eine oder der Andere mit manchen Abschnitten unterfordert fühlen. Falls das so sein sollte, einfach überspringen was bereits bekannt ist.

Betriebssystem: Win2000 SP3 und WinXp Professional
.NET Umgebung: Visual Studio 2003

Bei .NET gibt es keine kostenlose, integrierte Entwicklungs Umgebung wie Visual Basic for Application. Es soll aber eine kostenlose Entwicklungs Umgebung namens #Developer geben, aber da ich mit Visual Studio 2003 arbeite, habe ich mich nicht so richtig dafür interessiert, so kann ich auch nicht sagen, ob alles was mit VS 2003 ( kostenpflichtig ) auch mit #Developer ( kostenlos ) machbar ist. Aber, wenn ich es richtig verfolgt habe, gibt es hier ein paar Leute die mit #Developer arbeiten, daher einfach mal im Forum nachfragen.

1. Starten von einem neuen .NET Projekt

In geöffneten VS 2003 über Datei / Neu / Projekt ( Strg + Umschalten + N ) kommen Sie zu dem "Neues Projekt" Dialog:

In dem linken Fenster haben Sie die Möglichkeit den Typ von Projekten auszuwählen. Dabei können Sie zwischen verschiedenen Sprachen wählen. Zu Sprachen muss folgendes gesagt werden... Aus ein paar Grunden hat die Wahl von Sprachen in .NET an Bedeutung verloren. Alle Sprachen der .NET Umgebung, greifen auf gleiche .NET Bibliotheken drauf zu. Und egal mit welcher Sprache der Code geschrieben wird, nach der Kompilierung entsteht ein Intermediate Language Code. Also nicht wie gewöhnlich werden die Quellcodes in Maschinen Code übersetzt, sonder in einer Art Prozessor unabhängigen Zwischencode, der zur Laufzeit ( Just In Time ) in Maschinen Code umgewandelt wird. Das Ganze erinnert stark an Java Virtual Machine, wobei die Laufzeitumgebung in .NET den Namen Common Language Runtime trägt.

Also kurz und schmerzlos, ohne irgendwelche pro und kontra Selbstgespräche über die Wahl der Sprache anzufangen: ich habe mich für C# entschieden.

In dem rechten Fenster können Sie zwischen ein paar schon vorgefertigten Vorlagen, die verschiedene Projekt Arten darstellen, wählen. Da wir unsere "Applikation" in Inventor integrieren wollen, wählen wir aus den vorlagen "Klassenbibliothek" aus. Jetzt muss nur noch der Name und der Speicherort angegeben werden, und schon kann es los gehen.

2. VS 2003 Oberfläche

Auf den ersten Blick erinnert die Oberfläche an die Microsoft Visual Studio 6.0. Es gibt einen "Projektmappen-Explorer", "Eigenschaften Fenster", das "Code Fenster", ... Als erstes ist mir der Tabbed Style des Hauptfensters positiv aufgefallen.

Egal welchen Typ von Dokumenten wir mal aufgemacht haben ( Quallcode einer Klasse, eine Form, ein Icon, Hilfe Datei, ... ) wird der selbe als Tab in das Hauptfenster eingebunden. Das ermöglicht schnelles wechseln zwischen den Fenstern. Die restliche Oberfläche passt sich dynamisch den momentanen Stand der Entwicklung an. zB wenn ein Formular in das Projekt eingefügt wird, wird die seitliche Toolbox Leiste um die Steuerelemente erweitert die zu den Formularen gehören. Die Toolbox öffnet sich automatisch sobald man mit der Maus darüber fährt. Die restliche Zeit ist sie platzsparend eingezogen. Die Menüleiste, und auch der ganze Oberflächenlayout ist benutzer anpassbar.

Im Hauptfenster kann der Code mit einem Klick auf das "+" Zeichen "Windows Explorer like" erweitert werden, und auf das "-" geschlossen werden. So werden aus den Klassen oder Funktionen immer jeweils eine Zeile. Auf dieser Weise bekommt man den Code sehr übersichtlich.

3. Das von Wizard erstellte Projekt

Das Projekt beinhaltet eine Klasse Class1.cs, AssemblyInfo.cs und ein paar wichtige Verweise. In dem Quelltext Editor wird die Datei Class.cs angezeigt. Als erste Zeilen sehen wir: "using System;". Damit wird der Namespace (System) dem Compiler bekannt gemacht, so dass der Zugriff auf aller Klassen diesen Namespace möglich ist. Die Zeile ClassLibrary1 definiert unseren eigenen Namespace. Alle Zeilen die mit "//" anfangen, stellen die Kommentare dar. Die Kommentare die mit "///" anfangen beinhalten einen XML Code und dienen zur Erstellung eines Webberichts. Der Assistent hat innerhalb des Namenraums eine Klasse Class1 erstellt, worin das eigentliche Programm zu schreiben ist. Es ist auch eine AssemblyInfo.cs Datei erstellt worden. In dieser Datei befinden sich die Metadaten von der gesamten Assembly ( Versionsnummer, Digitalesignatur, ... ). Der Assistent hat auch ein paar der wichtigsten Verweise auf die .NET Klassen zu unserem Projekt hinzugefügt. Die jenigen die wir benutzen wollen, müssen aber über die using-Direktive dem Compiler bekannt gemacht werden.

4. Anpassen des Projektes auf unsere Bedürfnisse

Verweis
Als erstes setzen wir einen Verweis auf die Inventor Object Libary. Dazu klicken wir mit der RMT auf Verweise und wählen "Verweis hinzufügen". Danach erscheint der "Verweis hinzufügen" Dialog. Sparen Sie sich die Suche nach InventorObjectLibery unter .NET Komponenten. Da ist noch nichts vorhanden. Um die Komponente einzufügen wechseln Sie zu COM Komponenten, und wählen da "Autodesk Inventor Object Libary". Danach kann der Dialog geschlossen werden. Anschliessend machen wir die Komponente über der using-Direktive noch dem Compiler bekannt, und schon können wir drauf zugreifen.
Vererbung
Eines der wichtigsten Markenzeichen einer echten Objekt orientierten Programmierung ist die Vererbung. Ziel der Vererbung ist Wiederverwendung von Klassen, so kann von einer vorhandenen Klasse eine neue abgeleitet werden. Die neue Klasse verfügt über die Daten und Methoden der ursprünglichen ( Basis ) Klasse. Ableiten von einer Klasse erfolgt mit der Eingabe eines Doppelpunkts:

Zitat:

------ Erstellen gestartet: Projekt: ClassLibrary2, Konfiguration: Debug .NET ------
Ressourcen werden vorbereitet...
Verweise werden aktualisiert...
Hauptkompilierung wird durchgeführt...
Erstellung abgeschlossen -- 0 Fehler, 0 Warnungen
Satellitenassemblies werden erstellt...
---------------------- Fertig ----------------------
Erstellen: 1 erfolgreich, 0 fehlgeschlagen, 0 übersprungen
Gut so ! Nach dem wir die DLL kompiliert haben, brauchen wir die CLSID Nummer um die REG Datei zu erstellen. Um die raus zu kriegen, gehen wir in die Registry und suchen nach HelloWorld.Class1 ( immer NameSpace.KlassenName ). Und ? Nichts gefunden. Also gehen wir in die Eigenschaften vom Projekt / Konfigurationseigenschaften / Für COM-Interop registrieren und setzen den Wert auf True. Übernehmen die Einstellungen mit "Ubernehmen" und schliessen den Dialog mit OK. Danach kompilieren wir die Anwendung noch ein mal. Schauen wir uns danach das Ausgabe Fenster noch ein mal an:

Zitat:

------ Erstellen gestartet: Projekt: ClassLibrary2, Konfiguration: Debug .NET ------
Ressourcen werden vorbereitet...
Verweise werden aktualisiert...
Hauptkompilierung wird durchgeführt...
Erstellung abgeschlossen -- 0 Fehler, 0 Warnungen
Satellitenassemblies werden erstellt...
Die Projektausgaben für COM-Interop werden registriert...
---------------------- Fertig ----------------------
Erstellen: 1 erfolgreich, 0 fehlgeschlagen, 0 übersprungen
Wenn wir jetzt erneut in der Registry nach HelloWorld.Class1 suchen werden wir fündig. Der Eintrag müsste so aussehen:

Doppelklicken wir mal auf den Eintrag (Standard) in dem rechten Fenster und kopieren uns den kompleten Wert in eine Textdatei. Die Nummer werden wir brauchen um eine REG Datei zu erstellen.
Notice !!! Bei jeder Kompilierung wird eine neue CLSID erstellt. Um das zu vermeiden, schreiben Sie bitte die Zeile:

Zitat:
[GuidAttribute(" Ihre CLSID Nummer ")]

vor der Klasse Class1. Damit haben wir eine Art von Projekt Kompatibilität erstellt, und es wird nicht immer eine neue CLSID erstellt.
Reg Datei
Jetzt müssen wir nur noch dem Inventor klar machen, dass er unsere DLL beim Start mit lädt. Das können wir mit einer REG Datei machen. Eine Reg ( extention .reg ) Datei sieht in etwa so aus:

Zitat:

REGEDIT4
[HKEY_CLASSES_ROOT\CLSID\{AE1BA67B-6910-3321-8A12-2A4517EA2DC3}]
@="C# Inventor HelloWorld"
[HKEY_CLASSES_ROOT\CLSID\{AE1BA67B-6910-3321-8A12-2A4517EA2DC3}\Description]
@="This is the sample Add-In by daywa1k3r"
[HKEY_CLASSES_ROOT\CLSID\{AE1BA67B-6910-3321-8A12-2A4517EA2DC3}\Implemented Categories\{39AD2B5C-7A29-11D6-8E0A-0010B541CAA8}]
[HKEY_CLASSES_ROOT\CLSID\{AE1BA67B-6910-3321-8A12-2A4517EA2DC3}\Required Categories]
[HKEY_CLASSES_ROOT\CLSID\{AE1BA67B-6910-3321-8A12-2A4517EA2DC3}\Required Categories\{39AD2B5C-7A29-11D6-8E0A-0010B541CAA8}]
[HKEY_CLASSES_ROOT\CLSID\{AE1BA67B-6910-3321-8A12-2A4517EA2DC3}\Settings]
"LoadOnStartUp"="1"
"Type"="Standard"
Kopieren Sie den Text in einen Text editor
Ersetzen Sie die CLSID Einträge durch ihre CLSID
Speichern Sie die Datei als HelloWorld.reg.
Als Speicherort wählen Sie am besten den Speicherort des Projektes.

Nach dem Ausführen der Datei werden Sie gefragt, ob Sie die Einträge in Registry eintragen wollen. Bestätigen Sie diese und auch die nächste Meldung mit OK. So, jetzt dürfte der Inventor auch wissen, dass es unseren AddIn gibt, und dass der beim Start geladen werden soll.
Notice !!! Noch ein Unterschied zwischen COM und .NET Komponenten ist, dass die .NET Komponente ihre Selbstbeschreibung in Form von Metadaten mit sich trägt. Die COM Komponenten haben die Beschreibung von Klassen und Methoden in Typbibliotheken, die ausserhalb der Komponenten gespeichert sind. Aus diesem Grund war nach jedem Kompilieren eine Registrierung beim Betriebssystem nötig. Bei .NET Komponenten ist die Registrierung über Regsvr32 nicht mehr nötig. Die fertigen Dateien sind sofort lauffähig, und müssen zB. beim Setup einfach in das Zielverzeichnis kopiert werden. Das erleichtert den Setup Vorgang um einiges. Man spricht da von XCopy Deployment, da die Installation mit einem einfachen Copy Befehlt erfolgt.
Wenn wir jetzt Inventor starten müsste unter Extras / Anpassen unser HelloWorld AddIn zu sehen sein.
5. Grafische Oberfläche
Als erstes deklarieren wir zwei private Variablen in unserer Class1:ApplicationAddInServer:
Code:
private Inventor.Application oApp;
private ButtonDefinitionHandler oButtonHelloWorld;
Weiter geht es in der #region ApplicationAddInServer Member, und zwar sind da vier public Funktionen zu sehen:
Code:

public void ExecuteCommand (int CommandID)
public object Automation
public void Deactivate()
public void Activate (ApplicationAddInSite AddInSiteObject, bool FirstTime)
Die ersten zwei interessieren uns nicht sonderlich, daher einfach auf das "-" klicken und aublenden.
public void Activate wird aufgerufen wenn Inventor versucht unser AddIn zu laden. AddInSiteObject und FirstTime sind zwei Parameter die die Funktion mit sich bringt. Der Parameter FirstTime hat in unserem Beispiel nicht viel zu tun, da wir hier noch ohne den UserInterfaceManager arbeiten. Dieser Parameter wird erst ab der Version 9 interessant sein, daher gehe ich jetzt nicht näher darauf ein. Der erste Parameter ist für uns sehr wichtig, weil wir darauss unser Inventor.Application Object holen:
oApp = AddInSiteObject.Application;
Danach werden wir ein Icon für unseren HelloWorld Button laden. Da ich Autodesk Sample nicht öffnen konnte, musste ich selbst erst sehr viel rumprobieren, bis ich den richtigen Weg gefunden habe. Später bin ich dann darauf gekommen, dass ich die Dateien die sich nicht öffnen lassen, einfach mit einem Code Editor betrachten kann ( RMK ). Ich hätte mir da schon ein paar Stunden sparen können, da die Funktion ImageToPictureConverter genau die gleiche ist wie in dem Autodesk Sample Egal. Da ich ja viel probiert habe, musste ich das in ein try-catch einschliessen. Das ist der nächste Unterschied zur zB. VB OnErrorResumeNext, den es nicht mehr gibt. Aber ich gehe jetzt nicht auf try-throw-catch-finally näher ein. Zurück zu den Images... Der Witz ist nämlich, dass Inventor als Icon genau den Typ IPictureDisp erwartet. Alles andere wird einfach nicht angezeigt. Und die Funktion ImageToPictureConverter erwartet ein Image und liefert ein iPictureDisp zurück. iPictureDisp ist ein Mitglied von stdole, daher ist es nötig, dass wir die stdole über der using-Direktive mit in das Projekt einbinden:
using stdole;
Wenn es um das Laden von Bildern geht, gibt es zwei Möglichkeiten: 1. Die Bilder von der Festplatte laden 2. Die Bilder in das Projekt einbinden. Ich habe mich für die Möglichkeit zwei entschieden. Um eine Bild Datei in das Projekt einzufügen, einfach mit der RMT auf das Projekt klicken und dann auf "Hinzufügen / Vorhandenes Element hinzufügen", und die ( in meinem Fall ) BPM laden. Danach erscheint die Datei im Projekt direkt. Das einzige was noch getan werden muss, ist in den Eigenschaften die "Buildaktion" auf "Eingebettete Ressource" setzen. Visual Studio 2003 besitzt auch einen Image Editor, so dass wenn man "Hinzufügen / Neues Element hinzufügen / Bitmap Datei" wählt, automatisch der Editor geöffnet wird.
Notice !!! Die Icons für Autodesk Inventor müssen eine feste Grösse haben, und zwar: small -> width = 16px; height = 15px; und large -> width = 24px; height = 22px; Alle anderen Grössen werden von Inventor skalliert, und sehen danach dementsprechend aus.
Also, weiter geht es mit definieren von Buttons... Wir brauchen ein Bitmap Object, an das Object übergeben wir das Bild aus der Ressource, danach konvertieren wir das Ganze in das iPictureDisp und übergeben es an unsere Variable iPictureDisp.
Vierzeiler:
Code:

Bitmap MyBitmap;
MyBitmap = new Bitmap (this.GetType(), "HelloWorld.bmp");
IPictureDisp IconHelloWorld;
IconHelloWorld = ImageToPictureConverter.Convert (MyBitmap);
Das Gleiche als Einzeiler:
Code:

IPictureDisp IconHelloWorld = ImageToPictureConverter.Convert (new Bitmap(this.GetType(), "HelloWorld.bmp"));
Die Funktion this.GetType() liefert ein Array von Typ Type zurück, wo die ganzen definierten Typen aus der Assembly definiert sind.
So, jetzt können wir ein ButtonDefinitionHandler erstellen:
Code:

oButtonHelloWorld = AddInSiteObject.CreateButtonDefinitionHandler ("HelloWorldIntCmd1", CommandTypesEnum.kShapeEditCmdType, "C# Hello World", "HelloWorld Sample by daywa1k3r written in C#", IconHelloWorld, IconHelloWorld)
Die Sachen innerhalb "" sind Strings und bedeuten: Internal Name, Description, ToolTipText, ...
Notice !!! Die InternalNames von den Buttons müssen eindeutig sein. Zwei gleiche InternalNames führen zu Fehlern.
Danach definieren wir einen OnClick Event für den ButtonHandler:
Code:

oButtonHelloWorld.OnClick += new ButtonDefinitionHandlerEventsSink_OnClickEventHandler (oButtonHelloWorld_OnClick);
Wenn wir jetzt versuchen das Projekt zu kompilieren, würden wir einen Fehler erhalten:
Der Name "oButtonHelloWorld_OnClick" besteht nicht in der KLasse oder dem Namespace "HelloWorld.Class1"
Also müssen wir die Funktion schnell schreiben, und die soll nichts anderes machen, als eine MessageBox ausgeben.
Code:

private void oButtonHelloWorld_OnClick()
{
MessageBox.Show ("Hello World", "C# Hello World");
}
So, jetzt dürfte sich das Projekt wieder kompilieren lassen.
public void Deactivate();
In dieser Funktion müssen wir "alle" Objecte die wir zur Laufzeit geladen haben wieder freigeben. Normalerweise übernimmt die Laufzeitumgebung die ganzen "clean arbeiten" ( Garbage Collection ), aber irgendwie waren die Sachen nicht frei zu geben. Möglicherweise lag es daran, dass zB. oApp nicht mit new zu aloizieren war. Wie auch immer, es war nicht so leicht das Object frei zugeben. Mit einer gesunder Mischung aus MarshalReleaseComObject und expliziten Aufruf der GarbageCollection ging es dann doch.
Code:

if (oApp != null) Marshal.ReleaseComObject (oApp);
GC.WaitForPendingFinalizers();
GC.Collect();
Irgendwie erscheint mir die ganze Lösung nicht so logisch, aber es funktioniert. Die Funktion Mashal.ReleaseComObject dekrementiert den Verweiszähler des bereitgestellten Runtime Callable Wrapper. Soweit, so gut. Laut MSDN ist es so, dass bei jedem Eintrit eines COM Schnittstellenzeigers in die CommonRuntimeLanguage wird, dieser in einem RCW gewrappt wird. Mit Marshal.ReleaseComObject (oObject); wird das COM Object oObject freigegeben. Um sicher zu gehen, dass kein Objekt mehr geladen ist, ist empfohlen eine while Schleife zu benutzen bis die Marshal.ReleaseComObject eine Null liefert. Das hab ich auch gemacht, aber leider ohne Erfolg. Erst wenn ich zusätzlich die GarbageCollection explizit aufgerufen habe ( im normalen Fall wird die GarbageCollection von Laufzeitumgebung automatisch durchgeführt ), funktionierte es. Alleine GarbageCollection half mir auch nichts, daher habe ich zum Anfang gesagt, dass eine gesunde Mischung zum Erfolg führt.

So, das wäre in etwa alles, was beachtet werden muss, um ein "leeres" AddIn zu erstellen. Kompilieren Sie jetzt das Projekt, und in Inventor unter Zusatz Module müsste unsere Anwendung aufgelistet sein. Über Anpassen, können Sie dann HelloWorld Toolbar sichtbar machen, und nach einem Klick auf das HelloWorld Button müsste eine MessageBox mit "Hello World" kommen.

Das waren meine ersten Erfahrungen mit C# und .NET AddIn. Ich hoffe, hiermit dem einem oder anderem ein paar Stolpersteien aus dem Weg geräumt zu haben. Ich melde mich wieder nach dem Urlaub, wenn ein wenig mehr Zeit da ist, und dann aber mit einem grösseren Beispiel.

------------------
Grüße daywa1k3r

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP