|
IMarshal
The IMarshal interface allows an object to perform custom marshaling of interface
pointers.
"Marshaling" is the process of packaging function parameters into data packets
in order to send them to a different process or machine. "Unmarshaling" is the
process of recovering those parameters when they are received. When a remote
function call passes an interface pointer as a function parameter, that pointer
is marshaled in such a way that it becomes possible for a client in one process
to use that interface pointer to call methods on an object in another process.
OLE marshals an interface pointer by creating a proxy object in the client's
process. A client holds an interface pointer to the proxy object and calls
methods using that pointer; the proxy marshals the method parameters and sends them
to the original process, thus forwarding the method call to the original
object. The IMarshal interface allows an object to control what kind of proxies are created.
When to Implement
You almost never need to implement this interface. OLE provides a default
implementation of IMarshal that uses OLE-generated proxy objects; this is suitable for almost all
situations. You implement the IMarshal interface only if you want to perform custom marshaling; this allows you to
write your own proxy objects.
OLE uses your implementation of IMarshal in the following manner: When it's necessary to create a remote interface
pointer to your object (that is, when a pointer to your object is passed as a
parameter in a remote function call), OLE queries your object for the IMarshal interface. If your object implements it, OLE uses your IMarshal implementation to create the proxy object. If your object does not implement IMarshal, OLE uses its standard implementation.
Some situations in which you might want to perform custom marshaling are as
follows:
- The objects you are writing keep their state in shared memory. In this case,
both the original process and the client process uses proxies that refer to the
shared memory. This type of custom marshaling is possible only if the client
process is on the same machine as the original process. The compound file
implementations of IStorage and IStream are examples of this type of custom marshaling.
- The objects you are writing are immutable, that is, their state does not
change after creation. Instead of forwarding method calls to the original objects,
you can simply create copies of those objects in the client process. This
technique avoids the cost of context switches (switching from one process to
another). Monikers are an example of immutable objects; if you are implementing your
own moniker class, you should perform custom marshaling.
Note that these situations do not require you to create a separate class of
proxy objects; the same objects are used by both the original process and the
client process. In other situations, you may need to write a separate class of
proxy objects (with its own CLSID) that forward calls to the original objects, in
addition to implementing IMarshal on the original objects.
When to Use
You typically do not need to call this interface. OLE is the primary user of
this interface.
Methods in VTable Order
See Also
IStdMarshalInfo
| Last news from Greatis Software |
 |
|
Nostalgia .Net |
|
.Net is powerful, but not all-powerful, so sometimes we need to use Win32 API for our .Net applications. It's simple enough with Platform Invoke if you have Win32 skill, but we do not always have time to dig the ancient documentation, declare the special types that are compatible with Win32, find the values of the Win32's constants and so on. Nostalgia .Net offers several simple-to-use classes, and components that will allow you to forget about the headache of Win32 and just use the power of Win32 in your application the same way as you use the native. Net classes. More » |
| Recommended software for developers |
 |
|
Ultimate Pack |
|
Component pack for Delphi and C++ Builder that contains runtime form designer, runtime object inspector, print suite and much more for the very special price. More » |
 |
|
Form Designer .Net |
|
Unique runtime form design solution that allows to edit any form in .Net WinForms application at runtime with full source codes for only 300 euro! More » |
 |
|
Print Suite .Net |
|
Print Suite .Net is a set of components for easy printing texts, images and grids from your WinForms applications. Full C# source codes are available More » |
 |
|
Gradient Controls .Net |
|
Gradient Controls .Net offers controls with gradient background feature. Labels, panels and so on... Full C# source codes are available More » |
 |
|
Greatis iGrid |
|
iGrid plots drawing grid right over your desktop, so you can use it everywhere, with any drawing application without any special plugins for different graphic editors. More » |
All the contacts and projectsDmitry Vasiliev (just.dmitry)
Related LinksSoftware for Visual Studio .NET developers
Software for Delphi and C++ Builder developers
Software for Visual Basic 6 developers
Delphi Tips&Tricks
MegaDetailed.NET More Online Helps Win32 Programmer's Reference
Win32 Multimedia Programmer's Reference
OLE Programmer's Reference
Microsoft Windows Pen API Programmer's Reference
Microsoft Windows Sockets 2 Reference
Microsoft Windows Telephony API (TAPI) Programmer's Reference
Unix Manual Pages
|
