Designing Efficient Interfaces
There are some special considerations to keep in mind when designing a custom
interface. If you follow these guidelines, your marshalling code can be used
across the network when support for remotable objects is provided in a future
release.
First of all, because data is shipped across address spaces, using
architecture-dependent types such as
int may prohibit the data from being re-created correctly in the object
application's address space. The size of an integer varies from architecture to
architecture. Thus, the data type
int should not be used for structure data members or interface method parameters.
Specifying data types unambiguously to the MIDL compiler will allow your
interface to be more easily transferred to remote machines with different
architectures and addressing schemes. The MIDL compiler requires all integer variables
that may be remoted to be explicitly declared as short, long, or their unsigned
equivalents.
A frequently used data type for pointers, the
void * construct, allows the callee of a method to interpret the data pointed to
according to the need. While local interfaces can use this construct, distributed
applications cannot. This is because the MIDL compiler must know exactly what
types of data are being transmitted so that the data can be accurately
re-created on the receiving side. The
void * construct is too vague.
Pointers to data must be used carefully. To re-create the data in the callee's
address space, RPC must know the exact size of the data. If, for example, a
char * parameter points to a buffer of characters rather than to a single character
(as is implied), the data cannot be correctly re-created. Use the syntax
available with MIDL to accurately describe the data structures represented by your
type definitions.
Initialization is essential for pointers that are embedded in arrays and
structures and passed across process boundaries. Uninitialized pointers may work
when passed to a program in the same process space, but proxies and stubs assume
that all pointers are initialized with valid addresses or are null.
Be careful when aliasing pointers (allowing pointers to point to the same
piece of memory). If the aliasing is intentional, these pointers should be declared
aliased in the IDL file. Pointers declared as non-aliased should never alias
each other.
The MIDL has directional attributes that let you specify the data flow
direction. The proxies and stubs use these attributes to determine whether to send the
data from the client to the object or from the object to the client,
respectively. Data labeled as
out only is uninitialized on the way to the interface stub; data labeled as
in only does not affect the data structures upon return. The
in, out attribute indicates that data is sent to the object initialized and the
object will change it before sending it back.
It is also imperative to realize the importance of defining status codes. This
must be coordinated by the definer of the interface to avoid conflicting error
codes.
Finally, the designer of an interface must develop an understanding of how the
interface will be used by client applications. In particular, the frequency of
method calls across the interface boundary and the amount of data to be
transferred to complete a given method call together determine whether the interface
will be efficient across process and machine boundaries. Although OLE makes
cross-process and, eventually, cross-network calls transparent to programs, it
cannot make high-frequency and high-bandwidth calls efficient across address
spaces. In some cases, it is more appropriate to design interfaces that will
normally be implemented only as in-process servers while other interfaces are more
appropriate for remote use.
- Software for developers
-
Delphi Components
.Net Components
Software for Android Developers
- More information resources
-
MegaDetailed.Net
Unix Manual Pages
Delphi Examples
- Databases for Amazon shops developers
-
Amazon Categories Database
Browse Nodes Database