M B A R K's Blog
Overview on Marshaling in C#

Overview on Marshaling in C#

M B A R K's photo
M B A R K
·

4 min read

Table of contents

Marshaling is the process of converting data between different formats, such as between managed and unmanaged code. In C#, marshaling is often used to interact with native code, such as code written in C or C++. In this article, we will explore the basics of marshaling in C# and provide some examples of how it can be used.

Types of Marshaling

There are several types of marshaling in C#, each with its own use case. The most commonly used types are:

  • Blittable: This type of marshaling is used for data types that can be directly copied from one memory location to another without the need for any conversion. Examples of blittable types include integers, floating-point numbers, and structures that contain only blittable types.

  • Non-Blittable: This type of marshaling is used for data types that cannot be directly copied from one memory location to another. Examples of non-blittable types include strings, arrays, and structures that contain non-blittable types.

  • Custom: This type of marshaling is used when the default marshaling provided by C# is not sufficient. Custom marshaling allows developers to control the process of converting data between managed and unmanaged code.

Examples of Marshaling in C#

Here are some examples of how marshaling can be used in C#:

Example 1: Marshaling a C String

The following example shows how to marshal a C-style string (a null-terminated array of characters) to a C# string:

using System;
using System.Runtime.InteropServices;

class Program {
    [DllImport("example.dll")]
    private static extern IntPtr GetCString();

    static void Main(string[] args) {
        IntPtr cString = GetCString();
        string cSharpString = Marshal.PtrToStringAnsi(cString);
        Console.WriteLine(cSharpString);
    }
}

In this example, the GetCString function is imported from an external DLL (example.dll) and returns a pointer to a C-style string. The Marshal.PtrToStringAnsi method is used to convert the pointer to a C# string.

Example 2: Marshaling a Structure

The following example shows how to marshal a C structure to a C# struct:

[StructLayout(LayoutKind.Sequential)]
public struct Point {
    public int x;
    public int y;
}

[DllImport("example.dll")]
private static extern Point GetPoint();

Point point = GetPoint();
Console.WriteLine("({0}, {1})", point.x, point.y);

In this example, the Point struct is defined in C# and has the same layout as the C structure. The GetPoint function is imported from an external DLL (example.dll) and returns a Point struct. The returned struct can be directly used in C# code.

Example 3: Marshaling a custom object

The following example shows how to marshal a custom object to a C# object

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
public class CustomObject
{
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
    public string name;
    public int age;

    [DllImport("example.dll")]
    private static extern IntPtr GetCustomObject();

    public static CustomObject FromIntPtr(IntPtr p)
    {
        return (CustomObject)Marshal.PtrToStructure(p, typeof(CustomObject));
    }

    public static void Main(string[] args)
    {
        IntPtr pCustomObject = GetCustomObject();
        CustomObject customObject = FromIntPtr(pCustomObject);
        Console.WriteLine("Name: {0}, Age: {1}", customObject.name, customObject.age);
    }
}

In this example, a custom class is defined in C#, with a string and an int field. The class has a method FromIntPtr which converts an IntPtr to an object of the class using Marshal.PtrToStructure method, which takes the pointer to the unmanaged memory block and the type of the structure to be created as arguments. In the Main method, the GetCustomObject function is imported from an external DLL (`example.dll`) and returns a pointer to a C-style custom object. The returned pointer is passed to the FromIntPtr method to convert the object to a C# object, and then the object fields are printed to the console.

Conclusion

Marshaling in C# allows developers to interact with native code by converting data between different formats. Marshaling can be used for a variety of purposes, such as calling functions in external DLLs, passing data between managed and unmanaged code, and converting data structures from one format to another. The examples provided in this article demonstrate some of the basic concepts of marshaling in C#, but there are many other advanced scenarios that can be implemented using marshaling. It is important to keep in mind that marshaling can be a complex process, and it is essential to have a good understanding of the data types and memory layouts involved in order to ensure that the process is done correctly.

C#