Classe System.Runtime.InteropServices.ComWrappers

Observação

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

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

Tradicionalmente no tempo de execução, um proxy nativo para objeto gerenciado é chamado de COM Callable Wrapper (CCW), e um proxy gerenciado para um objeto nativo é chamado de Runtime Callable Wrapper (RCW). No entanto, quando usados aqui, esses termos não devem ser confundidos com os recursos internos do mesmo nome (ou seja, CCW e RCW). Ao contrário dos recursos internos, a maior parte da responsabilidade pelo gerenciamento preciso do ciclo de vida, métodos de chamada e organização 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 nativo IUnknown e seu proxy 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 respetiva 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 "prolongamento do tempo de vida" e "não prolongamento do tempo de vida", por oposição a implicar uma aplicaçã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 do ponto de vista 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 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 é usado para dar suporte ao cenário (3) mencionado anteriormente. Consulte CreateObjectFlags.TrackerObject. Com esta referência forte opcional, a contagem de referência seria +2.

  • Last updated on