Automatisierte Anpassung von .NET-Komponenten an einen kanonischen Interaktionsstil
- Art: Diplomarbeit
- Autor: Boris Tsarev
- Abgabedatum: Juli 2006
- Umfang: 163 Seiten
- Dateigröße: 8,1 MB
- Note: 1,5
- Institution / Hochschule: Freie Universität Berlin Deutschland
- ISBN (eBook): 978-3-8324-9784-2
-
ISBN (Paperback) :
978-3-8324-9784-2 P - ISBN (CD) :978-3-8324-9784-2 CD
- Sprache: Deutsch
- Prämierung:
- Arbeit zitieren: Tsarev, Boris Juli 2006: Automatisierte Anpassung von .NET-Komponenten an einen kanonischen Interaktionsstil, Hamburg: Diplomica Verlag
- Schlagworte: CORBA, NET, Generator, Vertreter, Programmieren
In den Warenkorb
68,00 €
Diplomarbeit von Boris Tsarev
Zusammenfassung:
Die komponentenbasierte Software-Entwicklung ist die Lösung der Softwaretechnik zu einer Modularisierung der Software, die zu einer erhöhten Wiederverwendung, Qualität, Wartbarkeit und Flexibilität führt. Es haben sich mittlerweile mehrere Komponentenmodelle (COM – Component Object Model von Microsoft, Java Beans, Enterprise Java Beans, .NET, CORBA Component Model usw.) mit verschiedenen Vor- und Nachteilen in der Software-Industrie etabliert. Die Investitionen in die Entwicklung von Komponenten sind in den letzten Jahren enorm gestiegen und es besteht bereits ein beachtlicher Bestand an Software-Komponenten.
Immer häufiger wird der Weg der Integration einer bestehenden Komponente als die Neuentwicklung gewählt. Wegen der Heterogenität der Komponentenmodelle und ihrer Laufzeitumgebungen kann man leider nicht ohne weiteres eine Komponente für eine bestimmte Laufzeitumgebung in einer anderen Laufzeitumgebung, die mit der ersten inkompatibel ist, nutzbar machen. Wenn die Interaktionsstile in den beiden Umgebungen aufrufbasiert und die Unterschiede nur technischer Natur sind, kann eine aufrufbasierte Middleware für Fernaufrufe wie CORBA weiterhelfen, die Implementierungen in vielen Programmiersprachen vorzuweisen hat. Wenn die Laufzeitumgebungen vom Prinzip her unterschiedliche Interaktionsstile aufweisen, kann der Ansatz von Prof. Dr.-Ing. Klaus-Peter Löhr zum Einsatz kommen, der dieser Arbeit zugrunde gelegt wurde.
Er stellt eine weitgehende Generalisierung des generator-gestützten Vertreter-Treiber-Ansatzes von CORBA dar (bekannt im Englischen als „Proxy/Driver“ oder „Stub/Skeleton“). Ziel ist es, dass die Vermittlung zur Komponente für den Nutzer völlig transparent abläuft, so dass der Anschein erweckt wird, als wäre die Komponente speziell für die gewünschte Umgebung geschaffen worden. Zu diesem Zweck wird ein kanonischer Interaktionsstil definiert, auf den alle zu unterstützenden Interaktionsstile abgebildet werden können. Die Schnittstelle der Komponente wird in AID (Abstract Interface Definition), eine speziell für den kanonischen Interaktionsstil entwickelte Sprache, beschrieben. Nun können auf dieser Basis die Generatoren für die gewünschte Umgebung bzw. die Umgebung der Komponente einen Vertreter bzw. einen Treiber zur Komponente erstellen. Vertreter und Treiber kommunizieren über einen Kommunikationskanal, da sie in unterschiedlichen Umgebungen laufen.
Im Rahmen dieser Arbeit wurde eine Lösung zur Realisierung des kanonischen Interaktionsstils zwischen Vertreter und Treiber mittels CORBA-Fernaufrufen konzeptionell erarbeitet und praktisch umgesetzt. Nach einer Analyse des Interaktionsstils und der Schnittstellen von .NET-Komponenten wurde die Abbildung des Interaktionsstils von .NET auf den kanonischen und umgekehrt spezifiziert und im Vertreter und Treiber für das .NET Framework praktisch realisiert. Zu guter Letzt werden die Vertreter und Treiber mit Hilfe des entwickelten Generators automatisiert generiert.
Die Semantik, die Syntax und das Typsystem von AID mussten zusammen mit Prof. Löhr, seinen wissenschaftlichen Mitarbeitern und Daniel Nowak genau konkretisiert werden. Nur dadurch konnte ein für alle Generatoren verbindliches AID-IDL Mapping spezifiziert werden. Parallel zu dieser Arbeit liefen die Entwicklungsarbeiten an Generatoren für die Interaktionsstile bei Message-Driven Beans, Unix-Filter-Programmen und Komponenten, die über Java Tuplespaces interagieren.
Inhaltsverzeichnis:
| Kurzfassung | V | |
| Inhalt | VII | |
| 1. | Einleitung und Zielsetzung | 1 |
| 1.1 | Wiederverwendung von Software | 1 |
| 1.2 | Komponentenbasierte Software-Entwicklung | 1 |
| 1.3 | Integration von Komponenten | 1 |
| 1.4 | Interaktionsstile und Komponenten | 2 |
| 1.5 | Integration von Komponenten mit einem inkompatiblen Interaktionsstil | 4 |
| 1.6 | Zielsetzung | 5 |
| 1.7 | Gliederung dieser Arbeit | 6 |
| 2. | Vermittlung zwischen unterschiedlichen Interaktionsstilen | 7 |
| 2.1 | Grundlagen | 7 |
| 2.2 | Kanonischer Interaktionsstil | 8 |
| 2.3 | Lebensdauer und Exemplare einer AID-Komponente | 10 |
| 2.4 | Aufgaben des Vertreters und Treibers | 11 |
| 2.5 | Beschreibung der Schnittstellen der Komponente in AID | 12 |
| 2.6 | Generierung von Vertreter und Treiber | 13 |
| 2.7 | Wahl der Middleware und des Vermittlungsprotokolls | 14 |
| 2.8 | Umsetzung des kanonischen Interaktionsstils auf Basis von CORBA | 15 |
| 2.9 | Das AID-IDL Mapping | 17 |
| 2.9.1 | Mapping von primitiven Typen | 17 |
| 2.9.2 | Mapping von COMPONENT | 18 |
| 2.9.3 | Mapping von TUPLE | 18 |
| 2.9.4 | Mapping von EXCEPTION | 19 |
| 2.9.5 | Mapping von Feldern | 19 |
| 2.9.6 | Mapping von INTERFACE | 20 |
| 2.9.7 | Mapping von INIT | 21 |
| 2.9.8 | Mapping von IN-Ereignissen | 21 |
| 2.9.9 | Mapping von OUT-Ereignissen | 21 |
| 2.9.10 | Mapping von INOUT-Ereignissen | 22 |
| 2.9.11 | Mapping von OUTIN-Ereignissen | 22 |
| 3. | .NET-Komponenten – Grundlagen und Interaktionsstil | 23 |
| 3.1 | Was ist eine .NET-Komponente? | 23 |
| 3.2 | Laufzeitumgebung für .NET-Komponenten | 24 |
| 3.3 | Interaktionsstil in .NET | 25 |
| 3.3.1 | Erzeugung von Komponentenexemplaren | 25 |
| 3.3.2 | Zerstörung von Komponentenexemplaren | 25 |
| 3.3.3 | Bindung zu einem Komponentenexemplar | 26 |
| 3.3.4 | Primitive zur Kommunikation mit der Komponente | 26 |
| 3.3.5 | Schnittstelle einer .NET-Komponente | 26 |
| 3.3.6 | Typsystem in .NET | 29 |
| 3.4 | Weitere Aspekte | 29 |
| 3.4.1 | Lokale und entfernte Nutzung von Komponenten | 30 |
| 3.4.2 | Asynchrone Aufrufe | 30 |
| 3.4.3 | Vererbung und Implementierung von Schnittstellen | 33 |
| 3.4.4 | Importierte Schnittstellen | 34 |
| 3.4.5 | Abstrakte Methoden, Eigenschaften und Ereignisse | 35 |
| 3.4.6 | Statische Methoden, statische Eigenschaften etc. | 35 |
| 4. | Vermittlung zwischen dem kanonischen und dem Interaktionsstil von .NET im Treiber | 37 |
| 4.1 | Abbildung des Typsystems von .NET in AID | 37 |
| 4.1.1 | Primitive Typen | 37 |
| 4.1.2 | Klassen ohne wesentliche Funktionalität, die als Verbundtypen verwendet werden | 38 |
| 4.1.3 | Verbundtypen (Strukturen) | 40 |
| 4.1.4 | Ausnahmen | 41 |
| 4.1.5 | Klassen mit Funktionalität | 41 |
| 4.1.6 | Abstrakte Klassen und Schnittstellen | 42 |
| 4.1.7 | Delegaten | 42 |
| 4.2 | Steuerung der Lebensdauer der Komponentenexemplare | 43 |
| 4.2.1 | Erzeugung und Initialisierung | 44 |
| 4.2.2 | Zerstörung und Freigabe | 44 |
| 4.3 | Abbildung der Schnittstelle einer .NET-Komponente in AID | 45 |
| 4.3.1 | Methoden | 45 |
| 4.3.2 | OneWay-Methoden | 46 |
| 4.3.3 | Ereignisse | 47 |
| 4.3.4 | Eigenschaften | 48 |
| 4.3.5 | Mitgliedsvariablen | 49 |
| 4.3.6 | Geerbte Methoden, Eigenschaften und Ereignisse | 49 |
| 4.3.7 | Abstrakte Methoden, Eigenschaften und Ereignisse | 51 |
| 4.3.8 | Statische Methoden, Eigenschaften und Ereignisse | 54 |
| 4.4 | Umsetzung des Treibers | 54 |
| 4.4.1 | IIOP.NET – Eine CORBA-Implementierung für .NET | 55 |
| 4.4.2 | Umsetzung des IIOP-Servers | 56 |
| 4.4.3 | AID_System | 58 |
| 4.4.4 | Grundgerüst zu einer AID-Schnittstelle | 60 |
| 4.4.5 | Umsetzung der Klasse [Name]_IN | 61 |
| 4.4.6 | Die Klasse [Name]_OUT | 70 |
| 4.4.7 | Umsetzung der Klasse [Name]_OUTIntern | 71 |
| 4.4.8 | Klassen zu AID-Tupeln | 73 |
| 4.4.9 | Klassen zu AID-Ausnahmen | 74 |
| 4.4.10 | Klassen zur Konvertierung von Feldern | 74 |
| 5. | Vermittlung zwischen dem kanonischen und dem Interaktionsstil von .NET im Vertreter | 77 |
| 5.1 | Abbildung von AID in .NET | 77 |
| 5.1.1 | Primitive Typen | 78 |
| 5.1.2 | Felder | 78 |
| 5.1.3 | Schlüsselwort COMPONENT | 78 |
| 5.1.4 | AID-Tupeln | 79 |
| 5.1.5 | AID-Ausnahmen | 79 |
| 5.1.6 | AID-Schnittstellen | 79 |
| 5.2 | Umsetzung des Vertreters | 81 |
| 5.2.1 | Klasse AIDSystemProxy | 81 |
| 5.2.2 | Klasse AIDSystemException | 84 |
| 5.2.3 | Gerüst zu einer AID-Schnittstelle | 84 |
| 5.2.4 | Vertreter-Klasse einer AID-Schnittstelle | 85 |
| 5.2.5 | Schnittstelle [Name]Out | 93 |
| 5.2.6 | Klasse [Name]_OUTImpl | 94 |
| 5.2.7 | Klassen zu AID-Tupeln | 94 |
| 5.2.8 | Klassen zur Konvertierung von Feldern | 95 |
| 6. | Umsetzung eines Generators zu automatisierter Erzeugung von Treibern und Vertretern für .NET | 97 |
| 6.1 | Ablauf der Generierung | 97 |
| 6.2 | Parsen der AID-Datei | 100 |
| 6.3 | AID-Datenbaum | 100 |
| 6.4 | Generierung des Quellcodes | 103 |
| 6.5 | Übersetzung und Erstellung einer Vertreter- bzw. Treiber-Assembly | 105 |
| 6.6 | Konfiguration und Inbetriebnahme des Generators | 105 |
| 7. | Zusammenfassung und Ausblick | 107 |
| Anhang A. | Syntax, Typsystem und Semantik von AID | 109 |
| Anhang B. | Auflistung der Annotationen für die Treiber-Generierung zu .NET-Komponenten | 115 |
| Anhang C. | Auflistung der Annotationen für die Vertreter-Generierung in .NET zu AID-Komponenten | 127 |
| Anhang D. | Installation und Konfiguration des Generators für den Interaktionsstil in .NET (aid_net.exe) | 131 |
| Anhang E. | Anleitung zur Erstellung von Treibern von .NET-Komponenten | 133 |
| Anhang F. | Anleitung zur Erstellung von Vertretern von AID-Komponenten in .NET | 143 |
| Quellenverzeichnis | 153 | |
| Eidesstattliche Erklärung | 155 |
In den Warenkorb
68,00 €
Link zur Arbeit:
http://www.diplom.de/ean/9783832497842
Arbeit zitieren:
Tsarev, Boris Juli 2006: Automatisierte Anpassung von .NET-Komponenten an einen kanonischen Interaktionsstil, Hamburg: Diplomica Verlag
Schlagworte:
CORBA, NET, Generator, Vertreter, Programmieren




