ComWrappers Clase

Definición

Espacio de nombres:
System.Runtime.InteropServices
Ensamblado:
System.Runtime.InteropServices.dll
Source:
ComWrappers.cs
Source:
ComWrappers.cs
Source:
ComWrappers.cs
Source:
ComWrappers.cs
Source:
ComWrappers.cs

Importante

Esta API no es conforme a CLS.

Clase para administrar contenedores de tipos IUnknown COM.

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 = class
Public MustInherit Class ComWrappers
Herencia
Object
ComWrappers
Derivado
Atributos
CLSCompliantAttribute UnsupportedOSPlatformAttribute SupportedOSPlatformAttribute

Comentarios

La API ComWrappers proporciona compatibilidad con la API IUnknown independiente de la compatibilidad integrada con la interoperabilidad COM. La ComWrappers API expone la compatibilidad mínima en tiempo de ejecución necesaria para que los desarrolladores reemplacen la versión integrada de forma eficaz.

Tradicionalmente, en tiempo de ejecución, un proxy nativo para un objeto administrado se denomina Wrapper de Llamadas COM (CCW), y un proxy administrado para un objeto nativo se denomina Wrapper de Llamadas en Tiempo de Ejecución (RCW). Sin embargo, cuando se usa aquí, esos términos no deben confundirse con las características integradas del mismo nombre (es decir, CCW y RCW). A diferencia de las características integradas, la mayor parte de la responsabilidad de la administración precisa de la duración, los métodos de envío y la serialización de argumentos y valores devueltos queda para el implementador ComWrappers.

La "compatibilidad mínima" se define mediante las siguientes características:

  1. Asignación eficaz entre un objeto administrado y un proxy nativo (por ejemplo, CCW).
  2. Asignación eficaz entre un elemento nativo IUnknown y su proxy administrado (por ejemplo, RCW).
  3. Integración con el recolector de basura mediante el contrato de la interfaz IReferenceTrackerHost.

Aprovechar esto es un escenario avanzado.

Estado del proxy

En esta sección se proporcionan descripciones e ilustraciones del estado de proxy nativo y administrado tras su respectiva creación.

En las ilustraciones siguientes, una referencia fuerte se representa como una línea sólida (===) y una referencia débil se representa como una línea discontinua (= = =). Los términos "referencia fuerte" y "referencia débil" deben interpretarse como "extender la duración" y "no extender la duración", en lugar de implicar una implementación específica.

En la ilustración siguiente se muestra el estado del objeto administrado y el proxy nativo después de una llamada a ComWrappers.GetOrCreateComInterfaceForObject(Object, CreateComInterfaceFlags).

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

En la siguiente ilustración se muestra el estado del objeto nativo y el proxy administrado después de una llamada a ComWrappers.GetOrCreateObjectForComInstance(IntPtr, CreateObjectFlags). El concepto de "identidad" sigue las reglas de 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 solo existen referencias débiles desde la perspectiva del entorno de ejecución. El recuento de referencias +1 en el objeto nativo se supone que lo realiza el creador del proxy administrado (es decir, el ComWrappers implementador) para garantizar la vida útil asociada entre el objeto nativo y su proxy administrado. Hay una referencia segura opcional (es decir, AddRef()) mencionada en el proxy administrado, que se usa para admitir el escenario (3) mencionado anteriormente. Consulte CreateObjectFlags.TrackerObject. Con esta referencia segura opcional, el recuento de referencias sería +2.

Constructores

Nombre Description
ComWrappers()

Constructor de instancia.

Métodos

Nombre Description
ComputeVtables(Object, CreateComInterfaceFlags, Int32)

Calcula la tabla virtual deseada para obj, respetando los valores de flags.
CreateObject(IntPtr, CreateObjectFlags, Object, CreatedWrapperFlags)

Crea un objeto administrado para el objeto al externalComObject que apunta respetando los valores de flags.
CreateObject(IntPtr, CreateObjectFlags)

Crea un objeto administrado para el objeto al que externalComObject apunta, respetando los valores de flags.
Equals(Object)

Determina si el objeto especificado es igual al objeto actual.

(Heredado de Object)
GetHashCode()

Actúa como función hash predeterminada.

(Heredado de Object)
GetIUnknownImpl(IntPtr, IntPtr, IntPtr)

Obtiene la implementación de IUnknown proporcionada por el entorno de ejecución.
GetOrCreateComInterfaceForObject(Object, CreateComInterfaceFlags)

Crea una representación COM del objeto proporcionado que se puede pasar a un entorno no administrado.
GetOrCreateObjectForComInstance(IntPtr, CreateObjectFlags, Object)

Obtiene el objeto administrado registrado actualmente o crea un nuevo objeto administrado y lo registra.
GetOrCreateObjectForComInstance(IntPtr, CreateObjectFlags)

Obtiene el objeto administrado registrado actualmente o crea un nuevo objeto administrado y lo registra.
GetOrRegisterObjectForComInstance(IntPtr, CreateObjectFlags, Object, IntPtr)

Obtenga el objeto administrado registrado actualmente o use el objeto administrado proporcionado y lo registra.
GetOrRegisterObjectForComInstance(IntPtr, CreateObjectFlags, Object)

Obtiene el objeto administrado registrado actualmente o usa el objeto administrado proporcionado y lo registra.
GetType()

Obtiene el Type de la instancia actual.

(Heredado de Object)
MemberwiseClone()

Crea una copia superficial del Objectactual.

(Heredado de Object)
RegisterForMarshalling(ComWrappers)

Registra una ComWrappers instancia que se va a usar como instancia global para la serialización en tiempo de ejecución.
RegisterForTrackerSupport(ComWrappers)

Registra una ComWrappers instancia que se va a usar como instancia global para la compatibilidad con el seguimiento de referencias.
ReleaseObjects(IEnumerable)

Libera una colección de objetos fuera del objeto normal o la duración de la interfaz COM.
ToString()

Devuelve una cadena que representa el objeto actual.

(Heredado de Object)
TryGetComInstance(Object, IntPtr)

Determina si el objeto administrado especificado es un ComWrapperscontenedor administrado creado y, si es así, devuelve el puntero no administrado ajustado.
TryGetObject(IntPtr, Object)

Determina si el objeto COM especificado es un ComWrapperscontenedor no administrado creado y, si es así, devuelve el objeto administrado ajustado.

Se aplica a