.NET and COM

This note is about book .NET and COM.

Think of XML Web services simply as components or Application Programming Interfaces (APIs) exposed on a Web site rather than a DLL residing on your own computer.

An assembly is a self-describing logical component. Assemblies are units of deployment, units of security, units of versioning, and units of scope for the types contained within. Although an assembly is typically one executable or one DLL, it could be made up of multiple files.

Any assemblies with type definitions contain corresponding type information describing them. This information is called metadata (data about data).

Reflection is the process of programmatically obtaining type information. Programs can dynamically inspect (“reflect upon”) the metadata for any assemblies, dynamically instantiate objects and invoke members, and even emit metadata dynamically (a technology called Refection Emit). Reflection provides late binding facilities like COM’s IDispatch and IDispatchEx interfaces, type inspection like COM’s ITypeInfo and ITypeInfo2 interfaces, and much more.

How Unmanaged Code Interacts with Managed Code

Three technologies exist that enable the interaction between unmanaged and managed code:

Platform Invocation Services (PInvoke)

 1 static class GameSharp
 2 {
 3     /// The native methods in the DLL's unmanaged code.
 4     internal static class UnsafeNativeMethods
 5     {
 6     const string _dllLocation = "CoreDLL.dll";
 7     [DllImport(_dllLocation)]
 8     public static extern void SimulateGameDLL(int a, int b);
 9     }
10 }
Choosing a Calling Convention
The calling convention of an entry point can be specified using another DllImportAttribute named parameter, called CallingConvention. The choices for this are as follows:
CallingConvention.Cdecl. The caller is responsible for cleaning the stack. Therefore, this calling convention is appropriate for methods that accept a variable number of parameters (like printf).
CallingConvention.FastCall. This is not supported by version 1.0 of the .NET Framework.
CallingConvention.StdCall. This is the default convention for PInvoke methods running on Windows. The callee is responsible for cleaning the stack.
CallingConvention.ThisCall. This is used for calling unmanaged methods defined on a class. All but the first parameter is pushed on the stack since the first parameter is the this pointer, stored in the ECX register.
CallingConvention.Winapi. This isn’t a real calling convention, but rather indicates to use the default calling convention for the current platform. On Windows (but not Windows CE), the default calling convention is StdCall.
Declare always uses Winapi, and the default for DllImportAttribute is also Winapi. As you might guess, this is the calling convention used by Win32 APIs, so this setting doesn’t need to be used in this chapter’s examples.
 1 using System;
 2 using System.Runtime.InteropServices;
 3 
 4 public class LibWrap
 5 {
 6 // C# doesn't support varargs so all arguments must be explicitly defined. 
 7 // CallingConvention.Cdecl must be used since the stack is  
 8 // cleaned up by the caller. 
 9 
10 // int printf( const char *format [, argument] )
11 
12 [DllImport("msvcrt.dll", CharSet=CharSet.Unicode, CallingConvention=CallingConvention.Cdecl)]
13 public static extern int printf(String format, int i, double d); 
14 
15 [DllImport("msvcrt.dll", CharSet=CharSet.Unicode, CallingConvention=CallingConvention.Cdecl)]
16 public static extern int printf(String format, int i, String s); 
17 }
18 
19 public class App
20 {
21     public static void Main()
22     {
23         LibWrap.printf("\nPrint params: %i %f", 99, 99.99);
24         LibWrap.printf("\nPrint params: %i %s", 99, "abcd");
25     }
26 }