Need an easier way to work with PWSTR

[catmanjan]

As far as I can tell this repo is full of issues with the use of PWSTR in this library - there needs to be an easier way to get a string to a PWSTR* or some doco on how to do so...

In particular I am using IExplorerCommand which has functions like

        unsafe void IExplorerCommand.GetTitle(IShellItemArray psiItemArray, PWSTR* ppszName)

I can't work out the proper way to set the property, the solutions I've found online all have issues

[mjr4077au]

There will be a friendlier overload in he Windows.Win32 namespace that will have a signature of unsafe void IExplorerCommand.GetTitle(IShellItemArray psiItemArray, out PWSTR ppszName). You can then use the .ToString() method to get the string. The PWSTR can be null though, in which case you'll have a null string, even if it stores into a string type regardless of whether you've made it nullable (see #1418 for more info on that).

Please note that you'll likely have to free memory yourself on this PWSTR, likely using Marshal.FreeCoTaskMem(). Please ensure you read the documentation on the IExplorerCommand type properly.

[catmanjan]

How do I find that friendlier overload? In this scenario I am implementing IExplorerCommand (see code below)

I can see 3 partial IExplorerCommand interfaces but 2 are empty

    [GeneratedComClass, ComVisible(true), Guid("1F080472-F173-4D9D-8BE7-435776617348")]
    public partial class CommandHandler : IExplorerCommand
    {
        unsafe void IExplorerCommand.GetTitle(IShellItemArray psiItemArray, PWSTR* ppszName)
        {
            unsafe
            {
                string message = "Hello World";
                fixed (char* pMessage = message)
                {
                    PWSTR pcwstr = new PWSTR(pMessage);
                    ppszName = &pcwstr;
                }
            }
        }

        unsafe void IExplorerCommand.GetIcon(IShellItemArray psiItemArray, PWSTR* ppszIcon)
        {
            throw new NotImplementedException();
        }

        unsafe void IExplorerCommand.GetToolTip(IShellItemArray psiItemArray, PWSTR* ppszInfotip)
        {
            throw new NotImplementedException();
        }

        public unsafe void GetCanonicalName(Guid* pguidCommandName)
        {
            throw new NotImplementedException();
        }

        void IExplorerCommand.GetState(IShellItemArray psiItemArray, BOOL fOkToBeSlow, out _EXPCMDSTATE pCmdState)
        {
            throw new NotImplementedException();
        }

        void IExplorerCommand.Invoke(IShellItemArray psiItemArray, Windows.Win32.System.Com.IBindCtx pbc)
        {
            throw new NotImplementedException();
        }

        void IExplorerCommand.GetFlags(out _EXPCMDFLAGS pFlags)
        {
            throw new NotImplementedException();
        }

        void IExplorerCommand.EnumSubCommands(out IEnumExplorerCommand ppEnum)
        {
            throw new NotImplementedException();
        }
    }

[mjr4077au]

Generally I just leverage Intellisense and start typing the type, it'll then autofill with an extension class like UI_Shell_IExplorerCommand_Extensions. Its contents are below. The first overload is what you want.

using global::System;
using global::System.Diagnostics;
using global::System.Diagnostics.CodeAnalysis;
using global::System.Runtime.CompilerServices;
using global::System.Runtime.InteropServices;
using winmdroot = global::Windows.Win32;
namespace Windows.Win32
{
	[global::System.CodeDom.Compiler.GeneratedCode("Microsoft.Windows.CsWin32", "0.3.269+368685089b.RR")]
	internal static partial class UI_Shell_IExplorerCommand_Extensions
	{
		/// <inheritdoc cref="winmdroot.UI.Shell.IExplorerCommand.GetTitle(winmdroot.UI.Shell.IShellItemArray, winmdroot.Foundation.PWSTR*)"/>
		internal static unsafe void GetTitle(this winmdroot.UI.Shell.IExplorerCommand @this, winmdroot.UI.Shell.IShellItemArray psiItemArray, out winmdroot.Foundation.PWSTR ppszName)
		{
			fixed (winmdroot.Foundation.PWSTR* ppszNameLocal = &ppszName)
			{
				@this.GetTitle(psiItemArray, ppszNameLocal);
			}
		}

		/// <inheritdoc cref="winmdroot.UI.Shell.IExplorerCommand.GetIcon(winmdroot.UI.Shell.IShellItemArray, winmdroot.Foundation.PWSTR*)"/>
		internal static unsafe void GetIcon(this winmdroot.UI.Shell.IExplorerCommand @this, winmdroot.UI.Shell.IShellItemArray psiItemArray, out winmdroot.Foundation.PWSTR ppszIcon)
		{
			fixed (winmdroot.Foundation.PWSTR* ppszIconLocal = &ppszIcon)
			{
				@this.GetIcon(psiItemArray, ppszIconLocal);
			}
		}

		/// <inheritdoc cref="winmdroot.UI.Shell.IExplorerCommand.GetToolTip(winmdroot.UI.Shell.IShellItemArray, winmdroot.Foundation.PWSTR*)"/>
		internal static unsafe void GetToolTip(this winmdroot.UI.Shell.IExplorerCommand @this, winmdroot.UI.Shell.IShellItemArray psiItemArray, out winmdroot.Foundation.PWSTR ppszInfotip)
		{
			fixed (winmdroot.Foundation.PWSTR* ppszInfotipLocal = &ppszInfotip)
			{
				@this.GetToolTip(psiItemArray, ppszInfotipLocal);
			}
		}

		/// <inheritdoc cref="winmdroot.UI.Shell.IExplorerCommand.GetCanonicalName(global::System.Guid*)"/>
		internal static unsafe void GetCanonicalName(this winmdroot.UI.Shell.IExplorerCommand @this, out global::System.Guid pguidCommandName)
		{
			fixed (global::System.Guid* pguidCommandNameLocal = &pguidCommandName)
			{
				@this.GetCanonicalName(pguidCommandNameLocal);
			}
		}
	}
}

[catmanjan]

Hmm, my issue is that I am implementing my own class for COM interop purposes so I need to implement the interface, not extend a class

[mjr4077au]

Remember though, you will still have to free the memory returned to you in the PWSTR value. I generally do this, extend the extension method with my own SafeHandle:

namespace ProjectName.Interop.Extensions
{
    internal static class IPersistFileExtensions
    {
        internal static void GetCurFile(this IPersistFile @this, out SafeCoTaskMemHandle? ppszFileName)
        {
            @this.GetCurFile(out PWSTR ppszFileNameLocal);
            ppszFileName = !ppszFileNameLocal.IsNull()
                ? new(ppszFileNameLocal, true)
                : null;
        }
    }
}

This will release the memory automatically when the item goes out of scope.

If you're wanting something truly managed for you with marshalled strings, etc, then you're probably better off looking at Vanara.

[catmanjan]

Yes we are currently using Vanara, but need to swap back to cswin32 for nativeaot support

[mjr4077au]

Hmm, my issue is that I am implementing my own class for COM interop purposes so I need to implement the interface, not extend a class

If your method's prototype is unsafe void IExplorerCommand.GetTitle(IShellItemArray psiItemArray, PWSTR* ppszName), then why not just do:

PWSTR ppszNameLocal = new();
iExCmdObj.GetTitle(someArray, &ppszNameLocal);

[mjr4077au]

Yes we are currently using Vanara, but need to swap back to cswin32 for nativeaot support

Using CsWin32 requires a decent understanding of how Win32 works. I've had to learn a lot myself when I started leveraging it.

[catmanjan]

@mjr4077au I think the confusion here is that we are not consuming the IExplorerCommand, we have our own explorer command which implements IExplorerCommand - currently Vanara makes it very easy to do this because it handles the transition from managed types to unmanaged types

[mjr4077au]

Sure, but because your CommandHandler implements IExplorerCommand, any extension method available to IExplorerCommand should accept your CommandHandler object as it implements that interface (i.e. call UI_Shell_IExplorerCommand_Extensions.GetTitle(commandHandlerObj, out PWSTR ppszName) directly).

[catmanjan]

We aren't the caller, we implement IExplorerCommand and register our dll so windows explorer (explorer.exe) can call GetTitle, etc

[mjr4077au]

I'd probably have to see your old code to see how I'd port it over. I'll be honest also, I've not made a shell extension like this either. I just know how to generically work with a COM interface out of CsWin32. This project's been very quiet for months so I figured I'd try to help where I could.

[catmanjan]

Here is the Vanara equivalent:

using System.Runtime.InteropServices;
using System.Runtime.InteropServices.ComTypes;
using Vanara.InteropServices;
using Vanara.PInvoke;
using Windows.System;
using static Vanara.PInvoke.Shell32;

namespace MyCommandHandler
{
    [ComVisible(true), Guid("DF080472-F173-4D9D-8BE7-435776617348")]
    public class CommandHandler : IExplorerCommand
    {
        public HRESULT GetTitle(IShellItemArray psiItemArray, out string? ppszName)
        {
            ppszName = "Hello World";

            return HRESULT.S_OK;
        }

        public HRESULT GetIcon(IShellItemArray psiItemArray, out string? ppszIcon)
        {
            return HRESULT.S_OK;
        }

        public HRESULT GetToolTip(IShellItemArray psiItemArray, out string? ppszInfotip)
        {
            return HRESULT.S_OK;
        }

        public HRESULT GetCanonicalName(out Guid pguidCommandName)
        {
            return HRESULT.S_OK;
        }

        public HRESULT GetState(IShellItemArray psiItemArray, bool fOkToBeSlow, out EXPCMDSTATE pCmdState)
        {
            return HRESULT.S_OK;
        }

        public HRESULT Invoke(IShellItemArray psiItemArray, IBindCtx? pbc)
        {
            return HRESULT.S_OK;
        }

        public HRESULT GetFlags(out EXPCMDFLAGS pFlags)
        {
            return HRESULT.S_OK;
        }

        public HRESULT EnumSubCommands(out IEnumExplorerCommand? ppEnum)
        {
            return HRESULT.S_OK;
        }
    }
}

[mjr4077au]

I just focused on the GetTitle() method, but you should be doing something like:

[ComVisible(true), Guid("DF080472-F173-4D9D-8BE7-435776617348")]
internal class CommandHandler : IExplorerCommand
{
    public void GetTitle(IShellItemArray psiItemArray, PWSTR* ppszName)
    {
        string title = "Hello World";
        IntPtr titlePtr = Marshal.StringToCoTaskMemUni(title);
        unsafe
        {
            *ppszName = new(titlePtr);
        }
    }
}

The caller (Explorer) will release the memory, I suppose.

[jevansaks]

Thanks @mjr4077au for jumping on this one! Yes, when implementing COM interfaces you are much more exposed to the implementation details of Win32.

CsWin32 is more "bare metal" than alternatives, but that's because we are focusing on enabling the binding as closely as possible with minimal overhead.

Also built-in COM marshalling in .NET has more features than source-generated COM (the one that supports native AOT) so things like this sometimes are worse because of those limitations.