//
you're reading...
Interop Marshaling

Passing Managed Structures With Strings To Unmanaged Code Part 1

1. Introduction.

1.1 Managed structures that contain strings are a common sight. The trouble is that managed strings are non-blittable. This means that they do not have a single common representation in the unmanaged world. However, there are several standardized representations that are recognized by the CLR.

1.2 A managed string is also a referenced type which means that it cannot be a directly embedded as part of the memory block of its containing structure. Contrast this with a value type (e.g. integer) which can be directly part of a containing structure.

1.3 As such, a managed structure which contains string members cannot be directly passed to an unmanaged function. It needs to be transformed into an unmanaged representation that can be used by unmanaged code. This transformation is what makes a managed string accessible and consumable by unmanaged code. It is also part of the interop marshaling process and is the topic of this series of blogs.

2. Unmanaged String Representations.

2.1 Unmanaged strings can be represented in many different ways. Each unmanaged language can have its own internal representation.

2.2 The C/C++ language has its own rather famous NULL-terminated character array. A Pascal string intrinsically contains its length as a prefix (similar to a BSTR). Other languages may have their own internal representations. A string need not even be internally organized as an array.

2.3 Because of the diversity of string representations in the unmanaged world, the Interop Marshaler can only standardize on a few to represent a string contained within an unmanaged structure. These are :

  • A fixed length inline NULL-terminated character array (aka C-style string).
  • A pointer to a NULL-terminated character array (better known as LPCSTR in C/C++ lingo).
  • A BSTR.

2.4 The selected representation is indicated by using the MarshalAsAttribute. In section 4 below, we shall discuss how to represent a managed string (contained within a structure) as a fixed-length character array inside an unmanaged structure. In section 5, we will explore how to represent the string as a pointer to a NULL-terminated string. And finally in section 6, we will explore BSTRs.

2.5 Throughout this part 1, we will focus only on passing a structure from managed code to unmanaged code by value. In further parts of this series, we will study how such a structure can be passed from unmanaged code to managed code as “out” (return) parameters. In yet further parts, we will discuss how such a structure may be passed two-ways (as “in” and “out” parameters).

2.6 Throughout this series of blogs, the unmanaged code shall be based on C++.

3. Sample Structure.

3.1 Throughout this part 1, we shall use the following managed structure for illustrative purposes :

public struct TestStruct01
{
  public string m_strString;
};

3.2 Now, in order that this structure be marshalable to unmanaged code, a minimum amount of specification must be afforded to the interop marshaler in the form of the StructLayoutAttribute. This attribute indicates the general memory layout of the structure when represented in unmanaged code. The following is a typical way this structure is put to use :

[StructLayout(LayoutKind.Sequential, Pack = 1, CharSet = CharSet.Ansi)]
public struct TestStruct01
{
  public string m_strString;
};

3.3 The “LayoutKind” enumeration controls the memory layout of an object when exported to unmanaged code. The Sequential value indicates that the members of the structure are laid out sequentially, in the order in which they appear when exported to unmanaged memory.

3.4 The “Pack” argument indicates the byte packing between the struct members. I have used a value of 1 for simplicity.

3.5 The “CharSet” argument indicates the character set that the string member is to map to in unmanaged code. Here, we have specified “Ansi” which means that the “m_strString” string member, when marshaled to unmanaged code, will contain Ansi characters. Note that managed strings always contain Unicode characters internally.

4. Representing a String as an Inline NULL-Terminated Character Array.

4.1 A string member of a managed structure, when to be marshaled across as an inline NULL-terminated character array, must be declared with the following MarshalAsAttribute :

[MarshalAs(UnmanagedType.ByValTStr, SizeConst = <size of character array>)]

The “UnmanagedType.ByValTStr” argument indicates that the string member will be marshaled as a “by value array” of characters the size of which is indicated by the “SizeConst” argument. The “SizeConst” value includes the terminating NULL-character for the string.

Note well the description “by value array” (contrast this to “by reference array”). This means that the string will be marshaled as an inline array of characters which are embedded within the containing structure itself.

4.2 The following is an example structure :

[StructLayout(LayoutKind.Sequential, Pack = 1, CharSet = CharSet.Ansi)]
public struct TestStruct01
{
  [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 21)]
  public string m_strString;
};

The “SizeConst” argument is set to a value of 21 as an example. Hence the “m_strString” string member must contain at most 20 characters. The 21st character will be the terminating NULL.

4.3 The corresponding C++ equivalent of such a structure is :

#pragma pack (1)

struct TestStruct01
{
  char m_szString[21];
};

4.4 An example C++-based unmanaged API that takes such a structure as an “in” value parameter is listed below :

void __stdcall DisplayTestStruct01(/*[in]*/ TestStruct01 test_struct_01)
{
  printf("test_struct_01.m_szString : [%s].\r\n", test_struct_01.m_szString);
}

The string contents of the “m_szString” member of the C++-based TestStruct01 structure is displayed.

4.5 The following is how such an API is declared in C# :

[DllImport("TestDLL01.dll", CallingConvention = CallingConvention.StdCall)]
public static extern void DisplayTestStruct01([In] TestStruct01 test_struct_01);

4.6 And a sample C# method of using the TestStruct01 structure with a call to the DisplayTestStruct01() API :

static void DisplayTestStruct01()
{
  TestStruct01 test_struct_01;

  test_struct_01.m_strString = "Hello World";

  DisplayTestStruct01(test_struct_01);
}

Of course, “test_struct_01.m_strString” must be set to a string value that does not exceed 20 characters in length. If so the string will be truncated for the sake of the final terminating NULL character.

4.7 Low-level wise, where does the unmanaged “m_szString” struct member reside ? Now, since the DisplayTestStruct01() API takes an “in” (read-only) TestStruct01 structure, the entire unmanaged structure (which includes the m_szString inline character array) can simply be pushed onto the call stack.

4.8 Hence the interop marshaler uses the stack space to create the unmanaged TestStruct01 structure and copies the contents of the “m_szString” member of the managed “test_struct_01” into the corresponding member of the unmanaged struct on the stack.

4.9 The use of the stack to store the entire unmanaged structure is most ideal in this situation because the structure is read-only (hence the interop marshaler need not concern itself about changes) and because when the API returns, the stack space is automatically recovered, saving the interop marshaler the trouble of any memory release.

5. Representing a String as a Pointer to an Unmanaged NULL-Terminated Character Array.

5.1 A string member of a managed structure, when to be marshaled across as a pointer to an unmanaged NULL-terminated character array, must be declared with the following MarshalAsAttribute :

[MarshalAs(UnmanagedType.LPStr)]

This indicates that the string member is to be marshaled across as a pointer to a NULL-terminated ANSI character array.

5.2 The following is an example structure :

[StructLayout(LayoutKind.Sequential, Pack = 1)]
public struct TestStruct02
{
  [MarshalAs(UnmanagedType.LPStr)]
  public string m_strString;
};

Notice that TestStruct02 is very similar to TestStruct01 except for the MarshalAsAttribute applied to the “m_strString” member.

5.3 The corresponding C++ equivalent of such a structure is :

#pragma pack (1)

struct TestStruct02
{
  LPCSTR m_pszString;
};

5.4 An example C++-based unmanaged API that takes such a structure as an “in” value parameter is listed below :

void __stdcall DisplayTestStruct02(/*[in]*/ TestStruct02 test_struct_02)
{
  printf("test_struct_02.m_pszString : [%s].\r\n", test_struct_02.m_pszString);
}

The string contents of the buffer pointed to by the “m_pszString” member of the C++-based TestStruct02 structure is displayed.

5.5 The following is how such an API is declared in C# :

[DllImport("TestDLL01.dll", CallingConvention = CallingConvention.StdCall)]
public static extern void DisplayTestStruct02([In] TestStruct02 test_struct_02);

5.6 And a sample C# method of using the TestStruct02 structure with a call to the DisplayTestStruct02() API :

static void DisplayTestStruct02()
{
  TestStruct02 test_struct_02;

  test_struct_02.m_strString = "Hello World";

  DisplayTestStruct02(test_struct_02);
}

5.7 This time, the length of the string assignable to “m_strString” is not limited to any fixed length (viz the TestStruct01 structure).

5.8 Under the covers, the “test_struct_02” itself will be pushed onto the stack just like the previous case with the TestStruct01 structure and the call to the DisplayTestStruct01() API. The “m_pszString” member, however, is a pointer to a NULL-terminated C-style string. It will not be an inline member of this structure. What will happen is that the Interop Marshaler will allocate a memory buffer that will be used to store the unmanaged string which is based on the value in “test_struct_02.m_strString”. It is a pointer to this buffer that will be passed as the unmanaged “test_struct_02.m_pszString” that we saw in DisplayTestStruct02() of point 5.4. Then when the API returns, the interop marshaler will free this buffer.

5.9 The memory allocation is done via the CoTaskMemAlloc() API. The interop marshaler may call this API directly or it may use the static Marshal.AllocCoTaskMem() method which will eventually call CoTaskMemAlloc(). The memory freeing is done CoTaskMemFree(). The interop marshaler may call it directly or use the Marshal.FreeCoTaskMem() static method which will eventually call CoTaskMemFree().

5.10 As an alternative to using “UnmanagedType.LPStr”, we can also use “UnmanagedType.LPWStr”. In this case, the C# string would be marshaled across as a wide-character string (i.e. Unicode). The C# declaration for the TestStruct02 structure would be :

[StructLayout(LayoutKind.Sequential, Pack = 1)]
public struct TestStruct02
{
  [MarshalAs(UnmanagedType.LPWStr)]
  public string m_strString;
};

The C++ declaration for TestStruct02 would be :

#pragma pack (1)

struct TestStruct02
{
  LPCWSTR m_pszString;
};

The C++ API DisplayTestStruct02() would be :

void __stdcall DisplayTestStruct02(/*[in]*/ TestStruct02 test_struct_02)
{
  printf("test_struct_02.m_pszString : [%S].\r\n", test_struct_02.m_pszString);
}

The C# DisplayTestStruct02() method that calls the DisplayTestStruct02() API is the same.

6. Representing a String as a BSTR.

6.1 A string member of a managed structure, when to be marshaled across as a BSTR, must be declared with the following MarshalAsAttribute :

[MarshalAs(UnmanagedType.BStr)]

This indicates that the string member is to be marshaled across as a COM BSTR.

6.2 The following is an example structure :

[StructLayout(LayoutKind.Sequential, Pack = 1)]
public struct TestStruct03
{
  [MarshalAs(UnmanagedType.BStr)]
  public string m_strString;
};

6.3 The corresponding C++ equivalent of such a structure is :

#pragma pack (1)

struct TestStruct03
{
  BSTR m_bstr;
};

6.4 An example C++-based unmanaged API that takes such a structure as an “in” value parameter is listed below :

void __stdcall DisplayTestStruct03(/*[in]*/ TestStruct03 test_struct_03)
{
  printf("test_struct_03.m_bstr : [%S].\r\n", test_struct_03.m_bstr);
}

This API simply prints out the “m_bstr” member of the input “test_struct_03” struct.

6.5 The following is how such an API is declared in C# :

[DllImport("TestDLL01.dll", CallingConvention = CallingConvention.StdCall)]
public static extern void DisplayTestStruct03([In] TestStruct03 test_struct_03);

6.6 And a sample C# method of using the TestStruct03 structure with a call to the DisplayTestStruct03() API :

static void DisplayTestStruct03()
{
  TestStruct03 test_struct_03;

  test_struct_03.m_strString = "Hello World";

  DisplayTestStruct03(test_struct_03);
}

6.7 Just like the “m_strString” member of the “TestStruct02” structure, the length of the string assignable to the “m_strString” member of the “TestStruct03” structure is not limited to any fixed length.

6.8 Under the covers, the unmanaged version of “test_struct_03” will be pused onto the stack just like the previous 2 examples. The Interop Marshaler will internally allocate a BSTR (via SysAllocString()) that will be used to store the unmanaged string which is based on the value in “test_struct_03.m_strString”. It is this BSTR that will be passed as the unmanaged “test_struct_03.m_bstr” that we saw in DisplayTestStruct03() of point 6.4. Then when the API returns, the interop marshaler will free this BSTR (via SysFreeString()).

7. Special Handling for Structures Passed by Pointers.

7.1 If a structure (containing a string field member) is to be passed to an unmanaged API as a pointer, special processing (similar to manual marshaling) needs to be done.

7.2 Let’s say we need to pass a pointer to TestStruct01 as a parameter to an API :

void __stdcall DisplayTestStruct01_ViaPointer(/*[in]*/ TestStruct01* ptest_struct_01)
{
  printf("ptest_struct_01 -> m_szString : [%s].\r\n", ptest_struct_01 -> m_szString);
}

7.3 The above API will need to be declared in C# as :

[DllImport(@"TestDLL01.dll", CallingConvention = CallingConvention.StdCall)]
public static extern void DisplayTestStruct01_ViaPointer([In] IntPtr ptest_struct_01);

7.4 This time, the structure will need to be passed as an IntPtr. Now, because there is no MarshalAsAttributes attached to this IntPtr parameter, the interop marshaler does not know how to perform automatic marshaling. Hence all marshaling will need to be performed manually. The following will need to be done :

  • A managed TestStruct01 structure will need to be allocated and its string field assigned as usual.
  • The size of TestStruct01 in unmanaged memory will need to be calculated.
  • A block of unmanaged memory the size of the unmanaged version of TestStruct01 will have to be allocated.
  • The field values of the managed TestStruct01 will have to be transferred (i.e. marshaled) to the unmanaged memory block which now serves as the unmanaged representation of TestStruct01.
  • After this, the unmanaged API is be invoked with a pointer to the unmanaged TestStruct01.
  • After the API call, the unmanaged structure will need to be freed. This is where careful attention must be taken. There are 2 steps to be taken in sequence.
  • First, the field values of the structure which are references to memory (e.g. a LPSTR or a BSTR) must have their referenced memory freed.
  • Next, the unmanaged structure itself must be freed.
  • Because the parameter was passed as an “in” parameter, it was passed as a read-only parameter. The unmanaged API is not allowed to modify its memory. The managed application is the rightful owner of the memory of the unmanaged representation of the TestStruct01 structure and so the deallocation of the memory for the unmanaged TestStruct01 must be done within the managed application code.

7.5 The C# code below demonstrates this in detail :

static void DisplayTestStruct01_ViaPointer()
{
  // Create TestStruct01 and assign value to its field as usual.
  TestStruct01 test_struct_01 = new TestStruct01();

  test_struct_01.m_strString = "Hello World";

  // Determine the size of the TestStruct01 for marshaling.
  int iSizeOfTestStruct01 = Marshal.SizeOf(typeof(TestStruct01));
  // Allocate in unmanaged memory a block of memory the size
  // of an unmanaged TestStruct01 structure.
  IntPtr ptest_struct_01 = Marshal.AllocHGlobal(iSizeOfTestStruct01);
  // Transfer the contents of the managed TestStruct01
  // (i.e. test_struct_01) to the unmanaged memory
  // which now serves as the unmanaged representation
  // of test_struct_01.
  Marshal.StructureToPtr(test_struct_01, ptest_struct_01, false);
  // Call the API using a pointer to the unmanaged test_struct_01.
  DisplayTestStruct01_ViaPointer(ptest_struct_01);
  // We must remember to destroy the test_struct_01 structure.
  // Doing this will free any fields which are references
  // to memory.
  Marshal.DestroyStructure(ptest_struct_01, typeof(TestStruct01));
  // Finally, the block of memory allocated for the
  // unmanaged test_struct_01 must itself be freed.
  Marshal.FreeHGlobal(ptest_struct_01);
  ptest_struct_01 = IntPtr.Zero;
}

7.6 The following are the pertinent points concerning the code above :

  • The Marshal.SizeOf() method is used to calculate the byte size of the unmanaged TestStruct01 structure. This is done with the help of the StructLayoutAttribute and the MarshalAsAttributes decorated on the structure.
  • The Marshal.AllocHGlobal() method is used to perform the actual memory allocation for the unmanaged structure. Note that Marshal.AllocCoTaskMem() may also be used.
  • Next comes the important step of transferring the contents of the managed TestStruct01 to the unmanaged memory which now serves as the unmanaged representation of test_struct_01. This is done by using Marshal.StructureToPtr().
  • The above step is crucial because recall that we want to pass TestStruct01 to the unmanaged API to have its field contents displayed. Hence the unmanaged structure must contain values equivalent to those of the managed structure.
  • The API DisplayTestStruct01_ViaPointer() is then called with the pointer to the unmanage structure passed as parameter.
  • After the API is called, nothing further needs to be done to the managed TestStruct01 structure. It has done its part.
  • However the unmanaged structure still remains in memory and we must remember to destroy it. In this destruction process, we must also free any fields which are references to memory. This is done using Marshal.DestroyStructure().
  • Now the unmanaged TestStruct01 structure contains an inline embedded character array which is not a reference to memory. Calling Marshal.DestroyStructure() will not destroy this inline array. The call is harmless nevertheless.
  • Next we must free the unmanaged TestStruct01 structure itself. This is done by calling Marshal.FreeHGlobal on the IntPtr.

7.7 Note my remark that after the call to DisplayTestStruct01_ViaPointer(), nothing further needs to be done to the managed TestStruct01 structure. This is because the spirit and intent of the DisplayTestStruct01_ViaPointer() API is to take a pointer to the unmanaged TestStruct01 structure as an “in” parameter.

This means that we do not expect any changes to be done to the structure, i.e. changes that will need to be reflected in the managed version of the same structure. Later, when we study the passing of the structure as an “out” or an “in and out” parameter, extra work will need to be done to ensure that changes made to the unmanaged structure are transferred to the managed version. More on this in part 2 and 3.

7.8 The very useful function used in the code in point 7.5 is Marshal.DestroyStructure(). This method will thoroughly free fields which are references to memory (e.g. a string).

In order to use Marshal.DestroyStructure() effectively, the structure must be properly decorated with MarshalAsAttributes for fields which are reference types. In the above example, Marshal.DestroyStructure() is used to destroy a pointer to an unmanaged TestStruct01 structure.

7.9 Now the unmanaged TestStruct01 contains an embedded character array. It will not be touched by Marshal.DestroyStructure(). However, genuine reference type fields, e.g. those declared to be marshaled as a pointer to a NULL-terminated character array (as is the case for TestStruct02) :

[MarshalAs(UnmanagedType.LPStr)]
public string m_strString;

or a BSTR (as is the case for TestStruct03) :

[MarshalAs(UnmanagedType.BStr)]
public string m_strString;

will be handled correctly by Marshal.DestroyStructure().

7.10 In fact, the code in 7.5 can be modified to handle TestStruct02 and TestStruct03. If we were working with TestStruct02 (the string field of which is marshaled as a pointer to a NULL-terminated C-style string) when the m_strString field is marshaled across to its unmanaged counterpart, the interop marshaler will allocate memory for the NULL-terminated character array string and then transfer the string value in the m_strString field to this array via Marshal.StringToCoTaskMemAnsi(). This is done during a call to Marshal.StructureToPtr().

Then, when Marshal.DestroyStructure() is called, Marshal.FreeCoTaskMem() (which eventually calls ::CoTaskMemFree()) is called to free the memory occuppied by the NULL-terminated character array string.

7.11 If it was TestStruct03 that was passed as a pointer to the unmanaged API, then ::SysAllocStringLen() will be used to allocated the BSTR field when Marshal.StructureToPtr() is called. And ::SysFreeString() will be used to free the BSTR when Marshal.DestroyStructure() is called.

7.12 I have created the following set of code constructs for the reader to test with TestStruct02 and TestStruct03 :

void __stdcall DisplayTestStruct01_ViaPointer(/*[in]*/ TestStruct01* ptest_struct_01)
{
  printf("ptest_struct_01 -> m_szString : [%s].\r\n", ptest_struct_01 -> m_szString);
}

void __stdcall DisplayTestStruct02_ViaPointer(/*[in]*/ TestStruct02* ptest_struct_02)
{
  printf("ptest_struct_02 -> m_pszString : [%s].\r\n", ptest_struct_02 -> m_pszString);
}

void __stdcall DisplayTestStruct03_ViaPointer(/*[in]*/ TestStruct03* ptest_struct_03)
{
  printf("ptest_struct_03 -> m_bstr : [%S].\r\n", ptest_struct_03 -> m_bstr);
}

Listed above are the C++ definitions for the 3 display APIs each of which takes a pointer to one of the versions of the test structs.

Listed below are various C# code constructs :

[DllImport("TestDLL01.dll", CallingConvention = CallingConvention.StdCall)]
public static extern void DisplayTestStruct01_ViaPointer([In] IntPtr ptest_struct_01);

[DllImport("TestDLL01.dll", CallingConvention = CallingConvention.StdCall)]
public static extern void DisplayTestStruct02_ViaPointer([In] IntPtr ptest_struct_02);

[DllImport("TestDLL01.dll", CallingConvention = CallingConvention.StdCall)]
public static extern void DisplayTestStruct03_ViaPointer([In] IntPtr ptest_struct_03);

static void InitializeStruct(ref TestStruct01 test_struct_01, string strInitial)
{
  test_struct_01.m_strString = strInitial;
}

static void InitializeStruct(ref TestStruct02 test_struct_02, string strInitial)
{
  test_struct_02.m_strString = strInitial;
}

static void InitializeStruct(ref TestStruct03 test_struct_03, string strInitial)
{
  test_struct_03.m_strString = strInitial;
}

delegate void Delegate_InitializeStruct(ref T t, string strInitial);

delegate void Delegate_DisplayTestStruct0x_ViaPointer(IntPtr ptest_struct_0x);

static void DisplayTestStruct0x_ViaPointer
    (
      Delegate_InitializeStruct pInitializer,
      Delegate_DisplayTestStruct0x_ViaPointer pDisplayFunction
    ) where T : new()
{
    // Create structure T and assign value to its field as usual.
    T test_struct_0x = new T();

    pInitializer(ref test_struct_0x, "Hello World");

    // Determine the size of the T structure for marshaling.
    int iSizeOfTestStruct0x = Marshal.SizeOf(typeof(T));
    // Allocate in unmanaged memory a block of memory the size
    // of an unmanaged T structure.
    IntPtr ptest_struct_0x = Marshal.AllocHGlobal(iSizeOfTestStruct0x);
    // Transfer the contents of the managed T structure
    // (i.e. test_struct_0x) to the unmanaged memory
    // which now serves as the unmanaged representation
    // of test_struct_0x.
    Marshal.StructureToPtr(test_struct_0x, ptest_struct_0x, false);
    // Call the API using a pointer to the unmanaged test_struct_0x.
    pDisplayFunction(ptest_struct_0x);
    // We must remember to destroy the test_struct_0x structure.
    // Doing this will free any fields which are references
    // to memory.
    Marshal.DestroyStructure(ptest_struct_0x, typeof(T));
    // Finally, the block of memory allocated for the
    // unmanaged test_struct_0x must itself be freed.
    Marshal.FreeHGlobal(ptest_struct_0x);
    ptest_struct_0x = IntPtr.Zero;
}

static void Main(string[] args)
{
  Delegate_InitializeStruct pInitializerFunction = InitializeStruct;
  Delegate_DisplayTestStruct0x_ViaPointer pDisplayFunction = DisplayTestStruct01_ViaPointer;

  DisplayTestStruct0x_ViaPointer(pInitializerFunction, pDisplayFunction);
}

The above code provides the following :

  • C# declarations for the DisplayTestStruct01_ViaPointer(), DisplayTestStruct02_ViaPointer() and DisplayTestStruct03_ViaPointer() APIs.
  • 3 overloaded initializer functions (InitializeStruct()), one each for the structs TestStruct01, TestStruct02 and TestStruct03.
  • Delegate Delegate_InitializeStruct<T> which is meant to generically point to one of the initializer functions.
  • Delegate_DisplayTestStruct0x_ViaPointer which is meant to point to one of the versions of the DisplayTestStructXX_ViaPointer APIs.
  • DisplayTestStruct0x_ViaPointer<T>() which generically performs the equivalent of the DisplayTestStruct01_ViaPointer() function (listed in point 7.5) but for all the test structs.
  • The main() function shows how DisplayTestStruct0x_ViaPointer<T>() may be called for TestStruct01. By simple substitutions, we can call DisplayTestStruct0x_ViaPointer<T>() for TestStruct02 and TestStruct03.

7.13 For more details on passing a pointer to a structure from managed to unmanaged code, please refer to :

Passing a Pointer to a Structure from C# to C++ Part 1.

Passing a Pointer to a Structure from C# to C++ Part 2.

Passing a Pointer to a Structure from C# to C++ Part 3.

8. In Conclusion.

8.1 In this part 1, we have explored how to express a string member of a managed struct in unmanaged code. We have passed such a structure as an “in” (by-value) parameter.

8.2 In part 2, we will look into how to pass such a structure as an “out” (return) parameter.

8.3 Proceed to Part 2.

8.4 Proceed to Part 3.

Advertisements

About Lim Bio Liong

I've been in software development for nearly 20 years specializing in C , COM and C#. It's truly an exicting time we live in, with so much resources at our disposal to gain and share knowledge. I hope my blog will serve a small part in this global knowledge sharing network. For many years now I've been deeply involved with C development work. However since circa 2010, my current work has required me to use more and more on C# with a particular focus on COM interop. I've also written several articles for CodeProject. However, in recent years I've concentrated my time more on helping others in the MSDN forums. Please feel free to leave a comment whenever you have any constructive criticism over any of my blog posts.

Discussion

4 thoughts on “Passing Managed Structures With Strings To Unmanaged Code Part 1

  1. This comment applies to the three articles in this series.

    Thank you so much for posting this information. I am currently engaged in a project that consists of taking an existing API written in C++ and putting a .NET wrapper around it. Since the development for the API was frozen a few years ago, this is the only option to bring the necessary functionality into .NET.

    I struggled for some time dealing with some of the API calls, especially ones that had In/Out arguments of unspecified type (*void specifically). In these cases, the argument was a pointer to any data type, as well as a number of structures. As you may surmise, for one not well versed in interop between managed and unmanaged code, getting a firm grasp on the problem, then finding well written examples of how to solve the problem have proven to be quite time consuming.

    The biggest problem I have seen with much of the advice I have found online regarding this topic, is that the examples shown rarely answer a real-world problem. I have a legacy API in unmanaged code. The API uses not only standard data types, but a number of structures, as well as buffers. How do I utilize this API in .NET?

    Fortunately, these articles have covered the interop topic with information that is easy to read, and examples that cover all of the work required to solve the problem. Aside from converting them into VB.NET (not terribly difficult), these examples cover just about all of the cases that I have encountered in completing this task.

    Once again, thank you for your efforts.

    Russ Kessing

    Posted by Russ Kessing | November 8, 2011, 4:13 pm

Trackbacks/Pingbacks

  1. Pingback: Passing Managed Structures With Strings To Unmanaged Code Part 2 « limbioliong - August 24, 2011

  2. Pingback: Passing Managed Structures With Strings To Unmanaged Code Part 3 « limbioliong - August 28, 2011

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: