How do I lock the size and position of an external application?

There are many ways to do this, though Windows doesn't have a function out of the box to lock the window in place.

Note: All these methods require an IntPtr (HWND), you can obtain it using the Form.Handle property, or, through HWND/HANDLE you get from the Windows APIs, which refer to the window in your external application.

The most reliable and simple approach would be changing the window form border style and removing the minimize box.

public static void LockResize(IntPtr hWnd, Rectangle desiredBounds)
{
    Form form = (Form)Form.FromHandle(hWnd)!;

    form.FormBorderStyle = FormBorderStyle.FixedSingle;
    form.MaximizeBox = false;
    form.Bounds = desiredBounds;
}

The next approach would be snapping the window positions back after it's done resizing. I've seen this approach in some older applications. Some people may consider this experience poor, so please review this approach to ensure it's reliable for your use case.

public static void LockResize(IntPtr hWnd, Rectangle desiredBounds)
{
    Form form = (Form)Form.FromHandle(hWnd)
        ?? throw new InvalidOperationException("Could not get form by handle...");

    form.Resize += (s, e) =>
    {
        if (form.InvokeRequired)
        {
            form.Invoke((MethodInvoker)(() =>
            {
                form.Bounds = desiredBounds;
            }));
        }
        else
        {
            form.Bounds = desiredBounds;
        }
    };
}

Another approach would be a bruteforce method, that constantly changes the window size. This does mean that the window will be rapidly resizing back and forth when you actually try resizing, however, it does eventually lock it in place.

private const int Interval = 25; //25ms

public static Thread LockResize(IntPtr hWnd, Rectangle desiredBounds)
{
    var thread = new Thread(() =>
    {
        try
        {
            Form form = (Form)Form.FromHandle(hWnd)!;

            while (true)
            {
                if (form.InvokeRequired)
                {
                    form.Invoke((MethodInvoker)(() =>
                    {
                        form.Bounds = desiredBounds;
                    }));
                }
                else
                {
                    form.Bounds = desiredBounds;
                }

                Thread.Sleep(Interval);
            };
        }
        catch
        {
        }
    });

    thread.Start();
    return thread;
}

This approach spawns a background thread. Note that you'll have to manually invoke the Interrupt() method on the returned Thread before your application exits naturally (e.g., when all windows are closed), otherwise it will just linger in the background.

var thread = LockResize(hwnd, bounds);
//...
thread.Interrupt();

You can also change the Interval constant to make resizes slower or faster, but using a value below ~3 risks slowing down the operating system from intense overhead.

Just a slight heads up: these approaches may not work as you expect with WinUI/UWP apps like Calculator or Sound Recorder, including Microsoft Paint (which has gone WinUI recently), because the actual window of these apps is in a different process - called ApplicationFrameHost.exe - so you'll have to get the window handle from there.

I assume you have managed to bring the main window of the external program into your application by setting its parent to the handle of a container cotrol with SetWindoLong(..).
If so, sending a WM_MAXIMIZE-Message to this window should result in aligning it to the client area of the container control.