ComWrappers Classe
Définition
Important
Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.
Important
Cette API n’est pas conforme CLS.
Classe pour la gestion des wrappers de types COM IUnknown.
public ref class ComWrappers abstract[System.CLSCompliant(false)]
[System.Runtime.Versioning.UnsupportedOSPlatform("android")]
[System.Runtime.Versioning.UnsupportedOSPlatform("browser")]
[System.Runtime.Versioning.UnsupportedOSPlatform("ios")]
[System.Runtime.Versioning.UnsupportedOSPlatform("tvos")]
public abstract class ComWrappers[System.CLSCompliant(false)]
[System.Runtime.Versioning.SupportedOSPlatform("windows")]
public abstract class ComWrappers[<System.CLSCompliant(false)>]
[<System.Runtime.Versioning.UnsupportedOSPlatform("android")>]
[<System.Runtime.Versioning.UnsupportedOSPlatform("browser")>]
[<System.Runtime.Versioning.UnsupportedOSPlatform("ios")>]
[<System.Runtime.Versioning.UnsupportedOSPlatform("tvos")>]
type ComWrappers = class[<System.CLSCompliant(false)>]
[<System.Runtime.Versioning.SupportedOSPlatform("windows")>]
type ComWrappers = classPublic MustInherit Class ComWrappers- Héritage
-
ComWrappers
- Dérivé
- Attributs
Remarques
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 :
- Mappage efficace entre un objet managé et un proxy natif (par exemple, CCW).
- Mappage efficace entre un élément natif
IUnknownet son proxy managé (par exemple, RCW). - 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.
Constructeurs
| Nom | Description |
|---|---|
| ComWrappers() |
Constructeur d’instance. |
Méthodes
| Nom | Description |
|---|---|
| ComputeVtables(Object, CreateComInterfaceFlags, Int32) |
Calcule la table virtuelle souhaitée pour |
| CreateObject(IntPtr, CreateObjectFlags, Object, CreatedWrapperFlags) |
Crée un objet managé pour l’objet pointé en respectant |
| CreateObject(IntPtr, CreateObjectFlags) |
Crée un objet managé pour l’objet qui |
| Equals(Object) |
Détermine si l’objet spécifié est égal à l’objet actuel. (Hérité de Object) |
| GetHashCode() |
Sert de fonction de hachage par défaut. (Hérité de Object) |
| GetIUnknownImpl(IntPtr, IntPtr, IntPtr) |
Obtient l’implémentation IUnknown fournie par le runtime. |
| GetOrCreateComInterfaceForObject(Object, CreateComInterfaceFlags) |
Crée une représentation COM de l’objet fourni qui peut être passée à un environnement non managé. |
| GetOrCreateObjectForComInstance(IntPtr, CreateObjectFlags, Object) |
Obtient l’objet managé actuellement inscrit ou crée un objet managé et l’inscrit. |
| GetOrCreateObjectForComInstance(IntPtr, CreateObjectFlags) |
Obtient l’objet managé actuellement inscrit ou crée un objet managé et l’inscrit. |
| GetOrRegisterObjectForComInstance(IntPtr, CreateObjectFlags, Object, IntPtr) |
Obtenez l’objet managé actuellement inscrit ou utilisez l’objet managé fourni et l’inscrit. |
| GetOrRegisterObjectForComInstance(IntPtr, CreateObjectFlags, Object) |
Obtient l’objet managé actuellement inscrit ou utilise l’objet managé fourni et l’inscrit. |
| GetType() |
Obtient la Type de l’instance actuelle. (Hérité de Object) |
| MemberwiseClone() |
Crée une copie superficielle du Objectactuel. (Hérité de Object) |
| RegisterForMarshalling(ComWrappers) |
Inscrit une ComWrappers instance à utiliser comme instance globale pour le marshaling dans le runtime. |
| RegisterForTrackerSupport(ComWrappers) |
Inscrit une ComWrappers instance à utiliser comme instance globale pour la prise en charge du suivi de référence. |
| ReleaseObjects(IEnumerable) |
Libère une collection d’objets en dehors de la durée de vie normale de l’objet ou de l’interface COM. |
| ToString() |
Retourne une chaîne qui représente l’objet actuel. (Hérité de Object) |
| TryGetComInstance(Object, IntPtr) |
Détermine si l’objet managé spécifié est un ComWrapperswrapper managé créé et, le cas échéant, retourne le pointeur non managé encapsulé. |
| TryGetObject(IntPtr, Object) |
Détermine si l’objet COM spécifié est un ComWrapperswrapper non managé créé et, le cas échéant, retourne l’objet managé encapsulé. |
