Simon Mourier's blog

IWebBrowser2::Quit Do not work on some explorer tabs

Thu, 02 Apr 2026 17:06:06 GMT

Well, I can reproduce "sometimes"... It's strange but here is a workaround that should work, it uses IWebBrowser2::HWND and PostMessage asking the owner window to close:

var staThread = new Thread(() =>
{
    var shellType = Type.GetTypeFromCLSID(new Guid("9BA05972-F6A8-11CF-A442-00A0C90A8F39"))!;
    dynamic shellWindows = Activator.CreateInstance(shellType!)!;

    // we need to loop here because some windows may not close immediately
    do
    {
        var toClose = new List<dynamic>();
        foreach (var window in shellWindows)
        {
            // add your logic here...
            toClose.Add(window);
        }
        if (toClose.Count == 0)
            break;

        foreach (var window in toClose)
        {
            nint hwnd;
            try
            {
                hwnd = (nint)window.HWND;
            }
            catch
            {
                continue;
            }

            const uint WM_CLOSE = 0x0010;
            PostMessage(hwnd, WM_CLOSE, 0, 0);
        }
    } while (true);
});

staThread.SetApartmentState(ApartmentState.STA);
staThread.Start();
staThread.Join();

[DllImport("user32")]
public static extern nint PostMessage(nint hWnd, uint Msg, nint wParam, nint lParam);

PS: your definition of IShellWindows is useless since you use dynamic (IDispatch undercovers).

What/How is `D3DKMT_BRIGHTNESS_INFO` used for?

Thu, 19 Mar 2026 14:37:20 GMT

These functions are for kernel mode. In user mode you can use GetMonitorBrightness but it will only work if your monitor supports it.

Providing stubs to a static library

Wed, 18 Mar 2026 17:29:51 GMT

In the end, you should always be able to provide ABI-compatible .obj files that you compiled yourself (not necessarily in assembler, C or "extern C" C++ for example)

How to check if Windows TPM is available and enabled using NCrypt API?

Wed, 18 Mar 2026 08:18:31 GMT

AI probably told you that crap :-) Here's the official way Tbsi_GetDeviceInfo There's also the simple function BOOL WINAPI Tbsi_Is_Tpm_Present() in the same tbs.h file, it's not visible in the doc but works.

Windows application packaging project for native AOT

Thu, 05 Mar 2026 09:06:25 GMT

Here's one solution (works for any .exe in fact), not sure it's officially sanctified though:

Once you have created your packaging project, instead of adding a reference, just change the .wapproj, add these properties (adapt to your context):

  <PropertyGroup>
    ...
    <AppxBundlePlatforms>x64</AppxBundlePlatforms>
    <EntryPointExe>MyApp.exe</EntryPointExe>
    ...
  </PropertyGroup>

  <ItemGroup>
    ...
    <Content Include="..\MyApp\bin\x64\Release\net10.0-windows10.0.22000.0\publish\MyApp.exe">
      <Link>MyApp.exe</Link>
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </Content>
    ...
  </ItemGroup>

Integrating Windows Explorer as a control in Windows 11

Tue, 03 Mar 2026 23:11:22 GMT

Yes, you can use INameSpaceTreeControl as shown here https://stackoverflow.com/a/48591421/403671

How to ask Windows if a printer spools or not (in either .NET or Win32)?

Thu, 26 Feb 2026 16:38:33 GMT

GetPrinter(...,2,...) should get you a PRINTER_INFO_2 that has an Attribute field that can contain PRINTER_ATTRIBUTE_DIRECT (=2) if job is sent directly to the printer, not spooled.

How do I get SCons to work on the Windows 10 command line?

Sat, 31 Jan 2026 12:08:19 GMT

FWIW, in case this can be useful to anyone, I had no scons.bat anywhere in the tons of my python directories (much could be said also about python install mess...) after having done all the usual python pip trials.

So what I did is create a scons.bat file manually in a folder that I know is in my PATH with simply this inside:

python -m SCons %*

Note SCons is here case-sensitive

How to prevent "appstarting" cursor when calling IContextMenu::QueryContextMenu?

Mon, 22 Dec 2025 16:17:29 GMT

This is not officially documented but you can implement the IWaitCursorManager interface, here is its definition (in C#):

[Guid("fc992f1f-debb-4596-b355-50c7a6dd1222")]
public interface IWaitCursorManager
{
    HRESULT Start(CURSORID id);
    HRESULT Restore();
    HRESULT Stop(CURSORID id);
}

public enum CURSORID
{
    CID_WAIT = 0,
    CID_APPSTARTING = 1,
}

To implement it you must pass a "site" to the IContextMenu implementation. For that just QueryInterface it for the IObjectWithSite interface, something like this (again in C#)

var ows = (IObjectWithSite)contextMenu;

and then pass a COM object of yours that must implement IServiceProvider:

var mySite = new MySite();
ows.SetSite(mySite);

Your COM object will be called on QueryService for a IWaitCursorManager's IID (among other IIDs). Pass an implementation of it that does nothing, like this:

public class MySite : IServiceProvider, IWaitCursorManager
{
    HRESULT QueryService(Guid siid,  Guid iid,  out object obj)
    {
       if (iid == typeof(IWaitCursorManager).Guid)
       {
          obj = this;
          return 0;
       }
          
       ...
    }

    HRESULT Start(CURSORID id)
    {
        return 0;
    }   
    
    HRESULT Restore()
    {
        return 0;
    }   

    HRESULT Stop(CURSORID id)
    {
        return 0;
    }   
}

Is it possible to connect the New Outlook for Windows to our own server?

Mon, 15 Dec 2025 17:11:04 GMT

Outlook for Windows is a pure web app, so you can't use COM addins, see here https://learn.microsoft.com/en-us/microsoft-365-apps/outlook/get-started/state-of-com-add-ins

The new Outlook for Windows doesn't support COM add-ins, but it does support Office web add-ins. To learn more about Office Add-ins, see Office Add-ins platform overview.

For guidance to migrate COM add-ins to web add-ins, see Migrate from COM to web add-ins.

What are the strengths and weaknesses of using VTable/COM-centric APIs?

Tue, 09 Dec 2025 15:16:36 GMT

This is why Microsoft has taken the COM approach more than 30 years ago and sticks with it (WinRT is COM) almost everywhere in Windows. At its root, COM is "just" a binary (not source code, this is fundamental) reusable contract, the vtable, plus the IUnknown interface. Then, on top of this you have many optional other services (factory, registration, automation, threading, etc.). Just using vtable + IUnknown is often called "Nano COM" today. Typically the DirectX devs (Direct3D, Direct2D, DirectWrite, DirectComposition, etc.) have chosen this path, they provide an initial factory (no CoCreateInstance/registry needed) and you can program the whole API using binary interfaces. If you can get a copy of "Essential COM" by Don Box, that may be of interest (especially the first pages that explain history, links with C++, etc.).

How to force the Application.Run to wait for all async void handlers?

Wed, 19 Nov 2025 07:29:10 GMT

Since what causes Application.Run to return is the main form closing, the most simple not hacky way to do it for me seems to prevent the form from closing (duh).

For example with something like this:

internal static class Program
{
    [STAThread]
    static void Main()
    {
        ApplicationConfiguration.Initialize();
        var completedOperations = 0;
        var form = new Form();

        form.FormClosing += EarlyClosingBlocker.HandleFormClosing;
        form.Load += (s, e) => _ = EarlyClosingBlocker.Run(async () =>
        {
            await Task.Delay(1000);
            completedOperations++;
        });

        form.Shown += (s, e) => _ = EarlyClosingBlocker.Run(async () =>
        {
            await Task.Delay(2000);
            completedOperations++;
        });

        Application.Run(form);
        MessageBox.Show($"Completed operations: {completedOperations}");
    }
}

public static class EarlyClosingBlocker
{
    private static readonly ConcurrentDictionary<AutoResetEvent, object?> _waitEvents = new();

    public static async Task Run(Func<Task> action)
    {
        var are = new AutoResetEvent(false);
        _waitEvents[are] = null;
        try
        {
            await action();
        }
        finally
        {
            are.Set();
            _waitEvents.TryRemove(are, out _);
        }
    }

    public static void HandleFormClosing(object? sender, FormClosingEventArgs e)
    {
        var events = _waitEvents.ToArray();
        if (events.Length == 0)
            return;

        // note we could use e.CloseReason to decide not to wait whatsoever
        e.Cancel = true;
        var form = (Form)sender!;
        form.Hide(); // or put a message, etc.
        _ = Task.Run(() =>
        {
            // wait for all events to finish, note this cannot run in an STA thread
            WaitHandle.WaitAll([.. events.Select(e => e.Key)]);
            form.BeginInvoke(form.Close);
        });
    }
}

Flickering when drawing to IDCompositionSurface

Tue, 18 Nov 2025 07:37:32 GMT

If you want to use Direct2D with Direct Composition, you want to use IDCompositionSurface::BeginDraw asking for a D2D device context. Note for that you must create the Direct Composition device using a D2D device.

This code should work better:

int main()
{
    constexpr const wchar_t* WINDOW_CLASS_NAME = _T("a");
    constexpr const wchar_t* WINDOW_TITLE_NAME = _T("a");

    HRESULT hr = S_OK;

    CComPtr<ID3D11Device> d3dDevice;
    hr = D3D11CreateDevice(
        nullptr, D3D_DRIVER_TYPE_HARDWARE, nullptr,
        D3D11_CREATE_DEVICE_SINGLETHREADED | D3D11_CREATE_DEVICE_BGRA_SUPPORT | D3D11_CREATE_DEVICE_DEBUG,
        nullptr, 0, D3D11_SDK_VERSION, &d3dDevice, nullptr, nullptr
    );
    CComPtr<IDXGIDevice> dxgiDevice;
    hr = d3dDevice->QueryInterface(IID_PPV_ARGS(&dxgiDevice));

    CComPtr<ID2D1Device> d2dDevice;
    D2D1_CREATION_PROPERTIES creationProc = {};
    creationProc.debugLevel = D2D1_DEBUG_LEVEL_INFORMATION;
    hr = D2D1CreateDevice(dxgiDevice, creationProc, &d2dDevice);

    // *use D2D device to create DComp device*
    CComPtr<IDCompositionDesktopDevice> dcDesktopDevice;
    hr = DCompositionCreateDevice3(d2dDevice, IID_PPV_ARGS(&dcDesktopDevice));

    WNDCLASSEX wndClass = { 0 };
    wndClass.cbSize = sizeof(WNDCLASSEX);
    wndClass.style = CS_NOCLOSE | CS_VREDRAW | CS_HREDRAW;
    wndClass.lpfnWndProc = DefWindowProc;
    wndClass.hInstance = GetModuleHandle(NULL);
    wndClass.lpszClassName = WINDOW_CLASS_NAME;
    hr = RegisterClassEx(&wndClass) ? S_OK : E_FAIL;

    HWND hwnd;
    hwnd = CreateWindowEx(
        WS_EX_OVERLAPPEDWINDOW | WS_EX_TRANSPARENT | WS_EX_NOREDIRECTIONBITMAP,
        WINDOW_CLASS_NAME, WINDOW_TITLE_NAME,
        WS_POPUP | WS_VISIBLE,
        1100, 980, 800, 80,
        nullptr, nullptr, GetModuleHandle(nullptr), nullptr
    ); hr = hwnd ? S_OK : E_FAIL;
    SetWindowPos(hwnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);

    CComPtr<IDCompositionTarget> dcTarget;
    hr = dcDesktopDevice->CreateTargetForHwnd(hwnd, FALSE, &dcTarget);

    CComPtr<IDCompositionVisual2> dcVisual;
    hr = dcDesktopDevice->CreateVisual(&dcVisual);
    dcTarget->SetRoot(dcVisual);

    CComPtr<IDCompositionSurface> surface;
    hr = dcDesktopDevice->CreateSurface(
        800, 80,
        DXGI_FORMAT_B8G8R8A8_UNORM,
        DXGI_ALPHA_MODE_PREMULTIPLIED,
        &surface
    );
    hr = dcVisual->SetContent(surface);

    while (true)
    {
        POINT drawOffset = { 0,0 };
        CComPtr<ID2D1DeviceContext> d2dContext;
        hr = surface->BeginDraw(nullptr, IID_PPV_ARGS(&d2dContext), &drawOffset);

        d2dContext->Clear();

        // you *MUST* use the drawoffset you get back 
        d2dContext->SetTransform(D2D1::Matrix3x2F::Translation((FLOAT)drawOffset.x, (FLOAT)drawOffset.y));

        CComPtr<ID2D1SolidColorBrush> brush;
        hr = d2dContext->CreateSolidColorBrush(D2D1::ColorF(D2D1::ColorF::Red), &brush);
        d2dContext->FillRoundedRectangle(D2D1_ROUNDED_RECT{ D2D1::RectF(10,10,200,50), 10, 10 }, brush);

        hr = surface->EndDraw();
        hr = dcDesktopDevice->Commit();
        hr = dcDesktopDevice->WaitForCommitCompletion(); // optional
        Sleep(50); // this and the loop is optional see remarks
    }
}

Note you don't need to call Sleep and do it again as with Direct Composition, you compose your scene usually once (unless you want to animate it of course), you don't need to refresh it again at each vblank.

Also, it's much better to use Windows Visual Layer wich is simply the evolution of Direct Composition. It's not at all restricted to UWP, but it does require using WinRT API. There's an official example here https://github.com/microsoft/Windows.UI.Composition-Win32-Samples/tree/master/cpp/HelloComposition and a less bloated one here https://gist.github.com/kennykerr/62923cdacaba28fedc4f3dab6e0c12ec

With the Visual Layer the idea is roughly the same you can use a SpriteVisual and from that SpriteVisual you can get a D2D context to write https://learn.microsoft.com/en-us/windows/uwp/composition/composition-native-interop

CsWin32 how to create an instance of PWSTR for e.g. GetWindowText

Tue, 04 Nov 2025 21:58:28 GMT

With the latest version of CsWin32, currently 0.3.242, this is much more simple and natural than it used to be:

NativeMethods.txt:

GetWindowTextW
GetWindowTextLengthW

Program.cs:

...
var len = PInvoke.GetWindowTextLength(hwnd);
Span<char> chars = new char[len + 1];
PInvoke.GetWindowText(hwnd, chars);
var text = chars.ToString();
...

COM CCertRequest via CSWin32

Tue, 04 Nov 2025 08:56:14 GMT

It should work, but it depends on your configuration. Also note CsWin32 has been greatly improved lately and you want to use the CsWin32RunAsBuildTask directive, so here's an example that works:

csproj: `

<PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net9.0</TargetFramework>
    <Nullable>enable</Nullable>
    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
    <CsWin32RunAsBuildTask>true</CsWin32RunAsBuildTask>
    <DisableRuntimeMarshalling>true</DisableRuntimeMarshalling>
    <InvariantGlobalization>true</InvariantGlobalization>
</PropertyGroup>

<ItemGroup>
    <PackageReference Include="Microsoft.Windows.CsWin32" Version="0.3.242">
        <PrivateAssets>all</PrivateAssets>
        <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
    </PackageReference>
</ItemGroup>

NativeMethods.txt:

ICertAdmin
CCertRequest
ICertRequest
ICertRequest2
ICertRequest3

Program.cs:

using System;
using System.Runtime.Versioning;
using Windows.Win32.Security.Cryptography.Certificates;

[assembly: SupportedOSPlatform("windows5.1.2600")]

namespace Test;

internal class Program
{
    static void Main()
    {
        var instance = CCertRequest.CreateInstance<ICertRequest>();
        Console.WriteLine(instance);
    }
}

How to get the HWND handle of elements in .Net MAUI

Tue, 23 Sep 2025 20:00:57 GMT

WinUI3 is the technology used by MAUI on Windows, and you can refer to Windowing overview for WinUI and Windows App SDK to understand the link between a WinUI3 Window to a Win32 HWND.

Then, you can use Platform lifecycle events to get it, something like this:

using Microsoft.Maui.LifecycleEvents;

namespace MauiApp1
{
    public static class MauiProgram
    {
        public static MauiApp CreateMauiApp()
        {
            var builder = MauiApp.CreateBuilder();
            builder
                .UseMauiApp<App>()
                .ConfigureLifecycleEvents(events =>
                {
#if WINDOWS
                    events.AddWindows(bld =>
                    {
                        // window here is of Microsoft.UI.Xaml.Window type (WinUI3)
                        bld.OnWindowCreated(window =>
                        {
                            var hwnd = Microsoft.UI.Win32Interop.GetWindowFromWindowId(window.AppWindow.Id);
                        });
                    });
#endif
                });

            return builder.Build();
        }
    }
}

WinUI 3 DataTemplateSelector always crashed when using AOT

Wed, 17 Sep 2025 16:41:39 GMT

Your project doesn't even work w/o AOT publishing, it raises an InvalidCastException error:

The problem comes from the fact you want to expose a "pure" managed object (of type ADataTemplateSelector) to the underlying WinUI3 (native) layers but there's not enough information for C#/WinRT to project this type back. Invalid cast here means: this type doesn't implement what's needed to participate to the XAML/WinUI3 party.

If you work with Visual Studio and take a closer look over this managed class, you will see this:

Class ... implements WinRT interface but it ... isn't marked partial.

The warning tells you to add a partial keyword to the class to allow C#/WinRT to generate necessary information for this type to be recognised as a valid WinUI3 framework type:

public partial class ADataTemplateSelector : DataTemplateSelector
{
    ...
}

Once you've done that the warning should go and the project should run and work when published as AOT.

PS: there are other warnings in this code. In general and especially with AOT publishing you really want to make sure there are none left, even when it seems to work:

How to get the value of a runtime property back into a design time property?

Wed, 10 Sep 2025 18:55:12 GMT

Assuming you know how to dynamically add a TypeConverter to a property, as seen in How to get a runtime list into a PropertyGrid?, you need to build a a converter with properties that remember the initial instance that's being worked on.

Here is some sample code you can test like this:

public class A
{
    [TypeConverter(typeof(FullNameConverter))] // for quick demo purpose
    public string FullName { get; set; } = "John Doe";
}

// a class that knows how to parse and format a full name
public class FullName
{
    public string Forename { get; set; }
    public string LastName { get; set; }

    public override string ToString() => $"{Forename} {LastName}";

    public static FullName Parse(string? fullName)
    {
        if (string.IsNullOrWhiteSpace(fullName))
            return new FullName();

        var split = fullName.Split(' ');
        return new FullName { Forename = split[0], LastName = split[1] };
    }
}

// A <=> FullName property descriptors (they remember the A instance)
public class FullNamePropertyDescriptor : PropertyDescriptor
{
    // we use initial value to be able to reset (feature sometimes used by property grids)
    public FullNamePropertyDescriptor(A instance, object initialValue, string name, Type propertyType, Attribute[]? attrs)
        : base(name, attrs)
    {
        Instance = instance;
        PropertyType = propertyType;
        InitialValue = GetValue(initialValue);
    }

    public A Instance { get; }
    public object? InitialValue { get; }

    public override Type ComponentType => Instance.GetType();
    // honor ReadOnly attributes on FullName properties
    public override bool IsReadOnly => Attributes.OfType<ReadOnlyAttribute>().FirstOrDefault()?.IsReadOnly ?? false;
    public override Type PropertyType { get; }
    public override bool CanResetValue(object component) => true;
    public override bool ShouldSerializeValue(object component) => false;
    public override void ResetValue(object component) => SetValue(component, InitialValue);

    // component is a string here
    public override object? GetValue(object? component)
    {
        var fn = FullName.Parse(component as string);

        // defer to FullName properties
        return TypeDescriptor.GetProperties(typeof(FullName))[Name].GetValue(fn);
    }

    // component is a string here
    public override void SetValue(object? component, object? value)
    {
        var fn = FullName.Parse(component as string);

        // defer to FullName properties
        TypeDescriptor.GetProperties(typeof(FullName))[Name].SetValue(fn, value);

        // update original object
        Instance.FullName = fn.ToString();
    }
}

// the A <=> FullName type converter
public class FullNameConverter : TypeConverter
{
    public override bool GetPropertiesSupported(ITypeDescriptorContext? context) => true;
    public override PropertyDescriptorCollection? GetProperties(ITypeDescriptorContext? context, object value, Attribute[]? attributes)
        => new([.. TypeDescriptor.GetProperties(typeof(FullName))
            .OfType<PropertyDescriptor>()
            .Select(pd => new FullNamePropertyDescriptor(
                (A)context.Instance,
                value,
                pd.Name,
                pd.PropertyType,
                pd.Attributes.Cast<Attribute>().ToArray()))]
            );

    // we can convert to and from string (the underlying type)
    public override bool CanConvertTo(ITypeDescriptorContext? context, [NotNullWhen(true)] Type? destinationType) => typeof(string) == destinationType || base.CanConvertTo(context, destinationType);
    public override bool CanConvertFrom(ITypeDescriptorContext? context, Type sourceType) => typeof(string) == sourceType || base.CanConvertFrom(context, sourceType);
    public override object? ConvertFrom(ITypeDescriptorContext? context, CultureInfo? culture, object value) => value;
    public override object? ConvertTo(ITypeDescriptorContext? context, CultureInfo? culture, object? value, Type destinationType) => value;
}

Here's the result:

Managed exceptions in MAUI Windows app logged as CoreMessagingXP.dll crashes

Tue, 09 Sep 2025 08:13:45 GMT

MAUI on Windows is implemented using WinUI3. WinUI3 itself is a native framework that has bindings/projections for .NET (but also C++), etc.

Anyway in Windows, unless something catches it, a crash will end up in the Event Log. This is the case by default with WinUI3 and MAUI over it, and that's what you see (note that with proper setup and symbols, a developer can investigate that kind of raw reports).

Here is how you can catch it (I've use the System.Diagnostics.EventLog package but you can use any logging facility):

Change Platforms\Windows\App.xaml.cs like this:

public partial class App : MauiWinUIApplication
{
    public App()
    {
        // we handle only our specific exception type in case of
        // unobserved exceptions, best effort for bad coding practises :-)
        AppDomain.CurrentDomain.FirstChanceException +=
            (sender, e) => HandleException(e.Exception as MyException);

        UnhandledException += (sender, e) =>
        {
            // prevent the app from crashing & exit gracefully
            e.Handled = true;
            HandleException(e.Exception);
        };

        InitializeComponent();
    }

    private void HandleException(Exception? ex)
    {
        if (ex == null) return;

        // pick a source that exists like "Application" or create a new one (requires admin rights)
        // here we use ".NET Runtime"
        // see why here https://www.jitbit.com/alexblog/266-writing-to-an-event-log-from-net-without-the-description-for-event-id-nonsense/
        System.Diagnostics.EventLog.WriteEntry(
            ".NET Runtime",
            $"Unhandled exception: {ex.Message}",
            System.Diagnostics.EventLogEntryType.Error,
            1000);

        Exit();
    }

    protected override MauiApp CreateMauiApp() => MauiProgram.CreateMauiApp();
}

This is the result in Event Viewer:

Now, why the first line? Because your reproducing code does this:

private async void OnLanguageClicked(object? sender, EventArgs e)
{
    throw new Exception("Simulated exception in OnLanguageClicked");
}

Note with Visual Studio the green swiggles:

What it means is the implicit task you're starting with the async keyword is unobserved. It's generally bad practise, and in this case it crashes the native layers underneath (which could handle this in a better way we agree on that...) so you get a real native handled error that you can see in the event viewer.

In this case there are two ways of dealing with this kind of errors:

A: use a custom exception type for all your errors and you can catch it in FirstChanceException handler (there are many other 1st chance exceptions that we don't care about that's why you need a custom one), so for example this would be caught by our handlers:

private async void OnCounterClicked(object? sender, EventArgs e)
{
    throw new MyException("hello from main page");
}

public class MyException : Exception
{
    public MyException(string message) : base(message) { }
}

B: (preferred as it works for types of exceptions), just make sure you don't use this type of void async bad practise code and use this pattern instead:

private void OnCounterClicked(object? sender, EventArgs e)
{
    _ = DoSomethingThatThrows();
}

Task DoSomethingThatThrows()
{
    throw new Exception("hello from main page");
}

How to get a runtime list into a PropertyGrid?

Wed, 03 Sep 2025 17:18:33 GMT

You can override type descriptions before using types with the TypeDescriptor class, passing it a custom type descriptor.

It's a bit convoluted and you want to make sure you scan types and properties before you configure type descriptor or you may run into stack overflow. (TypeDescriptor.GetProperties has a noCustomTypeDesc parameter but it seems ineffective with my .NET 9 tests...)

Here is a sample TypeDescriptionProvider that should do what you need from assembly B (.NET Core code):

Data obj = new Data();

// configure a custom type descriptor for the Data type
var td = new DataDescriptor();
TypeDescriptor.AddProvider(new DescriptionProvider(td), typeof(Data));

propertyGrid1.SelectedObject = obj;

Sample classes:

public class DescriptionProvider(ICustomTypeDescriptor descriptor) : TypeDescriptionProvider
{
    public override ICustomTypeDescriptor? GetTypeDescriptor([DynamicallyAccessedMembers((DynamicallyAccessedMemberTypes)(-1))] Type objectType, object? instance)
        => descriptor;
}

public class DataDescriptor : CustomTypeDescriptor
{
    public DataDescriptor()
    {
        var properties = TypeDescriptor.GetProperties(typeof(Data));
        var list = new List<PropertyDescriptor>();
        foreach (PropertyDescriptor property in properties)
        {
            if (property.Name == "Text")
            {
                list.Add(TypeDescriptor.CreateProperty(typeof(Data), property, new TypeConverterAttribute(typeof(CustomConverter))));
            }
            else
            {
                list.Add(property);
            }
        }
        _properties = new PropertyDescriptorCollection([.. list]);
    }

    private PropertyDescriptorCollection _properties;
    public override PropertyDescriptorCollection GetProperties(Attribute[]? attributes) => _properties;
}

public class CustomConverter : TypeConverter
{
    public override bool GetStandardValuesSupported(ITypeDescriptorContext? context) 
        => true;
    public override StandardValuesCollection? GetStandardValues(ITypeDescriptorContext? context)
        => new(new List<string> { "hello", "world" });
}