Using NotifyIcon in WinUI 3

private sealed class NativeWindow
{
    // Unique window identifier based on the NotifyIcon's ID
    private readonly string windowId;

    // Reference to the NotifyIcon instance that manages the tray icon
    private NotifyIcon owner;

    // Delegate for handling window messages
    private WNDPROC proc;

    // Constructor: creates an invisible window for message handling
    public unsafe NativeWindow(NotifyIcon owner)
    {
        // Ensure the provided owner is not null
        ArgumentNullException.ThrowIfNull(owner);

        // Store the reference to the owner (NotifyIcon)
        this.owner = owner;

        // Generate a unique window identifier
        windowId = $"class:{owner.Id}";

        // Set OnWindowMessageReceived as the message handler
        proc = OnWindowMessageReceived;

        // Pin the windowId string in memory for passing to Win32 API
        fixed (char* className = windowId)
        {
            // Create a WNDCLASSW structure to register the window class
            var classInfo = new WNDCLASSW()
            {
                lpfnWndProc = proc, // Specify the message handler
                lpszClassName = new PCWSTR(className), // Unique class name
            };

            // Register the window class with the system
            PInvoke.RegisterClass(classInfo);

            // Create an invisible window with the registered class
            Hwnd = PInvoke.CreateWindowEx(
                dwExStyle: 0, // Extended window styles (not used)
                lpClassName: windowId, // Window class name
                lpWindowName: windowId, // Window name (same as class)
                dwStyle: 0, // Window styles (not used, window is invisible)
                X: 0, // Window X position
                Y: 0, // Window Y position
                nWidth: 0, // Window width
                nHeight: 0, // Window height
                hWndParent: new HWND(IntPtr.Zero), // Parent window (none)
                hMenu: null, // Menu (none)
                hInstance: null, // Application instance (not used)
                lpParam: null); // Additional parameters (not used)
        }
    }

    // Destructor: automatically releases resources if Dispose was not called
    ~NativeWindow()
    {
        Dispose(false);
    }

    // Property: returns the handle of the created window
    public HWND Hwnd { get; private set; }

    // Dispose method: releases window resources
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this); // Prevent the destructor from being called
    }

    // Internal Dispose method: performs the actual resource cleanup
    private void Dispose(bool isDisposing)
    {
        // Check if the window has already been destroyed
        if (Hwnd != HWND.Null)
        {
            // Destroy the window
            PInvoke.DestroyWindow(hWnd: Hwnd);
            Hwnd = HWND.Null; // Reset the window handle

            // Unregister the window class
            PInvoke.UnregisterClass(
                lpClassName: windowId,
                hInstance: null);
        }
    }

    // Window message handler: called when receiving messages from the tray icon
    private LRESULT OnWindowMessageReceived(HWND hwnd, uint msg, WPARAM wParam, LPARAM lParam)
    {
        // Forward the message to NotifyIcon for processing
        owner.ProcessMessage(msg, wParam, lParam);

        // Call the default window procedure for unhandled messages
        return PInvoke.DefWindowProc(
            hWnd: hwnd,
            Msg: msg,
            wParam: wParam,
            lParam: lParam);
    }
}

var data = new NOTIFYICONDATAW
{
    // Set the size of the structure. This is required for the Shell_NotifyIcon function
    // to correctly interpret the structure, especially across different versions of Windows.
    cbSize = (uint)sizeof(NOTIFYICONDATAW),

    // Specify the fields in the structure that are being used.
    // NIF_TIP: The szTip (tooltip) field is valid.
    // NIF_MESSAGE: The uCallbackMessage field is valid (used for handling icon events).
    // NIF_GUID: The guidItem field is valid (unique identifier for the icon).
    // NIF_ICON: The hIcon field is valid (icon image).
    uFlags =
        NOTIFY_ICON_DATA_FLAGS.NIF_TIP |
        NOTIFY_ICON_DATA_FLAGS.NIF_MESSAGE |
        NOTIFY_ICON_DATA_FLAGS.NIF_GUID |
        NOTIFY_ICON_DATA_FLAGS.NIF_ICON,

    // Set the tooltip text that appears when hovering over the icon.
    szTip = Text,

    // Set the icon handle. If no icon is provided, use a null handle (nint.Zero).
    hIcon = new HICON(Icon?.Handle ?? nint.Zero),

    // Set the handle of the window that will receive messages from the tray icon.
    hWnd = window.Hwnd,

    // Set the custom message ID that will be sent to the window when the icon is interacted with.
    uCallbackMessage = MESSAGE_ID,

    // Set the unique identifier (GUID) for the icon. This ensures the icon is uniquely identified
    // even if the executable path changes.
    guidItem = Id,

    // Set additional options in the anonymous union.
    Anonymous =
    {
        // Explicitly set the version of the NOTIFYICONDATAW structure.
        // Version 5 is the latest and supports modern features like high-resolution icons
        // and extended tooltips.
        uVersion = 5
    }
};

// Method to show (add) the tray icon in the system tray
public void Show()
{
    // Retrieve the NOTIFYICONDATAW structure with the current icon settings
    var data = GetData();

    // Call Shell_NotifyIcon with the NIM_ADD flag to add the icon to the tray
    var result = PInvoke.Shell_NotifyIcon(
        dwMessage: NOTIFY_ICON_MESSAGE.NIM_ADD, // Add the icon
        lpData: data); // Pass the icon data

    // If the operation was successful, update the visibility flag
    if (result)
    {
        IsVisible = true;
    }
}

// Method to hide (remove) the tray icon from the system tray
public void Hide()
{
    // Retrieve the NOTIFYICONDATAW structure with the current icon settings
    var data = GetData();

    // Call Shell_NotifyIcon with the NIM_DELETE flag to remove the icon from the tray
    var result = PInvoke.Shell_NotifyIcon(
        dwMessage: NOTIFY_ICON_MESSAGE.NIM_DELETE, // Delete the icon
        lpData: data); // Pass the icon data

    // If the operation was successful, update the visibility flag
    if (result)
    {
        IsVisible = false;
    }
}

// Method to update the tray icon's properties (e.g., icon, tooltip)
private void Update()
{
    // Only update the icon if it is currently visible
    if (IsVisible)
    {
        // Retrieve the NOTIFYICONDATAW structure with the updated settings
        var data = GetData();

        // Call Shell_NotifyIcon with the NIM_MODIFY flag to update the icon
        PInvoke.Shell_NotifyIcon(
            dwMessage: NOTIFY_ICON_MESSAGE.NIM_MODIFY, // Modify the icon
            lpData: data); // Pass the updated icon data
    }
}

// Property for the tooltip text of the tray icon
public string Text
{
    // Getter: returns the current text or an empty string if null
    get => text ?? string.Empty;

    // Setter: updates the text and refreshes the tray icon
    set
    {
        // Check if the new value is the same as the current value
        if (text == value)
        {
            return; // No changes needed, exit early
        }

        // Update the text field with the new value
        text = value;

        // Call the Update method to refresh the tray icon with the new text
        Update();
    }
}

// Property for the icon image of the tray icon
public IIconFile? Icon
{
    // Getter: returns the current icon
    get => icon;

    // Setter: updates the icon and refreshes the tray icon
    set
    {
        // Check if the current icon exists and should be disposed
        if (icon != null && !keepIconAlive)
        {
            icon.Dispose(); // Release resources of the old icon
        }

        // Update the icon field with the new value
        icon = value;

        // Call the Update method to refresh the tray icon with the new icon
        Update();
    }
}

// Register a custom window message "TaskbarCreated" and store its unique ID.
// This message is sent by the system when the taskbar is recreated (e.g., after Explorer restarts).
private static readonly uint WM_TASKBARCREATED = PInvoke.RegisterWindowMessage("TaskbarCreated");

private void ProcessMessage(uint messageId, WPARAM wParam, LPARAM lParam)
{
    // Check if the message is WM_TASKBARCREATED, which indicates the taskbar has been recreated
    if (messageId == WM_TASKBARCREATED)
    {
        // Re-display the tray icon by calling the Show method
        Show();
        return; // Exit early since no further processing is needed for this message
    }

    // If the message is not the custom MESSAGE_ID (used for tray icon events), ignore it
    if (messageId != MESSAGE_ID)
    {
        return; // Exit early
    }

    // Handle specific tray icon events based on the value of lParam
    switch (lParam.Value)
    {
        // Handle left mouse button click (WM_LBUTTONUP)
        case WM_LBUTTONUP:
        // Handle right mouse button click (WM_RBUTTONUP)
        case WM_RBUTTONUP:
            // Trigger the OnClick event to notify subscribers of a click event
            OnClick(EventArgs.Empty);
            break;
    }
}

public partial class MainWindow : Window
{
    // Declare a NotifyIcon instance to manage the system tray icon
    private NotifyIcon notifyIcon;

    // Constructor for the MainWindow class
    public MainWindow()
    {
        // Initialize the window components
        this.InitializeComponent();

        // Create a new NotifyIcon instance with the following properties:
        // - A unique GUID to identify the icon
        // - Tooltip text ("Click me")
        // - An icon loaded from a library file (shell32.dll, index 130)
        notifyIcon = new NotifyIcon()
        {
            Id = Guid.Parse("55DE2A49-087C-4331-A76C-6AA2212F3C39"),
            Text = "Click me",
            Icon = new LibIcon("shell32.dll", 130)
        };

        // Subscribe to the Click event of the NotifyIcon
        notifyIcon.Click += NotifyIcon_Click;

        // Display the tray icon
        notifyIcon.Show();

        // Ensure the NotifyIcon is properly disposed of when the window is closed
        Closed += (_, _) => notifyIcon?.Dispose();
    }

    // Event handler for the NotifyIcon's Click event
    private void NotifyIcon_Click(object? sender, EventArgs e)
    {
        // Toggle the visibility of the window
        if (AppWindow.IsVisible)
        {
            AppWindow.Hide(); // Hide the window if it's visible
        }
        else
        {
            AppWindow.Show(); // Show the window if it's hidden
        }
    }

    // Nested class LibIcon: implements IIconFile to load icons from library files
    public sealed class LibIcon : IIconFile
    {
        // Handle to the loaded icon
        private DestroyIconSafeHandle iconHandle;

        // Constructor: loads an icon from a library file (e.g., shell32.dll)
        public LibIcon(string fileName, uint iconIndex)
        {
            // Extract the icon from the specified file and index
            iconHandle = PInvoke.ExtractIcon(fileName, iconIndex);
        }

        // Property: returns the handle to the loaded icon
        public nint Handle => iconHandle.DangerousGetHandle();

        // Method: disposes of the icon handle to free resources
        public void Dispose()
        {
            // Check if the handle is valid before disposing
            if (!iconHandle.IsInvalid)
            {
                iconHandle?.Dispose(); // Release the icon handle
            }
        }
    }
}