Compartir a través de

Clase System.Runtime.InteropServices.ComWrappers

  • Artículo

En este artículo se proporcionan comentarios adicionales a la documentación de referencia de esta API.

La ComWrappers API proporciona compatibilidad con la IUnknown API independiente de la compatibilidad integrada con la interoperabilidad COM. La ComWrappers API expone la compatibilidad mínima en tiempo de ejecución necesaria para que los desarrolladores reemplacen la versión integrada de forma eficaz.

Tradicionalmente en tiempo de ejecución, un proxy nativo para un objeto administrado se denomina contenedor com invocable (CCW) y un proxy administrado a un objeto nativo se denomina contenedor invocable en tiempo de ejecución (RCW). Sin embargo, cuando se usa aquí, esos términos no deben confundirse con las características integradas del mismo nombre (es decir, CCW y RCW). A diferencia de las características integradas, la mayor parte de la responsabilidad de la administración precisa de la duración, los métodos de envío y la serialización de argumentos y valores devueltos queda para el ComWrappers implementador.

La "compatibilidad mínima" se define mediante las siguientes características:

  1. Asignación eficaz entre un objeto administrado y un proxy nativo (por ejemplo, CCW).
  2. Asignación eficaz entre un proxy nativo IUnknown y su proxy administrado (por ejemplo, RCW).
  3. Integración con el recolector de elementos no utilizados a través del contrato de interfaz IReferenceTrackerHost .

Aprovechar esto es un escenario avanzado.

Estado del proxy

En esta sección se proporcionan descripciones e ilustraciones del estado de proxy nativo y administrado después de su creación respectiva.

En las ilustraciones siguientes, una referencia fuerte se representa como una línea sólida (===) y una referencia débil se representa como una línea discontinua (= = =). Los términos "referencia fuerte" y "referencia débil" deben interpretarse como "extender la duración" y "no extender la duración", en lugar de implicar una implementación específica.

En la ilustración siguiente se muestra el estado del objeto administrado y el proxy nativo después de una llamada a ComWrappers.GetOrCreateComInterfaceForObject(Object, CreateComInterfaceFlags).

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

En la siguiente ilustración se muestra el estado del objeto nativo y el proxy administrado después de una llamada a ComWrappers.GetOrCreateObjectForComInstance(IntPtr, CreateObjectFlags). El concepto de "identidad" sigue las reglas de IUnknown.

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

Observe que solo existen referencias débiles desde la perspectiva del entorno de ejecución. Se +1 supone que el creador del proxy administrado realiza el recuento de referencias en el objeto nativo (es decir, el ComWrappers implementador) para garantizar la duración asociada entre el objeto nativo y su proxy administrado. Hay una referencia segura opcional (es decir, AddRef()) mencionada en el proxy administrado, que se usa para admitir el escenario (3) mencionado anteriormente. Vea CreateObjectFlags.TrackerObject. Con esta referencia segura opcional, el recuento de referencias sería +2.