Partager via

Classe System.Runtime.InteropServices.ComWrappers

  • Article

Cet article vous offre des remarques complémentaires à la documentation de référence pour cette API.

L’API ComWrappers prend en charge l’API IUnknown indépendamment de la prise en charge intégrée de l’interopérabilité COM. L’API ComWrappers expose la prise en charge minimale du runtime nécessaire aux développeurs pour remplacer la version intégrée de manière efficace.

Traditionnellement dans le runtime, un proxy natif vers un objet managé est appelé wrapper POUVANT appeler COM (CCW), et un proxy managé vers un objet natif est appelé wrapper pouvant être appelé wrapper pouvant être appelé Runtime Callable Wrapper (RCW). Toutefois, lorsqu’ils sont utilisés ici, ces termes ne doivent pas être confondus avec les fonctionnalités intégrées du même nom (autrement dit, CCW et RCW). Contrairement aux fonctionnalités intégrées, une majorité de la responsabilité de la gestion précise de la durée de vie, de la répartition des méthodes et du marshaling des arguments et des valeurs de retour est laissée à l’implémenteur ComWrappers .

La « prise en charge minimale » est définie par les fonctionnalités suivantes :

  1. Mappage efficace entre un objet managé et un proxy natif (par exemple, CCW).
  2. Mappage efficace entre un proxy natif IUnknown et son proxy managé (par exemple, RCW).
  3. Intégration au garbage collector via le contrat d’interface IReferenceTrackerHost .

Il s’agit d’un scénario avancé.

État du proxy

Cette section fournit des descriptions et des illustrations de l’état du proxy natif et managé après leur création respective.

Dans les illustrations suivantes, une référence forte est représentée sous la forme d’une ligne solide (===) et une référence faible est représentée comme une ligne en pointillés (= = =). Les termes « référence forte » et « référence faible » doivent être interprétés comme « prolonger la durée de vie » et « ne pas prolonger la durée de vie », plutôt que d’impliquer une implémentation spécifique.

L’illustration suivante montre l’état de l’objet managé et du proxy natif après un appel à ComWrappers.GetOrCreateComInterfaceForObject(Object, CreateComInterfaceFlags).

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

L’illustration suivante montre l’état de l’objet natif et du proxy managé après un appel à ComWrappers.GetOrCreateObjectForComInstance(IntPtr, CreateObjectFlags). Le concept d'« identité » suit les règles pour IUnknown.

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

Notez que seules les références faibles existent du point de vue du runtime. Le +1 nombre de références sur l’objet natif est supposé être effectué par le créateur de proxy managé (autrement dit, l’implémenteur ComWrappers ) pour garantir la durée de vie associée entre l’objet natif et son proxy managé. Il existe une référence forte facultative (autrement dit, AddRef()) mentionnée dans le proxy managé, qui est utilisée pour prendre en charge le scénario (3) mentionné précédemment. Consultez CreateObjectFlags.TrackerObject. Avec cette référence forte facultative, le nombre de références serait +2.