Skip to content

Manual native memory extensions

Jump to bottom
David Hall edited this page Aug 8, 2022 · 1 revision

Including the namespace Vanara.Extensions provides access to many extensions to existing .NET classes and structures, including extensions for IntPtr. Here are some of the things you can do:

Reading memory

Extract a structure

The library can extract structures or classes that have an implied or expressed layout. This includes classes marked with the VanaraMarshalerAttribute.

// Extract a RECT (This is a copy and no longer points to the native memory)
IntPtr ptr = /* a pointer to native memory */;
CharSet charSet = CharSet.Unicode; /* Type of characters in the strings */
int offset = 0; /* number of bytes to offset the beginning of the enumeration */
int memSize = /* number of bytes allocated to ptr */;
RECT r = ptr.ToStructure<RECT>(memSize, offset);

// Get a reference to value types (This reference still points to the native memory)
ref RECT rr = ref ptr.AsRef<RECT>(offset, memSize);

Convert a pointer to an array of a type

This copies the contents of native memory to a managed array.

IntPtr ptr = /* a pointer to native memory */;
int elemCount = /* number of array elements */;
int offset = 0; /* number of bytes to offset the beginning of the enumeration */
int memSize = /* number of bytes allocated to ptr */;
ptr.ToArray<RECT>(elemCount, offset, memSize);

Convert a pointer to an IEnumerable sequence

You may also just need to enumerate over the memory. You can do this in two ways, with a direct iterator or with a Span. The only difference is that ToIEnum can also handle custom structure marshaling using IVanaraMarshaler.

// Use the iterator
IntPtr ptr = /* a pointer to native memory */;
int elemCount = /* number of array elements */;
int offset = 0; /* number of bytes to offset the beginning of the enumeration */
int memSize = /* number of bytes allocated to ptr */;
foreach (var rect in ptr.ToIEnum<RECT>(elemCount, offset, memSize))
{
   // iterate while ptr is still pointing to valid memory
}

// Use Span
foreach (var rect in ptr.AsSpan<RECT>(elemCount, offset, memSize))
{
   // iterate while ptr is still pointing to valid memory
}

Get a string array from memory

String arrays, natively, take two forms: 1) An array of pointers to string, and 2) An array of strings where each string is terminated with null and the array is terminated with an additional null.

// Array of string pointers
IntPtr ptr = /* a pointer to native memory */;
int elemCount = /* number of array elements */;
CharSet charSet = CharSet.Unicode; /* Type of characters in the strings */
int offset = 0; /* number of bytes to offset the beginning of the enumeration */
int memSize = /* number of bytes allocated to ptr */;
foreach (var rect in ptr.ToStringEnum(elemCount, charSet, offset, memSize))
{
   // iterate while ptr is still pointing to valid memory
}

// Array of zero terminated strings
foreach (var rect in ptr.ToStringEnum(charSet, offset, memSize))
{
   // iterate while ptr is still pointing to valid memory
}

Writing memory

To start, it is important to know that there are multiple allocation schemes in the Windows SDK. Two are supported in .NET: LocalAlloc (using Marshal.AllocHGlobal) and CoTaskMemAlloc (using Marshal.AllocCoTaskMem). Under the hood, since Win8, they both allocate memory from the process heap. Then you have all the heap functions from Kernel32 - HeapCreate/HeapAlloc and others. These are more complex and support locking. On top of these, you have the C/C++ functions too. To accommodate all these, in all the Vanara extensions, you must specify an allocator when creating native memory.

Copy a structure to newly allocated native memory

RECT r = new RECT(5, 5, 20, 20);
IntPtr ptr = r.MarshalToPtr(Marshal.AllocCoTaskMem, out int memSize, 0 /*prefixBytes*/, null /*lock method*/, null /*unlock method*/);
// use the ptr
Marshal.FreeCoTaskMem(ptr);

Copy a sequence (array or IEnumerable) of structures to newly allocated native memory

RECT[] r = new[] { new RECT(5, 5, 20, 20), new RECT(1, 1, 5, 5), new RECT(50, 50, 200, 200) };
IntPtr ptr = r.MarshalToPtr(Marshal.AllocHGlobal, out int memSize, 0 /*prefixBytes*/,
   null /*lock method*/, null /*unlock method*/);
// use the ptr
Marshal.FreeHGlobal(ptr);

Copy a sequence (array or IEnumerable) of strings to newly allocated native memory

string[] s = new[] { "ABCD", "EFGH", "IJKL" };
// **Note** the need to supply the packing method and character set
IntPtr ptr = s.MarshalToPtr(StringListPackMethod.Concatenated, Marshal.AllocHGlobal, out int memSize,
   CharSet.Unicode, 0 /*prefixBytes*/, null /*lock method*/, null /*unlock method*/);
// use the ptr
Marshal.FreeHGlobal(ptr);

Write objects to pre-allocated native memory

Matching all the allocating methods are write-only methods.

const int memSize = 1024;
IntPtr ptr = Marshal.AllocCoTaskMem(memSize);

RECT r = new RECT(5, 5, 20, 20);
ptr.Write(r, 0 /*offset*/, memSize);

RECT[] ra = new[] { new RECT(5, 5, 20, 20), new RECT(1, 1, 5, 5), new RECT(50, 50, 200, 200) };
ptr.Write(ra, 0 /*offset*/, memSize);

string[] s = new[] { "ABCD", "EFGH", "IJKL" };
// **Note** the need to supply the packing method and character set
ptr.Write(StringListPackMethod.Concatenated, CharSet.Ansi, 0 /*offset*/, memSize);
Clone this wiki locally