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. 

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 }

• Mixed-Mode Programming Using Managed Extensions to C++

• COM Interoperability

      Building COM Objects in C#