ComWrappers Classe

Definizione

Spazio dei nomi:
System.Runtime.InteropServices
Assembly:
System.Runtime.InteropServices.dll
Origine:
ComWrappers.cs
Origine:
ComWrappers.cs
Origine:
ComWrappers.cs
Origine:
ComWrappers.cs
Origine:
ComWrappers.cs

Importante

Questa API non è conforme a CLS.

Classe per la gestione dei wrapper dei tipi 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 = class
Public MustInherit Class ComWrappers
Ereditarietà
Object
ComWrappers
Derivato
Attributi
CLSCompliantAttribute UnsupportedOSPlatformAttribute SupportedOSPlatformAttribute

Commenti

L'API ComWrappers fornisce supporto per l'API IUnknown indipendentemente dal supporto di interoperabilità COM predefinito. L'API ComWrappers espone il supporto di runtime minimo necessario per gli sviluppatori per sostituire la versione predefinita in modo efficiente.

Tradizionalmente nel runtime, un proxy nativo per un oggetto gestito viene chiamato COM Callable Wrapper (CCW) e un proxy gestito a un oggetto nativo è denominato Runtime Callable Wrapper (RCW). Tuttavia, se usato qui, questi termini non devono essere confusi con le funzionalità predefinite dello stesso nome (ovvero CCW e RCW). A differenza delle funzionalità predefinite, la maggior parte della responsabilità della gestione accurata del ciclo di vita, della distribuzione dei metodi e dell'organizzazione degli argomenti e dei valori restituiti viene lasciata all'implementatore di ComWrappers.

"Supporto minimo" è definito dalle funzionalità seguenti:

  1. Mapping efficiente tra un oggetto gestito e un proxy nativo, ad esempio CCW.
  2. Mapping efficiente tra un proxy nativo IUnknown e il relativo proxy gestito, ad esempio RCW.
  3. Integrazione con il Garbage Collector tramite il contratto di interfaccia IReferenceTrackerHost.

Utilizzare questo rappresenta uno scenario avanzato.

Stato proxy

In questa sezione vengono fornite descrizioni e illustrazioni dello stato proxy nativo e gestito dopo la rispettiva creazione.

Nelle illustrazioni seguenti viene illustrato un riferimento sicuro come linea continua (===) e un riferimento debole viene rappresentato come linea tratteggiata (= = =). I termini "riferimento forte" e "riferimento debole" devono essere interpretati come "prolungamento della durata" e "non prolungamento della durata", anziché implicare una specifica implementazione.

La figura seguente illustra lo stato dell'oggetto gestito e del proxy nativo dopo una chiamata a ComWrappers.GetOrCreateComInterfaceForObject(Object, CreateComInterfaceFlags).

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

Nella figura seguente viene illustrato lo stato dell'oggetto nativo e del proxy gestito dopo una chiamata a ComWrappers.GetOrCreateObjectForComInstance(IntPtr, CreateObjectFlags). Il concetto di "identità" segue le regole per IUnknown.

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

Osservare che esistono solo riferimenti deboli dal punto di vista del runtime. Si presuppone che il +1 conteggio dei riferimenti sull'oggetto nativo venga eseguito dall'autore del proxy gestito (ovvero l'implementatore ComWrappers) per garantire l'associazione della durata tra l'oggetto nativo e il relativo proxy gestito. Esiste un riferimento sicuro facoltativo (ovvero AddRef()) menzionato nel proxy gestito, usato per supportare lo scenario (3) menzionato in precedenza. Vedete CreateObjectFlags.TrackerObject. Con questo riferimento sicuro facoltativo, il conteggio dei riferimenti sarà +2.

Costruttori

Nome Descrizione
ComWrappers()

Costruttore dell'istanza.

Metodi

Nome Descrizione
ComputeVtables(Object, CreateComInterfaceFlags, Int32)

Calcola la Vtable desiderata per obj, rispettando i valori di flags.
CreateObject(IntPtr, CreateObjectFlags, Object, CreatedWrapperFlags)

Crea un oggetto gestito per l'oggetto a externalComObject cui punta rispettando i valori di flags.
CreateObject(IntPtr, CreateObjectFlags)

Crea un oggetto gestito per l'oggetto a cui externalComObject punta, rispettando i valori di flags.
Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.

(Ereditato da Object)
GetHashCode()

Funge da funzione hash predefinita.

(Ereditato da Object)
GetIUnknownImpl(IntPtr, IntPtr, IntPtr)

Ottiene l'implementazione IUnknown fornita dal runtime.
GetOrCreateComInterfaceForObject(Object, CreateComInterfaceFlags)

Crea una rappresentazione COM dell'oggetto fornito che può essere passato a un ambiente non gestito.
GetOrCreateObjectForComInstance(IntPtr, CreateObjectFlags, Object)

Ottiene l'oggetto gestito attualmente registrato o crea un nuovo oggetto gestito e lo registra.
GetOrCreateObjectForComInstance(IntPtr, CreateObjectFlags)

Ottiene l'oggetto gestito attualmente registrato o crea un nuovo oggetto gestito e lo registra.
GetOrRegisterObjectForComInstance(IntPtr, CreateObjectFlags, Object, IntPtr)

Ottiene l'oggetto gestito attualmente registrato o usa l'oggetto gestito fornito e lo registra.
GetOrRegisterObjectForComInstance(IntPtr, CreateObjectFlags, Object)

Ottiene l'oggetto gestito attualmente registrato o utilizza l'oggetto gestito fornito e lo registra.
GetType()

Ottiene il Type dell'istanza corrente.

(Ereditato da Object)
MemberwiseClone()

Crea una copia superficiale del Objectcorrente.

(Ereditato da Object)
RegisterForMarshalling(ComWrappers)

Registra un'istanza ComWrappers da usare come istanza globale per il marshalling nel runtime.
RegisterForTrackerSupport(ComWrappers)

Registra un'istanza ComWrappers da usare come istanza globale per il supporto dello strumento di rilevamento dei riferimenti.
ReleaseObjects(IEnumerable)

Rilascia una raccolta di oggetti al di fuori della normale durata dell'oggetto o dell'interfaccia COM.
ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.

(Ereditato da Object)
TryGetComInstance(Object, IntPtr)

Determina se l'oggetto gestito specificato è un ComWrapperswrapper gestito creato e, in tal caso, restituisce il puntatore non gestito di cui è stato eseguito il wrapping.
TryGetObject(IntPtr, Object)

Determina se l'oggetto COM specificato è un ComWrapperswrapper non gestito creato e, in tal caso, restituisce l'oggetto gestito di cui è stato eseguito il wrapping.

Si applica a