ComWrappers Classe

Definizione

Importante

Questa API non è conforme a CLS.

Classe per gestire i wrapper di tipi IUnknown COM.Class for managing wrappers of COM IUnknown types.

public ref class ComWrappers abstract
[System.CLSCompliant(false)]
[System.Runtime.Versioning.SupportedOSPlatform("windows")]
public abstract class ComWrappers
[<System.CLSCompliant(false)>]
[<System.Runtime.Versioning.SupportedOSPlatform("windows")>]
type ComWrappers = class
Public MustInherit Class ComWrappers
Ereditarietà
ComWrappers
Attributi

Commenti

L' ComWrappers API fornisce supporto per l' IUnknown ABI, indipendentemente dal supporto di interoperabilità COM incorporato.The ComWrappers API provides support for the IUnknown ABI, independent of the built-in COM interoperability support. L' ComWrappers API espone il supporto di runtime minimo necessario per gli sviluppatori per sostituire la versione predefinita in modo efficiente.The ComWrappers API exposes the minimal runtime support that's needed for developers to replace the built-in version in an efficient manner.

Tradizionalmente in fase di esecuzione, un proxy nativo all'oggetto gestito è denominato COM Callable Wrapper (CCW) e un proxy gestito a un oggetto nativo viene definito Runtime Callable Wrapper (RCW).Traditionally in the runtime, a native proxy to managed object is called a COM Callable Wrapper (CCW), and a managed proxy to a native object is called a Runtime Callable Wrapper (RCW). Tuttavia, se usato in questo caso, tali termini non devono essere confusi con le funzionalità predefinite con lo stesso nome (ovvero CCW e RCW).However, when used here, those terms should not be confused with the built-in features of the same name (that is, CCW and RCW). Diversamente dalle funzionalità predefinite, la maggior parte della responsabilità per la gestione della durata, l'invio di metodi e il marshalling di argomenti e valori restituiti viene lasciata all' ComWrappers implementatore.Unlike the built-in features, a majority of the responsibility for accurate lifetime management, dispatching methods, and marshalling of arguments and return values is left to the ComWrappers implementer.

Il "supporto minimo" è definito dalle funzionalità seguenti:"Minimal support" is defined by the following features:

  1. Mapping efficiente tra un oggetto gestito e un proxy nativo (ad esempio, CCW).Efficient mapping between a managed object and a native proxy (for example, CCW).

  2. Mapping efficiente tra un IUnknown proxy nativo e il relativo proxy gestito (ad esempio, RCW).Efficient mapping between a native IUnknown and its managed proxy (for example, RCW).

  3. Integrazione con il Garbage Collector tramite il contratto di interfaccia IReferenceTrackerHost .Integration with the garbage collector through the IReferenceTrackerHost interface contract.

    Si tratta di uno scenario avanzato.Leveraging this is an advanced scenario.

Stato proxyProxy state

In questa sezione vengono fornite le descrizioni e le illustrazioni dello stato nativo e del proxy gestito dopo la rispettiva creazione.This section provides descriptions and illustrations of native and managed proxy state after their respective creation.

Nelle illustrazioni seguenti un riferimento sicuro viene rappresentato come una linea continua ( === ) e un riferimento debole viene rappresentato come una linea tratteggiata ( = = = ).In the following illustrations, a strong reference is depicted as a solid line (===) and a weak reference is depicted as a dashed line (= = =). I termini "riferimento sicuro" e "riferimento debole" devono essere interpretati come "estensione della durata" e "durata non estensione", anziché implicare un'implementazione specifica.The terms "strong reference" and "weak reference" should be interpreted as "extending lifetime" and "not extending lifetime", as opposed to implying a specific implementation.

Nella figura seguente viene illustrato lo stato dell'oggetto gestito e del proxy nativo dopo una chiamata a ComWrappers.GetOrCreateComInterfaceForObject(Object, CreateComInterfaceFlags) .The following illustration shows the state of the managed object and native proxy after a call to ComWrappers.GetOrCreateComInterfaceForObject(Object, CreateComInterfaceFlags).

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

Nell'illustrazione seguente viene mostrato lo stato dell'oggetto nativo e del proxy gestito dopo una chiamata a ComWrappers.GetOrCreateObjectForComInstance(IntPtr, CreateObjectFlags) .The next illustration shows the state of the native object and managed proxy after a call to ComWrappers.GetOrCreateObjectForComInstance(IntPtr, CreateObjectFlags). Il concetto di "identità" segue le regole per IUnknown .The concept of "identity" follows the rules for IUnknown.

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

Si noti che dal punto di vista del runtime sono presenti solo riferimenti deboli.Observe that only weak references exist from the runtime perspective. Il +1 conteggio dei riferimenti nell'oggetto nativo viene considerato eseguito dal creatore del proxy gestito, ovvero l' ComWrappers implementatore, per garantire la durata associata tra l'oggetto nativo e il relativo proxy gestito.The +1 reference count on the native object is assumed to be performed by the managed proxy creator (that is, the ComWrappers implementer) to ensure the associated lifetime between the native object and its managed proxy. È presente un riferimento sicuro facoltativo (ovvero, AddRef() ) indicato nel proxy gestito, usato per supportare lo scenario (3) indicato in precedenza.There is an optional strong reference (that is, AddRef()) mentioned in the managed proxy, which is used to support scenario (3) mentioned earlier. Vedere CreateObjectFlags.TrackerObject.See CreateObjectFlags.TrackerObject. Con questo riferimento sicuro facoltativo, il conteggio dei riferimenti sarà +2 .With this optional strong reference, the reference count would be +2.

Costruttori

ComWrappers()

Costruttore di istanze.Instance constructor.

Metodi

ComputeVtables(Object, CreateComInterfaceFlags, Int32)

Calcola l'elemento Vtable desiderato per obj, rispettando i valori di flags.Computes the desired Vtable for obj, respecting the values of flags.

CreateObject(IntPtr, CreateObjectFlags)

Crea un oggetto gestito per l'oggetto a cui externalComObject punta, rispettando i valori di flags.Creates a managed object for the object that externalComObject points to, respecting the values of flags.

Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(Ereditato da Object)
GetHashCode()

Funge da funzione hash predefinita.Serves as the default hash function.

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

Ottiene l'implementazione di IUnknown fornita dal runtime.Gets the runtime-provided IUnknown implementation.

GetOrCreateComInterfaceForObject(Object, CreateComInterfaceFlags)

Crea una rappresentazione COM dell'oggetto specificato che può essere passata a un ambiente non gestito.Creates a COM representation of the supplied object that can be passed to a non-managed environment.

GetOrCreateObjectForComInstance(IntPtr, CreateObjectFlags)

Ottiene l'oggetto gestito attualmente registrato o crea un nuovo oggetto gestito e lo registra.Gets the currently registered managed object or creates a new managed object and registers it.

GetOrRegisterObjectForComInstance(IntPtr, CreateObjectFlags, Object)

Ottiene l'oggetto gestito attualmente registrato o usa l'oggetto gestito specificato e lo registra.Gets the currently registered managed object or uses the supplied managed object and registers it.

GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Ereditato da Object)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Ereditato da Object)
RegisterForMarshalling(ComWrappers)

Registra un'istanza di ComWrappers da usare come istanza globale per il marshalling nel runtime.Registers a ComWrappers instance to be used as the global instance for marshalling in the runtime.

RegisterForTrackerSupport(ComWrappers)

Registra un'istanza di ComWrappers da usare come istanza globale per il supporto della registrazione dei riferimenti.Registers a ComWrappers instance to be used as the global instance for reference tracker support.

ReleaseObjects(IEnumerable)

Rilascia una raccolta di oggetti al di fuori della normale durata dell'interfaccia COM o dell'oggetto.Releases a collection of objects outside of the normal object or COM interface lifetime.

ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.Returns a string that represents the current object.

(Ereditato da Object)

Si applica a