Work with PCZZWSTR

[sensslen]

I'm currently struggling on how to interact with PCZZWSTR. PCZZWSTR has a constructor that takes a char*. How can I convert one or more strings to this structure?

[AArnott]

The simplest way to demonstrate is this:

unsafe
{
    string message = "message1\0message2\0\0";
    fixed (char* pMessage = message)
    {
        PCZZWSTR wstr = new(pMessage);
    }
}

Note that this doesn't copy the memory, it merely points to it. So the wstr I initialize here is only valid while you're inside the fixed block.

If you want to use it longer term, you can allocate native memory:

using System;
using System.Diagnostics;
using System.Linq;
using System.Runtime.InteropServices;
using Windows.Win32.Foundation;

string[] strings = ["message1", "message2"];
PCZZWSTR list = CreateStringList(strings);
try
{
    // use it here.
}
finally
{
    FreeStringList(ref list);
}

// Allocates native memory and copies an array of strings into it.
static unsafe PCZZWSTR CreateStringList(string[] values)
{
    // The length of the buffer is the sum of the individual string lengths, plus their null terminators, plus one more null terminator.
    int charLength = values.Sum(v => v.Length + 1) + 1;
    int byteLength = charLength * sizeof(char);

    char* p = (char*)Marshal.AllocHGlobal(byteLength);
    Span<char> remainingSpan = new(p, charLength);

    foreach (string value in values)
    {
        value.AsSpan().CopyTo(remainingSpan);
        remainingSpan[value.Length] = '\0';
        remainingSpan = remainingSpan.Slice(value.Length + 1);
    }

    remainingSpan[0] = '\0';
    Debug.Assert(remainingSpan.Length == 1);
    return new PCZZWSTR(p);
}

static unsafe void FreeStringList(ref PCZZWSTR list)
{
    Marshal.FreeHGlobal((IntPtr)list.Value);
    list = default;
}

[sensslen]

Thanks a lot for the in detail explanation here.

Now I'm wondering if it may make sense to provide an additional layer of abstraction for methods that use PCZZWSTR to make it easier for c# devs not too familiar with marshalling to use these methods.

[AArnott]

It's complicated. Interop isn't easy, and while it's absolutely possible to build higher level abstractions around it to make it easier, it's very difficult or impossible to do so in a general manner from CsWin32 itself. The reasons include simply not knowing how long the pointer should last, as that depends on the API you're calling into.

Interop is hard, and CsWin32 makes it easier by taking on the requirement of declaring the APIs for you. But at least for the foreseeable future, it won't go much beyond that to make win32 functions fundamentally easier to call. And it will do little or no memory management on your behalf.