Classe System.Runtime.InteropServices.ComWrappers

Cet article fournit des remarques supplémentaires à la documentation de référence de 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 l'environnement d'exécution, un proxy natif vers un objet managé est appelé un Wrapper CCW (COM Callable Wrapper), et un proxy managé vers un objet natif est appelé un wrapper RCW (Runtime Callable Wrapper). 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, la responsabilité de la gestion précise de la durée de vie, des méthodes de répartition et du tri des arguments et des valeurs de retour incombe en grande partie au responsable de l’implémentation 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 élément natif IUnknown et son proxy managé (par exemple, RCW).
3. Intégration avec récupérateur de mémoire via le contrat d’interface IReferenceTrackerHost.

Exploiter cela est un scénario avancé.

État du proxy

Cette section fournit des descriptions et des illustrations de l’état des proxies, natifs et managés, 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. Voir CreateObjectFlags.TrackerObject. Avec cette référence forte facultative, le nombre de références serait +2.