Compartilhar via

System.Runtime.InteropServices.ComWrappers classe

  • Artigo

Este artigo fornece observações complementares à documentação de referência para essa API.

A ComWrappers API fornece suporte para a IUnknown API independentemente do suporte interno de interoperabilidade COM. A ComWrappers API expõe o suporte de tempo de execução mínimo necessário para que os desenvolvedores substituam a versão interna de maneira eficiente.

Tradicionalmente no tempo de execução, um proxy nativo para o objeto gerenciado é chamado de CCW (Callable Wrapper) e um proxy gerenciado para um objeto nativo é chamado de RCW (Runtime Callable Wrapper). No entanto, quando usados aqui, esses termos não devem ser confundidos com os recursos internos de mesmo nome (ou seja, CCW e RCW). Ao contrário dos recursos internos, a maior parte da responsabilidade pelo gerenciamento preciso do tempo de vida, métodos de despacho e agrupamento de argumentos e valores de retorno é deixada para o ComWrappers implementador.

"Suporte mínimo" é definido pelos seguintes recursos:

  1. Mapeamento eficiente entre um objeto gerenciado e um proxy nativo (por exemplo, CCW).
  2. Mapeamento eficiente entre um proxy nativo IUnknown e seu gerenciado (por exemplo, RCW).
  3. Integração com o coletor de lixo através do contrato de interface IReferenceTrackerHost .

Aproveitar isso é um cenário avançado.

Estado do proxy

Esta seção fornece descrições e ilustrações do estado de proxy nativo e gerenciado após sua respectiva criação.

Nas ilustrações a seguir, uma referência forte é representada como uma linha sólida () e uma referência fraca é representada como uma linha tracejada (==== = =). Os termos "referência forte" e "referência fraca" devem ser interpretados como "prolongando a vida útil" e "não prolongando a vida útil", em vez de implicarem uma implementação específica.

A ilustração a seguir mostra o estado do objeto gerenciado e do proxy nativo após uma chamada para ComWrappers.GetOrCreateComInterfaceForObject(Object, CreateComInterfaceFlags).

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

A ilustração a seguir mostra o estado do objeto nativo e do proxy gerenciado após uma chamada para ComWrappers.GetOrCreateObjectForComInstance(IntPtr, CreateObjectFlags). O conceito de "identidade" segue as regras para 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 existem apenas referências fracas da perspectiva do tempo de execução. Presume-se +1 que a contagem de referência no objeto nativo seja executada pelo criador do proxy gerenciado (ou seja, o implementador) para garantir o tempo de vida associado entre o ComWrappers objeto nativo e seu proxy gerenciado. Há uma referência forte opcional (ou seja, ) mencionada no proxy gerenciado, AddRef()que é usada para dar suporte ao cenário (3) mencionado anteriormente. Consulte CreateObjectFlags.TrackerObject. Com essa referência forte opcional, a contagem de referência seria +2.