Vorwort......................................................................... Vorwort der Autoren........................................................... Systemanforderungen für die CD zum Buch...................................... Danksagung................................................................... XIII XV XVI XVI Teil I Grundlagen der Programmarchitektur.................................... 1 1 Komponenten-Software.................................................... 3 Von der objektorientierten Programmierung zur Komponenten-Software........... 6 Objektorientierte Programmierung........................................... 6 Gemeinsame Verwendung und Wiederverwendung von Code................... 7 Komponenten-Software..................................................... 8 Schnittstellen............................................................... 10 Die Entwicklung von COM+................................................... 10 Von OLE zu COM+........................................................ 10 RPC und COM+............................................................ 14 Von COM zu COM+.......................................................... 14 Windows-DNA: ein Three-Tier-Zugang....................................... 16 Just-In-Time-Aktivierung....................................................... 18 Objekt-Pooling................................................................ 20 Lastenausgleich............................................................... 20 In-Memory-Datenbank........................................................ 21 Warteschlangenkomponenten.................................................. 21 Transaktionen................................................................ 21 Rollenbasierte Sicherheit....................................................... 23 Ereignisse.................................................................... 24 2 Die IUnknown-Schnittstelle................................................ 25 Die Schnittstellendefinitionssprache IDL........................................ 27 Der Client.................................................................... 30 Die CoInitialize-Funktion................................................... 31 Die CoCreateInstance-Funktion............................................. 31 Die Methoden von IUnknown............................................... 33 Die CoUninitialize-Funktion................................................. 36 Die V-table-Situation....................................................... 36 Das Client-Projekt erstellen.................................................. 40 V
Die Komponente.............................................................. 41 Implementierung der AddRef- und Release-Methode........................... 42 Implementierung der IUnknown::QueryInterface-Methode..................... 42 Die ISum::Sum-Methode (endgültig)......................................... 48 Die IClassFactory-Schnittstelle............................................... 49 Exportierte DLL-Funktionen................................................ 53 Die CoCreateInstance-Funktion............................................. 56 Das Komponentenprojekt erstellen........................................... 59 Komponentenregistrierung.................................................. 63 Verbinden der Objektidentität.................................................. 69 Enthaltung................................................................. 70 Aggregation................................................................ 72 3 Sprachintegration.......................................................... 77 Typbibliotheken............................................................... 78 Typbibliotheken verwenden................................................. 78 Typbibliotheken erstellen.................................................... 79 Typbibliotheken registrieren................................................. 82 Ein einfacher C++-Client.................................................... 85 C++-Vorlagen (Eine kurze Einführung)....................................... 86 Namensbereiche............................................................ 93 Die Active Template Library (ATL)............................................. 94 Der ATL-COM-Anwendungs-Assistent....................................... 95 Der ATL-Objekt-Assistent................................................... 95 Zu einer Schnittstelle, die ATL benutzt, Methoden und Eigenschaften hinzufügen 97 Erstellen eines einfachen COM+-Objekts mit ATL............................. 99 COM+-Programmierung in Visual Basic......................................... 100 QueryInterface: Der Visual Basic-Weg........................................ 101 Erstellen eines Clients mit Visual Basic....................................... 103 COM+-Schnittstellen in Visual Basic implementieren.......................... 103 Erstellen einer Komponente mit Visual Basic.................................. 105 COM+-Programmierung in Java................................................ 106 Ein COM+-Objekt aus Java heraus aufrufen................................... 111 Implementieren von COM+-Objekten mit Java................................ 115 Integration von ActiveX-Steuerelementen und JavaBeans....................... 119 Das Sandbox-Modell........................................................ 119 4 Apartments................................................................. 121 Eine kurze Einführung zu Threads.............................................. 122 Apartment-Typen............................................................. 123 Das Single-Threaded-Apartment-Modell...................................... 125 Multithreaded-Apartments.................................................. 131 Übermitteln von Schnittstellenzeigern zwischen Apartments.................... 132 Die Auswahl des Threading-Modells.......................................... 135 Threading-Modelle für prozessinterne Komponenten............................. 137 Apartment-Interaktionen.................................................... 138 Objekte, die das MTA-Modell unterstützen................................... 140 Objekte, die alle Threading-Modelle unterstützen.............................. 141 Der Free-Threaded Marshaller............................................... 143 VI
Neutrale Apartments........................................................ 151 Vergleich der Apartment-Modelle............................................ 152 Thread-sichere Komponenten schreiben...................................... 153 Apartments und Sprachintegration.............................................. 155 Threading-Optionen für Visual Basic-Komponenten........................... 155 Threading-Optionen für Java-Komponenten................................... 159 Die zehn Threading-Gebote.................................................... 160 Teil II Leistungsmerkmale von COM+............................................. 161 5 Automatisierung............................................................ 163 Die IDispatch-Schnittstelle..................................................... 164 Automatisierungstypen...................................................... 166 IDispatch implementieren...................................................... 175 Entwerfen eines Dispinterface............................................... 176 Entwerfen einer dualen Schnittstelle.......................................... 176 Implementierungstechniken................................................. 180 Eigenschaften.............................................................. 187 Auflistungen............................................................... 188 Die verbesserte IDispatchEx-Schnittstelle..................................... 190 Automatisierungs-Clients erstellen.............................................. 195 Erstellen eines Automatisierungs-Client in C++................................ 195 Automatisierungs-Clients in Visual Basic erstellen............................. 199 Scripting..................................................................... 201 Erstellen von Automatisierungs-Clients mit Script-Sprachen.................... 202 Scriptlets................................................................... 204 6 Ausnahmefehler............................................................ 207 Fehlercodes................................................................... 208 FACILITY_ITF-Fehlercodes................................................. 209 Hilfsmakros................................................................ 209 Erweiterte Fehlerinformationen................................................. 210 Die ISupportErrorInfo-Schnittstelle.......................................... 210 Die ICreateErrorInfo-Schnittstelle............................................ 211 Fehlerinformationen ermitteln............................................... 212 Die IErrorInfo-Schnittstelle.................................................. 213 7 Komponentenkategorien................................................... 215 Standard-Komponentenkategorien.............................................. 216 Standardkomponenten...................................................... 218 Komponentenkategorien registrieren............................................ 220 Die ICatRegister-Schnittstelle................................................ 221 Abrufen von Informationen über Komponentenkategorien........................ 223 Die ICatInformation-Schnittstelle............................................ 224 VII
8 Verbindungspunkte........................................................ 227 Ein einfaches verbindungsfähiges Objekt........................................ 228 Die Quellschnittstelle....................................................... 228 Die IConnectionPoint-Schnittstelle........................................... 229 Die IConnectionPointContainer-Schnittstelle................................. 232 Ein eingehendes Objekt in C++ implementieren............................... 234 Ein Visual Basic-Sink-Objekt................................................ 238 Ein eingehendes Java-Objekt................................................. 243 Vollständige Version eines verbindungsfähigen Objekts........................... 244 Enumeratoren.............................................................. 246 Verbindungspunkte verwenden.............................................. 250 9 Typinformationen.......................................................... 253 Typbibliotheken erstellen...................................................... 254 Typinformationen hinzufügen................................................ 257 Typinformationen abrufen..................................................... 267 Die ITypeLib-Schnittstelle................................................... 269 Die ITypeInfo-Schnittstelle.................................................. 270 Die ITypeComp-Schnittstelle................................................ 274 Typinformationen mit höheren Programmiersprachen lesen.................... 274 10 Persistenz................................................................... 277 Die IPersist-Schnittstellenfamilie............................................... 277 Die IStream-Schnittstelle.................................................... 279 Objekte persistent werden lassen............................................. 281 Persistente Objekte implementieren.......................................... 282 Persistente Objekte mit Visual Basic erstellen................................. 286 Persistente Objekte in Java erstellen.......................................... 290 Strukturiertes Speichern....................................................... 291 Die Schnittstellen IStorage und IStream...................................... 292 Die Schnittstellen IPropertySetStorage und IPropertyStorage................... 294 11 Moniker..................................................................... 299 Objekte initialisieren.......................................................... 299 Klassenobjekte............................................................. 301 Benutzerdefinierte Aktivierungsschnittstellen................................. 301 Moniker...................................................................... 302 Die IMoniker-Schnittstelle.................................................. 303 Die MkParseDisplayName-Funktion......................................... 307 Der Klassen-Moniker.......................................................... 310 Eine verbesserte Variante des Klassen-Monikers............................... 312 Der neue Moniker............................................................. 318 Der Java-Moniker............................................................. 319 Running Object Table......................................................... 320 VIII
Teil III Fernverarbeitungsarchitektur.............................................. 323 12 Surrogate................................................................... 325 DLL-Surrogate................................................................ 326 Prozessinterne Komponenten lokal ausführen................................. 326 Komponenten auf entfernten Computern ausführen............................ 328 Benutzerdefinierte Surrogate................................................... 330 Das benutzerdefinierte DLL-Surrogat DllNanny............................... 331 Eine Einführung in das Marshaling............................................. 334 Standard-Marshaling........................................................ 335 Typbibliothek-Marshaling................................................... 337 Benutzerdefiniertes Marshaling.............................................. 338 13 Ausführbare Komponenten................................................ 341 Ausführbare Komponenten erstellen............................................ 343 Klassenobjekte registrieren.................................................. 346 Ferninstanzierung.......................................................... 348 Marshaling-Code integrieren................................................. 350 Die Lebensdauer von ausführbaren Komponenten verwalten...................... 351 Die verfrühte Freigabe....................................................... 353 Ausführbare Komponenten herunterfahren................................... 355 Benutzerdefinierte Aktivierungsschnittstellen................................. 357 Singletons.................................................................... 361 14 Benutzerdefiniertes Marshaling........................................... 363 Übersicht über das Marshaling von Schnittstellenzeigern.......................... 364 Die V-Table einer Schnittstelle nachbilden.................................... 365 Interprozesskommunikation................................................. 366 Soll es benutzerdefiniertes oder Standard-Marshaling sein?....................... 367 Können Sie»benutzerdefiniertes Marshaling«sagen?.......................... 370 Welche CLSID hat Ihr Objekt?.............................................. 373 Wie groß ist Ihre Schnittstelle?............................................... 373 Den Schnittstellenzeiger entpacken.......................................... 379 Das Wertübergabe-Marshaling.................................................. 383 15 Standard-Marshaling....................................................... 387 Die Standard-Marshaling-Architektur........................................... 388 Die Standard-Marshaling-Schnittstellen...................................... 391 Die Proxy-/Stub-DLL registrieren............................................ 405 Per Marshaling verpackte Schnittstellenzeiger in Zeichenfolgen umwandeln........ 405 Der OBJREF-Moniker...................................................... 408 Handler-Marshaling........................................................... 408 IX
16 Die Schnittstellendefinitionssprache IDL.................................. 415 Datentypen................................................................... 416 Enumerierte Typen......................................................... 417 Richtungsattribute............................................................. 417 Arrays........................................................................ 421 Felder fester Größe......................................................... 421 Konforme Arrays........................................................... 422 Variierende Arrays.......................................................... 425 Offene Arrays.............................................................. 426 Character-Arrays........................................................... 428 Mehrdimensionale Arrays................................................... 430 Benutzerdefinierte Visual Basic-Datentypen in einem Array übergeben.......... 431 Zeiger........................................................................ 432 Vollzeiger.................................................................. 432 Eindeutige Zeiger........................................................... 433 Referenzzeiger.............................................................. 434 Schnittstellenzeiger......................................................... 434 Empfehlungen für den Schnittstellenentwurf..................................... 437 17 Asynchrone Aufrufe........................................................ 439 Asynchrone Aufrufe durchführen............................................... 439 Asynchrone Aufrufe definieren............................................... 440 Asynchrone Schnittstellen................................................... 441 Asynchrone Schnittstellen implementieren.................................... 443 Interoperabilität............................................................ 445 Aufrufabbruch................................................................ 446 Abbruch von Methodenaufrufen anfordern.................................... 447 Terminieren der Methode................................................... 449 Pipes......................................................................... 450 18 Sicherheit................................................................... 453 Das verteilte Sicherheitsmodell von Windows.................................... 454 Das Sicherheitsmodell von COM+........................................... 455 COM+-Sicherheitspakete.................................................... 457 Deklarative Sicherheit durch die Registrierung................................... 458 Standardsicherheit.......................................................... 459 Zugriffs- und Startberechtigungen konfigurieren............................... 462 Die Komponentensicherheit über den Schlüssel AppID konfigurieren........... 464 Die IAccessControl-Schnittstelle............................................. 466 Die Komponentenidentität konfigurieren..................................... 471 Programmgesteuerte Sicherheit................................................. 473 Die Funktion CoInitializeSecurity............................................ 474 Die IAccessControl-Schnittstelle und CoInitializeSecurity...................... 481 Aktivierungsreferenzen und die COAUTHINFO-Struktur...................... 484 Die Schnittstelle IServerSecurity............................................. 487 Cloaking................................................................... 490 Die Schnittstelle IClientSecurity............................................. 491 X
19 Das Netzwerkprotokoll..................................................... 495 Das Netzwerkprotokoll untersuchen............................................ 497 Den Netzwerkmonitor ausführen............................................ 499 Fernaktivierung............................................................. 501 Internetdienste................................................................ 502 Remote-Objekte aufrufen...................................................... 504 Die Strukturen ORPCTHIS und ORPCTHAT................................. 507 Per Marshaling verpackte Schnittstellenzeiger.................................... 508 Die Standardobjektreferenz.................................................. 510 Die Struktur DUALSTRINGARRAY......................................... 511 Die Schnittstelle IRemUnknown............................................. 513 Die Schnittstelle IRemUnknown2............................................ 517 Der OXID-Resolver........................................................... 517 Speicherbereinigung........................................................... 520 Ein Fernmethodenaufruf.................................................... 523 Channel-Hooks............................................................... 524 Ein nützlicher Channel-Hook: Den Namen des Client-Rechners ermitteln....... 526 Teil IV Anhang........................................................................ 531 A Fernprozeduraufrufe........................................................ 533 Design und Zweck des RPC-Modells............................................ 533 Die Schnittstellendefinitionssprache IDL..................................... 534 Bindung................................................................... 535 Ortsunabhängigkeit......................................................... 535 Handles................................................................... 536 Die Prime-Applikation......................................................... 536 Initialisierung des Clients.................................................... 537 Rechenoperationen auf der Client-Seite....................................... 540 Der Prime-Server........................................................... 540 Kontextabschluss........................................................... 541 Debugging................................................................. 542 Verteilte Berechnung........................................................ 542 Stichwortverzeichnis............................................................ 543 Die Autoren..................................................................... 557 XI