Documentation
¶
Overview ¶
The ioi package implements the IOI client protocol.
Introduction ¶
The IManagedObject Interface Protocol provides interoperability support for the common language runtime (CLR). The common language runtime (CLR) is a virtual machine for the execution of software. The IManagedObject interface provides a bridge between existing computer systems and the virtual execution environment.
In particular, the CLR supports interoperability with the Component Object Model (COM).<1> The CLR supports exposing its own objects to COM for use as native COM objects and supports consuming COM objects.
In order to determine whether a COM object that enters the CLR is actually one of its own managed objects, the IManagedObject interface was created to allow for the CLR to identify its own objects. The IManagedObject Interface Protocol mechanism is detailed in this specification.
Overview ¶
The IManagedObject interface is a COM interface used by the common language runtime (CLR) to identify managed objects (objects created by the CLR) that are exported for interoperability with the Component Object Model (COM). The IManagedObject interface allows these objects to be identified when they reenter the CLR.
The IManagedObject interface is used specifically for scenarios in which managed code uses COM and interacts with a managed object. This interface is an optimization that allows managed code to avoid going through COM to interact with the managed object. There are two different scenarios in which this can occur: Either the managed object is within the same process division, the same application domain, or the managed object is in a different process division (application domain). In either case, this document discusses what is done instead of using DCOM [MS-DCOM] to interact between the CLR and managed objects.
When using COM, the COM Callable Wrapper (CCW) is the view of the object to COM, as defined in [MSDN-CCW]. When the CLR identifies a COM object that includes a CCW, a Runtime Callable Wrapper (RCW) is required in order to interact with the COM object, as defined in [MSDN-RCW]. If an RCW doesn't exist, the CLR attempts to create an RCW. If the object implements IManagedObject, the CLR determines that it is a .NET object. For more information on CCW and RCW, see [MSDN-CCW] and [MSDN-RCW].
In cases in which the .NET object is in the same process division, the CLR interacts directly with the .NET object.
Index ¶
Constants ¶
This section is empty.
Variables ¶
var (
// import guard
GoPackage = "dcom/ioi"
)
Functions ¶
This section is empty.
Types ¶
type ManagedObject ¶
type ManagedObject dcom.InterfacePointer
ManagedObject structure represents IManagedObject RPC structure.
The IManagedObject interface includes the following methods.
The client MUST be implemented with the type information for the remote object.<2>
Methods in RPC Opnum Order
+---------------------+----------------------------------------------------------------------------------+ | | | | METHOD | DESCRIPTION | | | | +---------------------+----------------------------------------------------------------------------------+ +---------------------+----------------------------------------------------------------------------------+ | GetSerializedBuffer | Returns a binary-formatted representation of a managed object, as specified in | | | [MS-NRBF] section 2.3. Opnum: 3 | +---------------------+----------------------------------------------------------------------------------+ | GetObjectIdentity | Used to determine if a COM object is a managed object that belongs to this CLR | | | instance and process subdivision. Opnum: 4 | +---------------------+----------------------------------------------------------------------------------+
func (*ManagedObject) InterfacePointer ¶
func (o *ManagedObject) InterfacePointer() *dcom.InterfacePointer
func (*ManagedObject) MarshalNDR ¶
func (*ManagedObject) NDRSizeInfo ¶
func (o *ManagedObject) NDRSizeInfo() []uint64
func (*ManagedObject) UnmarshalNDR ¶
type RemoteDispatch ¶
type RemoteDispatch dcom.InterfacePointer
RemoteDispatch structure represents IRemoteDispatch RPC structure.
func (*RemoteDispatch) InterfacePointer ¶
func (o *RemoteDispatch) InterfacePointer() *dcom.InterfacePointer
func (*RemoteDispatch) MarshalNDR ¶
func (*RemoteDispatch) NDRSizeInfo ¶
func (o *RemoteDispatch) NDRSizeInfo() []uint64
func (*RemoteDispatch) UnmarshalNDR ¶
type ServicedComponentInfo ¶
type ServicedComponentInfo dcom.InterfacePointer
ServicedComponentInfo structure represents IServicedComponentInfo RPC structure.
func (*ServicedComponentInfo) InterfacePointer ¶
func (o *ServicedComponentInfo) InterfacePointer() *dcom.InterfacePointer
func (*ServicedComponentInfo) MarshalNDR ¶
func (*ServicedComponentInfo) NDRSizeInfo ¶
func (o *ServicedComponentInfo) NDRSizeInfo() []uint64
Source Files
Directories