How to set Taskbar progress from a console app?

[timcassell]

I'm using ITaskbarList3 and GetConsoleWindow() to set the taskbar progress from a console app. This works perfectly fine in cmd and PowerShell, but it does nothing in Terminal. How can I get this to work agnostically?

dotnet/BenchmarkDotNet#2158

I have checked #6700, but I'm not sure how to actually make it work from a C# console app.

[zadjii-msft]

Don't call GetConsoleWindow. That's not gonna work right in plenty of scenarios.

What you'll need is SetConsoleMode with ENABLE_VIRTUAL_TERMINAL_PROCESSING. Then, write to the console something like

"\x1b]9;4;1;50\x1b\\"

(My C# is rusty so I might not have escaped that string correctly)

[timcassell]

I can check if a parent process is WindowsTerminal, but this feels super hacky.

Details

internal static class ProcessExtensions
{
    public static bool GetIsHostedByWindowsTerminal()
    {
        var process = Process.GetCurrentProcess();
        while (process != null)
        {
            if (process.ProcessName == "WindowsTerminal")
            {
                return true;
            }
            process = process.GetParent();
        }
        return false;
    }

    public static Process GetParent(this Process process)
    {
        int Id = process.Id;
        PROCESSENTRY32 pe32 = new PROCESSENTRY32 { };
        pe32.dwSize = (uint)Marshal.SizeOf(typeof(PROCESSENTRY32));
        using (var hSnapshot = CreateToolhelp32Snapshot(SnapshotFlags.Process, (uint)Id))
        {
            if (hSnapshot.IsInvalid)
            {
                return null;
            }

            if (!Process32First(hSnapshot, ref pe32))
            {
                return null;
            }
            do
            {
                if (pe32.th32ProcessID == (uint)Id)
                {
                    try
                    {
                        return Process.GetProcessById((int)pe32.th32ParentProcessID);
                    }
                    catch (ArgumentException)
                    {
                        return null;
                    }
                }
            } while (Process32Next(hSnapshot, ref pe32));
        }
        return null;
    }
    private const int ERROR_NO_MORE_FILES = 0x12;
    [DllImport("kernel32.dll", SetLastError = true)]
    private static extern SafeSnapshotHandle CreateToolhelp32Snapshot(SnapshotFlags flags, uint id);
    [DllImport("kernel32.dll", SetLastError = true)]
    private static extern bool Process32First(SafeSnapshotHandle hSnapshot, ref PROCESSENTRY32 lppe);
    [DllImport("kernel32.dll", SetLastError = true)]
    private static extern bool Process32Next(SafeSnapshotHandle hSnapshot, ref PROCESSENTRY32 lppe);

    [Flags]
    private enum SnapshotFlags : uint
    {
        HeapList = 0x00000001,
        Process = 0x00000002,
        Thread = 0x00000004,
        Module = 0x00000008,
        Module32 = 0x00000010,
        All = (HeapList | Process | Thread | Module),
        Inherit = 0x80000000,
        NoHeaps = 0x40000000
    }
    [StructLayout(LayoutKind.Sequential)]
    private struct PROCESSENTRY32
    {
        public uint dwSize;
        public uint cntUsage;
        public uint th32ProcessID;
        public IntPtr th32DefaultHeapID;
        public uint th32ModuleID;
        public uint cntThreads;
        public uint th32ParentProcessID;
        public int pcPriClassBase;
        public uint dwFlags;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)] public string szExeFile;
    };
    [SuppressUnmanagedCodeSecurity, HostProtection(SecurityAction.LinkDemand, MayLeakOnAbort = true)]
    internal sealed class SafeSnapshotHandle : SafeHandleMinusOneIsInvalid
    {
        internal SafeSnapshotHandle() : base(true)
        {
        }

        [SecurityPermission(SecurityAction.LinkDemand, UnmanagedCode = true)]
        internal SafeSnapshotHandle(IntPtr handle) : base(true)
        {
            base.SetHandle(handle);
        }

        protected override bool ReleaseHandle()
        {
            return CloseHandle(base.handle);
        }

        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success), DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true, ExactSpelling = true)]
        private static extern bool CloseHandle(IntPtr handle);
    }
}

[zadjii-msft]

Hmm. That looks to me like VT processing didn't get turned on. What was the original value of previousConsoleMode, did SetConsoleMode return an error, and if you call GetConsoleMode again after the call to SetConsoleMode, did the ENABLE_VIRTUAL_TERMINAL_PROCESSING stick?

[timcassell]

Looks like the Get/SetConsoleMode failed in both hosts, but the Console.Write worked to update the progress in Terminal anyway.

GetConsoleMode failed
previousConsoleMode: 0
SetConsoleMode failed
GetConsoleMode failed
currentConsoleMode: 0

IntPtr handle = Process.GetCurrentProcess().Handle;
ConsoleModes previousConsoleMode;
if (!GetConsoleMode(handle, out previousConsoleMode))
{
    Console.WriteLine("GetConsoleMode failed");
}
Console.WriteLine($"previousConsoleMode: {previousConsoleMode}");
if (!SetConsoleMode(handle, ConsoleModes.ENABLE_VIRTUAL_TERMINAL_PROCESSING | ConsoleModes.ENABLE_PROCESSED_OUTPUT))
{
    Console.WriteLine("SetConsoleMode failed");
}
ConsoleModes currentConsoleMode;
if (!GetConsoleMode(handle, out currentConsoleMode))
{
    Console.WriteLine("GetConsoleMode failed");
}
Console.WriteLine($"currentConsoleMode: {currentConsoleMode}");

[j4james]

@timcassell Your problem is that you're using the wrong handle. You need the standard output handle which you get like this:

var handle = GetStdHandle(STD_OUTPUT_HANDLE);

where STD_OUTPUT_HANDLE is -11 in case you don't already have that defined somewhere.

Also, I would probably recommended setting the mode like this:

SetConsoleMode(handle, previousConsoleMode | ConsoleModes.ENABLE_VIRTUAL_TERMINAL_PROCESSING);

That way you're just adding the VT mode, and not replacing all the existing modes entirely (unless that's what you intended).

That said, this is just going to stop the console from dumping those escape sequence to the screen, but it won't actually get the progress bar to work yet. As @DHowett mentioned above, the progress bar sequences are only supported in Windows Terminal for now.

[timcassell]

@j4james Aha, that did the trick, thanks!

That said, this is just going to stop the console from dumping those escape sequence to the screen, but it won't actually get the progress bar to work yet. As @DHowett mentioned above, the progress bar sequences are only supported in Windows Terminal for now.

That's fine, I will just use the ITaskbarList3 method as well as the console sequence, and one of them will work and the other will do nothing, depending which host is running. Though I'll have to update it to not use ITaskbarList3 later if conhost will actually support the console sequence in the future.