Condividi tramite

Classe System.Runtime.InteropServices.ComWrappers

  • Articolo

Questo articolo fornisce osservazioni supplementari alla documentazione di riferimento per questa API.

L'API ComWrappers fornisce supporto per l'API IUnknown indipendentemente dal supporto di interoperabilità COM predefinito. L'API ComWrappers espone il supporto di runtime minimo necessario per gli sviluppatori per sostituire la versione predefinita in modo efficiente.

Tradizionalmente nel runtime, un proxy nativo per un oggetto gestito viene chiamato COM Callable Wrapper (CCW) e un proxy gestito a un oggetto nativo è denominato Runtime Callable Wrapper (RCW). Tuttavia, se usato qui, questi termini non devono essere confusi con le funzionalità predefinite dello stesso nome (ovvero CCW e RCW). A differenza delle funzionalità predefinite, la maggior parte della responsabilità della gestione accurata della durata, dell'invio dei metodi e del marshalling degli argomenti e dei valori restituiti viene lasciata all'implementatore ComWrappers .

"Supporto minimo" è definito dalle funzionalità seguenti:

  1. Mapping efficiente tra un oggetto gestito e un proxy nativo , ad esempio CCW.
  2. Mapping efficiente tra un proxy nativo IUnknown e il relativo proxy gestito, ad esempio RCW.
  3. Integrazione con il Garbage Collector tramite il contratto di interfaccia IReferenceTrackerHost .

Sfruttando questo scenario è uno scenario avanzato.

Stato proxy

In questa sezione vengono fornite descrizioni e illustrazioni dello stato proxy nativo e gestito dopo la rispettiva creazione.

Nelle illustrazioni seguenti viene illustrato un riferimento sicuro come linea continua (===) e un riferimento debole viene rappresentato come linea tratteggiata (= = =). I termini "riferimento sicuro" e "riferimento debole" devono essere interpretati come "estensione della durata" e "non estensione della durata", anziché implicare un'implementazione specifica.

La figura seguente illustra lo stato dell'oggetto gestito e del proxy nativo dopo una chiamata a ComWrappers.GetOrCreateComInterfaceForObject(Object, CreateComInterfaceFlags).

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

Nella figura seguente viene illustrato lo stato dell'oggetto nativo e del proxy gestito dopo una chiamata a ComWrappers.GetOrCreateObjectForComInstance(IntPtr, CreateObjectFlags). Il concetto di "identità" segue le regole per IUnknown.

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

Osservare che esistono solo riferimenti deboli dal punto di vista del runtime. Si presuppone che il +1 conteggio dei riferimenti sull'oggetto nativo venga eseguito dall'autore del proxy gestito( ovvero l'implementatore ComWrappers ) per garantire la durata associata tra l'oggetto nativo e il relativo proxy gestito. Esiste un riferimento sicuro facoltativo (ovvero AddRef()) menzionato nel proxy gestito, usato per supportare lo scenario (3) menzionato in precedenza. Vedere CreateObjectFlags.TrackerObject. Con questo riferimento sicuro facoltativo, il conteggio dei riferimenti sarà +2.