Compartir a través de

Clase System.Runtime.InteropServices.ComWrappers

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

La API ComWrappers proporciona compatibilidad con la API IUnknown 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 Wrapper de Llamadas COM (CCW), y un proxy administrado para un objeto nativo se denomina Wrapper de Llamadas 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 implementador ComWrappers.

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 elemento nativo IUnknown y su proxy administrado (por ejemplo, RCW).
  3. Integración con el recolector de basura mediante el contrato de la 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 tras su respectiva creación.

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. El recuento de referencias +1 en el objeto nativo se supone que lo realiza el creador del proxy administrado (es decir, el ComWrappers implementador) para garantizar la vida útil 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. Consulte CreateObjectFlags.TrackerObject. Con esta referencia segura opcional, el recuento de referencias sería +2.

  • Last updated on