Klasse System.Runtime.InteropServices.ComWrappers

Opmerking

In dit artikel vindt u aanvullende opmerkingen in de referentiedocumentatie voor deze API.

De ComWrappers API biedt ondersteuning voor de IUnknown API onafhankelijk van de ingebouwde COM-interoperabiliteitsondersteuning. De ComWrappers API biedt de minimale runtime-ondersteuning die ontwikkelaars nodig hebben om de ingebouwde versie op een efficiënte manier te vervangen.

Traditioneel in de runtime wordt een systeemeigen proxy naar beheerd object een COM Callable Wrapper (CCW) genoemd en wordt een beheerde proxy naar een systeemeigen object een Runtime Callable Wrapper (RCW) genoemd. Wanneer deze termen hier echter worden gebruikt, moeten deze termen niet worden verward met de ingebouwde functies van dezelfde naam (dat wil gezegd CCW en RCW). In tegenstelling tot de ingebouwde functies wordt het merendeel van de verantwoordelijkheid voor nauwkeurig levensduurbeheer, dispatching-methoden en marshalling van argumenten en retourwaarden overgelaten aan de ComWrappers implementator.

'Minimale ondersteuning' wordt gedefinieerd door de volgende functies:

1. Efficiënte koppeling tussen een beheerd object en een systeemeigen proxy (bijvoorbeeld CCW).
2. Efficiënte koppeling tussen een systeemeigen IUnknown en zijn beheerde proxy (bijvoorbeeld RCW).
3. Integratie met de garbagecollector via het IReferenceTrackerHost-interfacecontract .

Door dit te benutten is dit een geavanceerd scenario.

Proxy-staat

Deze sectie bevat beschrijvingen en illustraties van de natuurlijke en beheerde proxystatus na hun respectieve creatie.

In de volgende illustraties wordt een sterke verwijzing weergegeven als een ononderbroken lijn (===) en wordt een zwakke verwijzing weergegeven als een stippellijn (= = =). De termen 'sterke verwijzing' en 'zwakke verwijzing' moeten worden geïnterpreteerd als 'levensduur verlengen' en 'niet de levensduur verlengen', in plaats van een specifieke implementatie te impliceren.

In de volgende afbeelding ziet u de status van het beheerde object en de systeemeigen proxy na een aanroep naar ComWrappers.GetOrCreateComInterfaceForObject(Object, CreateComInterfaceFlags).

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

In de volgende afbeelding ziet u de status van het systeemeigen object en de beheerde proxy na een aanroep naar ComWrappers.GetOrCreateObjectForComInstance(IntPtr, CreateObjectFlags). Het concept 'identiteit' volgt de regels voor IUnknown.

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

Merk op dat alleen zwakke verwijzingen bestaan vanuit het perspectief van runtime. Het +1 referentieaantal van het systeemeigen object wordt geacht uitgevoerd te worden door de beheerste proxy-creator (dat wil zeggen, de ComWrappers implementer) om de bijbehorende levensduur tussen het systeemeigen object en zijn beheerde proxy te garanderen. Er is een optionele sterke verwijzing (namelijk AddRef()) vermeld in de beheerde proxy, die wordt gebruikt om scenario (3) te ondersteunen dat eerder is genoemd. Zie CreateObjectFlags.TrackerObject. Met deze optionele sterke verwijzing zou het aantal verwijzingen zijn +2.