C#

const uint WM_GETTEXT = 0x000D;
StringBuilder message = new StringBuilder(1000);
SendMessage(handle, WM_GETTEXT, message.Capacity, message);

public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
        WindowWrapper parentForm = ProcessWindowsHelper.getHandleToAnotherProcessWindow("TortoiseGitProc", "Switch/Checkout");
        MessageBoxEx.Show(parentForm, "Hello on top of TortoiseGit Switch/Checkout dialog");
    }
}
public class ProcessWindowsHelper
{
    private delegate bool EnumThreadWndProc(IntPtr hWnd, IntPtr lp);
    [DllImport("user32.dll")]
    private static extern bool EnumThreadWindows(int tid, EnumThreadWndProc callback, IntPtr lp);
    [DllImport("user32.dll", CharSet = CharSet.Auto)]
    static extern IntPtr SendMessage(IntPtr hWnd, uint Msg, int wParam, StringBuilder lParam);
    delegate bool EnumThreadDelegate(IntPtr hWnd, IntPtr lParam);

    private const uint WM_GETTEXT = 0x000D;

    public static WindowWrapper getHandleToAnotherProcessWindow(string processName, string substringInAnotherProcessWindow)
    {
        Process myProcess = findProcessByName(processName);
        IEnumerable<IntPtr> allHandlesInMyProcess = EnumerateProcessWindowHandles(myProcess.Id);
        foreach (IntPtr handle in allHandlesInMyProcess)
        {
            StringBuilder message = new StringBuilder(1000);
            SendMessage(handle, WM_GETTEXT, message.Capacity, message);
            if (message.ToString().Contains(substringInAnotherProcessWindow))
            {
                Debug.WriteLine(message);
                return new WindowWrapper(handle);
            }
        }
        return null;
    }

    private static IEnumerable<IntPtr> EnumerateProcessWindowHandles(int processId)
    {
        List<IntPtr> handles = new List<IntPtr>();
        ProcessThreadCollection processThreadCollection = Process.GetProcessById(processId).Threads;
        for (int i = 0; i < processThreadCollection.Count; i++)
        {
            ProcessThread thread;
            thread = processThreadCollection[i];
            EnumThreadWindows(thread.Id, 
                delegate(IntPtr hWnd, IntPtr lParam)
                {
                    handles.Add(hWnd);
                    return true;
                }, 
                IntPtr.Zero);
        }
        return handles;
    }

    private static Process findProcessByName(string processName)
    {
        Process[] allProcesses = Process.GetProcesses();
        for (int j = 0; j < allProcesses.Length; j++)
        {
            if (allProcesses[j].ProcessName.Equals(processName))
            {
                return allProcesses[j];
            }
        }
        return null;
    }
}


public class WindowWrapper : IWin32Window
{
    public WindowWrapper(IntPtr handle)
    {
        _hwnd = handle;
    }

    public IntPtr Handle
    {
        get { return _hwnd; }
    }

    private IntPtr _hwnd;
}

parentForm = ProcessWindowsHelper.getHandleToAnotherProcessWindow("bash", "MING")

private static IEnumerable<IntPtr> EnumerateProcessWindowHandles(int processId)
{
    List<IntPtr> handles = new List<IntPtr>();
    ProcessThreadCollection processThreadCollection = Process.GetProcessById(processId).Threads;
    for (int i = 0; i < processThreadCollection.Count; i++)
    {
        ProcessThread thread;
        thread = processThreadCollection[i];
        EnumThreadWindows(thread.Id,
            delegate(IntPtr hWnd, IntPtr lParam)
            {
                handles.Add(hWnd);
                return true;
            },
            IntPtr.Zero);
    }
    return handles;
}

Window OOOA9B72 "MINGW64:/c/dummyRepo" mintty

Window Caption: MINGW64:/c/dummyRepo
Window Handle:  OOOA9B72
Window Proc:    (Unavailable)(Unicode)
Rectangle:      (86, 89)-(681, 466), 595x377
Restored Rect:  (86, 89)-(681, 466), 595x377
Client Rect:    (8, 31)-(570, 369), 562x338
Instance Handle 00400000
Menu Handle     00000000
User Data       00000000
Windows Bytes:

private static List<IntPtr> handles;

private static IEnumerable<IntPtr> EnumerateProcessWindowHandles(int processId)
{
    handles = new List<IntPtr>();
    ProcessThreadCollection processThreadCollection = Process.GetProcessById(processId).Threads;
    for (int i = 0; i < processThreadCollection.Count; i++)
    {
        ProcessThread thread;   // If I put a breakpoint here, the debugger stops 3 times
        thread = processThreadCollection[i];
        EnumThreadWindows(thread.Id, myDelegate, IntPtr.Zero);
    }
    return handles;
}

private static bool myDelegate(IntPtr hWnd, IntPtr lParam)
{
    handles.Add(hWnd);  // If I put a breakpoint here, then the debugger never stops
    return true;
}

$ git.exe checkout develop

pkfox wrote:

It must be the UI thread in Winforms

this.GetAccessToken().GetAwaiter().GetResult(); // Blocks the UI thread

this.Result = await this.App.AcquireTokenForClient(this.ResourceIds).ExecuteAsync().ConfigureAwait(false);

private void ButtonClick(object sender, EventArgs e)
{
    // Some code...
    this.GetAccessToken().GetAwaiter().GetResult();
    // Some more code...
}

private async void ButtonClick(object sender, EventArgs e)
{
    // Some code...
    await this.GetAccessToken();
    // Some more code
}

private void ButtonClick(object sender, EventArgs e)
{
    _ = SomeMethodAsync();
}

private async Task SomeMethodAsync()
{
    // Some code...
    await this.GetAccessToken();
    // Some more code
}

class SomeClass
{
    private async Task GetAccessToken() { ... }
    
    public async Task DoSomething()
    {
        // Code to run in this class before getting the access token here...
        
        await GetAccessToken();
        
        // Code to run in this class after getting the access token here...
    }
}

class YourForm
{
    private SomeClass _someClass;
    
    private void FormLoad(object sender, EventArgs e)
    {
        _someClass = new SomeClass();
        _ = DoSomethingInTheForm();
    }
    
    private async Task DoSomethingInTheForm()
    {
        // Code to run in the form before getting the access token here...
        
        await _someClass.DoSomething();
        
        // Code to run in the form after getting the access token here...
    }
}