System.Runtime.InteropServices.ComWrappers-Klasse

Dieser Artikel enthält ergänzende Hinweise zur Referenzdokumentation für diese API.

Die ComWrappers API bietet Unterstützung für die IUnknown API unabhängig von der integrierten COM-Interoperabilitätsunterstützung. Die ComWrappers API macht die minimale Laufzeitunterstützung verfügbar, die für Entwickler erforderlich ist, um die integrierte Version effizient zu ersetzen.

Traditionell wird in der Laufzeit ein nativer Proxy für ein verwaltetes Objekt als COM Callable Wrapper (CCW) bezeichnet, und ein verwalteter Proxy für ein natives Objekt wird als Runtime Callable Wrapper (RCW) bezeichnet. Wenn diese Begriffe hier verwendet werden, sollten diese Begriffe jedoch nicht mit den integrierten Features desselben Namens (d. b. CCW und RCW) verwechselt werden. Im Gegensatz zu den integrierten Funktionen liegt ein Großteil der Verantwortung für die korrekte Verwaltung der Lebensdauer, das Dispatching von Methoden und das Marshalling von Argumenten und Rückgabewerten beim ComWrappers-Implementierer.

"Minimale Unterstützung" wird durch die folgenden Features definiert:

1. Effiziente Zuordnung zwischen einem verwalteten Objekt und einem systemeigenen Proxy (z. B. CCW).
2. Effiziente Zuordnung zwischen einem nativen IUnknown und seinem verwalteten Proxy (z. B. RCW).
3. Integration mit dem Garbage Collector über den IReferenceTrackerHost-Interface-Contract.

Dies ist ein fortgeschrittenes Szenario.

Stellvertreterstaat

Dieser Abschnitt enthält Beschreibungen und Abbildungen des Status von nativen und verwalteten Proxys nach ihrer jeweiligen Erstellung.

In den folgenden Abbildungen wird ein starker Bezug als einfarbige Linie (===) dargestellt, und ein schwacher Bezug wird als gestrichelte Linie (= = =) dargestellt. Die Begriffe "starker Bezug" und "schwacher Bezug" sollten als "Verlängern der Lebensdauer" und "nicht verlängerte Lebensdauer" interpretiert werden, im Gegensatz zu einer bestimmten Implementierung.

Die folgende Abbildung zeigt den Status des verwalteten Objekts und des systemeigenen Proxys nach einem Aufruf von ComWrappers.GetOrCreateComInterfaceForObject(Object, CreateComInterfaceFlags).

 --------------------                  ----------------------
|   Managed object   |                |     Native proxy     |
|                    |                | Ref count: 1         |
|  ----------------  |                |  ------------------  |
| | Weak reference |=| = = = = = = = >| | Strong reference | |
| |    to proxy    | |<===============|=|    to object     | |
|  ----------------  |                |  ------------------  |
 --------------------                  ----------------------

Die nächste Abbildung zeigt den Status des systemeigenen Objekts und des verwalteten Proxys nach einem Aufruf von ComWrappers.GetOrCreateObjectForComInstance(IntPtr, CreateObjectFlags). Das Konzept der "Identität" folgt den Regeln für IUnknown.

 ------------------               ------------------
|  Native object   |< = = = = = =|                  |
| Ref count: +1    |             | Mapping from     |
 ------------------              | native identity  |
 ------------------------        | to managed proxy |
|   Managed proxy        |< = = =|                  |
| Created by ComWrappers |        ------------------
|   implementer.        |
| Optional AddRef() on   |
|   native object.      |
 ------------------------

Beachten Sie, dass nur schwache Verweise aus Laufzeitperspektive vorhanden sind. Es wird davon ausgegangen, dass die +1-Referenzzählung des nativen Objekts vom Ersteller des verwalteten Proxys (d.h. dem ComWrappers-Implementierer) durchgeführt wird, um die zugehörige Lebensdauer zwischen dem nativen Objekt und seinem verwalteten Proxy sicherzustellen. Im verwalteten Proxy wird ein optionaler starker Verweis (das heißt AddRef()) erwähnt, der dazu verwendet wird, das früher erwähnte Szenario (3) zu unterstützen. Siehe CreateObjectFlags.TrackerObject. Mit diesem optionalen starken Verweis wäre die Anzahl der Referenzen +2.