Rohit Vipin Mathews

Interoperability is the process of communication between two separate systems.

In .NET Interop, the first system is always the .NET Framework; the other system might be any other technology.

Unmanaged interoperation is not easy as the managed interop, and it's also much difficult and much harder to implement. In unmanaged code interoperation, the first system is the .NET code; the other system might be any other technology including Win32 API, COM, ActiveX, etc.

Interoperation with Native Libraries.

Interoperation with COM components.

This is the most famous form of .NET interop with unmanaged code. We usually call this technique, Platform Invocation, or simplyPInvoke. Platform Invocation or PInvoke refers to the technique used to call functions of native unmanaged libraries such as the Windows API.

To PInvoke a function, you must declare it in your .NET code. That declaration is called the Managed Signature. To complete the managed signature, you need to know the following information about the function:

1. The library file which the function resides in.

2. Function name.

3. Return type of the function.

4. Input parameters.

5. Other relevant information such as encoding.

using System.Runtime.InteropServices;

namespace InterOp_with_API

{

class Program

{

public enum beepType

{

Beep = -1,

OK=0x00,

Question=0x20,

Exclamation=0x30,

Asterix=0x40,

}

[DllImport("User32.dll",ExactSpelling=true)]

static extern bool MessageBeep(uint type);

static void Main(string[] args)

{

MessageBeep((uint)beepType.Exclamation);

MessageBeep((uint)beepType.Question);

}

}

}

Marshaling is the process of converting unmanaged types into managed and vice versa . That conversion can be done in many ways based on the type to be converted.

For example, BOOL can simply be converted to System.Boolean, and LPCTSTR can be converted to System.String, System.Text.StringBuilder, or even System.Char[].

Compound types (like structures and unions) usually don't have counterparts in .NET code and thus you need to create them manually.

COM Interop is very large and much harder than P/Invoke and it has many ways to implement.

COM Interop includes all COM-related technologies such as OLE, COM+, ActiveX, etc.

You can't talk directly to unmanaged code.

you have to declare your functions and types in your .NET code.

To include a COM-component in your .NET application, you go to the COM tab of the Add Reference dialog and select the COM component that you wish to add to your project and use it!

When you add a COM-component to your .NET application, Visual Studio automatically declares all functions and types in that library for you.

It creates a Proxy library (i.e. assembly) that contains the managed signatures of the unmanaged types and functions of the COM component and adds it to your .NET application.

The proxy acts as an intermediary layer between your .NET assembly and the COM-component. Therefore, your code actually calls the managed signatures in the proxy library that forwards your calls to the COM-component and returns back the results.

Proxy libraries also called Primary Interop Assemblies (PIAs) and Runtime Callable Wrappers (RCWs.)

Now you don't have to ship a proxy/PIA/RCW assembly along with your executable since the information in this assembly can now be embedded into your executable; its called Interop Type Embedding.

//Add a reference to the Microsoft Speech Object Library

class Program

{

static void Main(string[] args)

{

Console.WriteLine("Enter the text to read:");

string txt = Console.ReadLine();

Speak(txt);

}

static void Speak(string text)

{

SpVoice voice = new SpVoiceClass();

voice.Speak(text, SpeechVoiceSpeakFlags.SVSFDefault);

}

}

ActiveX is no more than a COM component that has an interface.

To add an ActiveX control to .NET application, right-click the Toolbox, select Choose Toolbox Items, switch to the COM Components tab and select the controls to be used in the application.