Classe System.Runtime.InteropServices.ComWrappers

Este artigo fornece comentários complementares à documentação de referência para esta API.

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

Tradicionalmente no runtime, um proxy nativo para objeto gerenciado é chamado de CCW (Com 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 incorporados, a maior parte da responsabilidade pelo gerenciamento preciso do tempo de vida, pelo envio de métodos e pela organização de argumentos e valores de retorno é deixada para o implementador ComWrappers.

O "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 IUnknown nativo e seu proxy gerenciado (por exemplo, RCW).
3. Integração com o coletor de lixo por meio do contrato de interface IReferenceTrackerHost .

Aproveitar esse é 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 é retratada como uma linha sólida (===) e uma referência fraca é retratada como uma linha tracejada (= = =). Os termos "referência forte" e "referência fraca" devem ser interpretados como "estendendo o tempo de vida" e "não estendendo o tempo de vida", em vez de implicar 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 próxima ilustração 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. Supõe-se +1 que a contagem de referência no objeto nativo seja executada pelo criador de proxy gerenciado (ou seja, o ComWrappers implementador) para garantir o tempo de vida associado entre o objeto nativo e seu proxy gerenciado. Há uma referência forte opcional (ou seja, AddRef()) mencionada no proxy gerenciado, que é usada para dar suporte ao cenário (3) mencionado anteriormente. Consulte CreateObjectFlags.TrackerObject. Com essa referência forte opcional, o contador de referência seria +2.