{"id":33,"date":"2013-07-26T11:20:35","date_gmt":"2013-07-26T11:20:35","guid":{"rendered":"https:\/\/praveenkatiyar.wordpress.com\/?p=33"},"modified":"2013-07-26T11:20:35","modified_gmt":"2013-07-26T11:20:35","slug":"marshaling-introduction-1-of-n","status":"publish","type":"post","link":"https:\/\/praveenkatiyar.in\/blog\/index.php\/2013\/07\/26\/marshaling-introduction-1-of-n\/","title":{"rendered":"Marshaling Introduction (1 of N)"},"content":{"rendered":"

What is Marshaling?<\/a><\/h3>\n

Marshaling <\/strong>(similar to serialization) is the process of transforming the memory representation of an object to a data format suitable for storage or transmission. It is typically used when data must be moved between different parts of a computer program or from one program to another.<\/p>\n

in the .NET scenario, Marshaling is the process of creating a bridge between managed code and unmanaged code; it is the homer that carries messages from the managed to the unmanaged environment and reverse. It is one of the core services offered by the CLR (Common Language Runtime.) Because much of the types in unmanaged environment do not have counterparts in managed environment, you need to create conversion routines that convert the managed types into unmanaged and vice versa; and that is the marshaling process. As a refresher, we call .NET code \u201cmanaged\u201d because it is controlled (managed) by the CLR. Other code that is not controlled by the CLR is called <\/p>\n

When we need Marshaling<\/a><\/h3>\n

You already know that there is no such compatibility between managed and unmanaged environments. In other words, .NET does not contain such the types HRESULT, DWORD, and HANDLE that exist in the realm of unmanaged code. Therefore, you need to find a .NET substitute or create your own if needed. That is what called marshaling.<\/p>\n

An example is the unmanaged DWORD; it is an unsigned 32-bit integer, so we can marshal it in .NET as System.UInt32. Therefore, System.UInt32 is a substitute for the unmanaged DWORD.<\/p>\n

Marshaling comes handy when you are working with unmanaged code, whether you are working with Windows API or COM components. It helps you interoperating (i.e. working) correctly with these environments by providing a way to share data between the two environments.  <\/p>\n

\"image\"<\/a><\/p>\n

Interop Marshaling<\/h3>\n

Interop marshaling governs how data is passed in method arguments and return values between managed and unmanaged memory during calls. Interop marshaling is a run-time activity performed by the common language runtime’s marshaling service. <\/p>\n

Most data types have common representations in both managed and unmanaged memory. The interop marshaler handles these types for you. Other types can be ambiguous or not represented at all in managed memory. <\/p>\n

An ambiguous type can have either multiple unmanaged representations that map to a single managed type, or missing type information, such as the size of an array. For ambiguous types, the marshaler provides a default representation and alternative representations where multiple representations exist. You can supply explicit instructions to the marshaler on how it is to marshal an ambiguous type. <\/p>\n

Default Marshaling<\/h3>\n