Simon Mourier's blog

How to do background scheduling (like Hangfire/Quartz) in a packaged WinUI 3 app that still passes the Store WACK?

Fri, 10 Jul 2026 14:19:37 GMT

As stated in Windows App SDK app lifecycle

Windows App SDK apps, like UWP apps, are started and stopped. They are either running or not running. [...] unlike UWP apps, they cannot be suspended and resumed

So if you run your background work in-process, you're fine, depending on what you really need, even a PeriodicTimer is ok.

If you must run out-of-process, the easiest is probably to write another .exe doing your cron work, add it to the package, and declare it as a Startup Task for example:

<Package
  xmlns:desktop="http://schemas.microsoft.com/appx/manifest/desktop/windows10"
  IgnorableNamespaces="desktop">
  <Applications>
    <Application>
      <Extensions>
        <desktop:Extension
          Category="windows.startupTask"
          Executable="bin\MyStartupTask.exe"
          EntryPoint="Windows.FullTrustApplication">
        <desktop:StartupTask
          TaskId="MyStartupTask"
          Enabled="false"
          DisplayName="My App Service" />
        </desktop:Extension>
      </Extensions>
    </Application>
  </Applications>
 </Package>

See here to programmatically enable or disable your startup task: StartupTask example

As for local database storage, as long as you store it in the official package-relative ApplicationData.Current.LocalFolder, it should be accessible by both applications.

Flickering when drawing to Windows.Forms with Direct2

Tue, 07 Jul 2026 17:03:07 GMT

What happens is Winforms is based on Win32's GDI which draws the background first (using default window color) when painting and you then call Clear(...) with some other color.

There are at least two solutions to this (you can use both without harm):

add this to your constructor (the control is drawn opaque and the background is not painted):
```
 SetStyle(ControlStyles.Opaque,true);
```

override OnPaintBackground and do nothing in it

 protected override void OnPaintBackground(PaintEventArgs e)
 {
     // do nothing
 }

PS: that should be a full question, not an advice

NtQuerySystemInformation returns zero ImageBase on Windows 11 25H2 — how to get kernel base without admin?

Wed, 03 Jun 2026 07:33:09 GMT

It's documented here for EnumDeviceDrivers function

Starting in Windows 11 Version 24H2, EnumDeviceDrivers will require SeDebugPrivilege to return valid ImageBase values. The function will still succeed if the caller does not have this privilege enabled, but the returned lpImageBase array will contain addresses that are all NULL.

It sems logical and security consistent it's been extended to all (kernel) functions returning ImageBase values.

What Windows API should I use to create a blurred window?

Tue, 05 May 2026 21:26:45 GMT

Layered Windows are an old thing. Technically on modern Windows, transparency like that is indeed achieved using the "Visual layer", aka "Direct Composition", the closest thing to the Desktop Windows Manager (the OS compositor).

This is a Windows' WinRT API so you can use it from any language with WinRT binding (Microsoft provides .NET and C++). This API is located in the Windows.UI.Composition WinRT namespace ("WUC").

The WinAppSDK with WinUI3 provides another implementation of a Direct Composition client in the Microsoft.UI.Composition ("MUC") namespace partially decoupled from Windows, this is today what Microsoft promote for what you want to do (again usable in .NET or C++).

This sample here https://github.com/aelyo-softworks/Wice demonstrates using WUC w/o any framework (it's C# but only using Win32/WinRT interop over WUC)

Note another solution for what you want to do is to host a WebView2 (you can host it using Direct Composition instead of the traditional HWND way) with transparency enabled and let the WebView use its CSS (this project does that again using C# but using 100% native API). This other sample demonstrates that https://github.com/smourier/ShellBat ("Acrylic Almond theme shows a 100% transparent WebView2), cf CoreWebView2Controller.DefaultBackgroundColor Property

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();
        }
    }
}