据我所知，所需的行为是启用“单击移动”（一种或另一种方式），然后单击多屏幕表面上的任何地方，让无边框表单跟随鼠标移动到新位置。在我的简短测试中，一个似乎有效的解决方案是pinvoke WinApi SetWindowsHookEx，为WH_MOUSE_LL安装一个全局低级钩子，以便拦截WM_LBUTTONDOWN。

*此答案已修改，以便跟踪问题的更新。
低级全局鼠标钩子

public MainForm()
    {
        InitializeComponent();
        using (var process = Process.GetCurrentProcess())
        {
            using (var module = process.MainModule!)
            {
                var mname = module.ModuleName!;
                var handle = GetModuleHandle(mname);
                _hook = SetWindowsHookEx(
                    HookType.WH_MOUSE_LL,
                    lpfn: callback,
                    GetModuleHandle(mname),
                    0);
            }
        }

        // Unhook when this `Form` disposes.
        Disposed += (sender, e) => UnhookWindowsHookEx(_hook);

        // A little hack to keep window on top while Click-to-Move is enabled.
        checkBoxEnableCTM.CheckedChanged += (sender, e) =>
        {
            TopMost = checkBoxEnableCTM.Checked;
        };

        // Compensate move offset with/without the title NC area.
        var offset = RectangleToScreen(ClientRectangle);
        CLIENT_RECT_OFFSET = offset.Y - Location.Y;
    }
    readonly int CLIENT_RECT_OFFSET;
    IntPtr _hook;
    private IntPtr callback(int code, IntPtr wParam, IntPtr lParam)
    {
        var next = IntPtr.Zero;
        if (code >= 0)
        {
            switch ((int)wParam)
            {
                case WM_LBUTTONDOWN:
                    if (checkBoxEnableCTM.Checked)
                    {
                        _ = onClickToMove(MousePosition);
                        // This is a very narrow condition and the window is topmost anyway.
                        // So probably swallow this mouse click and skip other hooks in the chain.
                        return (IntPtr)1;
                    }
                    break;
            }
        }
        return CallNextHookEx(IntPtr.Zero, code, wParam, lParam);
    }
}

执行移动

private async Task onClickToMove(Point mousePosition)
{
    // Exempt clicks that occur on the 'Enable Click to Move` button itself.
    if (!checkBoxEnableCTM.ClientRectangle.Contains(checkBoxEnableCTM.PointToClient(mousePosition)))
    {
        // Try this. Offset the new `mousePosition` so that the cursor lands
        // in the middle of the button when the move is over. This feels
        // like a semi-intuitive motion perhaps. This means we have to
        // subtract the relative position of the button from the new loc.
        var clientNew = PointToClient(mousePosition);

        var centerButton =
            new Point(
                checkBoxEnableCTM.Location.X + checkBoxEnableCTM.Width / 2,
                checkBoxEnableCTM.Location.Y + checkBoxEnableCTM.Height / 2);

        var offsetToNow = new Point(
            mousePosition.X - centerButton.X,
            mousePosition.Y - centerButton.Y - CLIENT_RECT_OFFSET);

        // Allow the pending mouse messages to pump. 
        await Task.Delay(TimeSpan.FromMilliseconds(1));
        WindowState = FormWindowState.Normal; // JIC window happens to be maximized.
        Location = offsetToNow;            
    }
    checkBoxEnableCTM.Checked = false; // Turn off after each move.
}

在我用来测试这个答案的代码中，将点击发生的按钮居中似乎是很直观的（如果这个偏移不适合你，很容易改变）。

威爱比

#region P I N V O K E
public enum HookType : int { WH_MOUSE = 7, WH_MOUSE_LL = 14 }
const int WM_LBUTTONDOWN = 0x0201;

delegate IntPtr HookProc(int code, IntPtr wParam, IntPtr lParam);

[DllImport("user32.dll", SetLastError = true)]
static extern IntPtr SetWindowsHookEx(HookType hookType, HookProc lpfn, IntPtr hMod, int dwThreadId);

[DllImport("user32.dll")]
static extern IntPtr CallNextHookEx(IntPtr hhk, int nCode, IntPtr wParam,
    IntPtr lParam);

[DllImport("user32.dll", SetLastError = true)]
static extern bool UnhookWindowsHookEx(IntPtr hhk);

[DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
public static extern IntPtr GetModuleHandle(string lpModuleName);
#endregion P I N V O K E

这是一个我最终会采用的“可能”的解决方案。这并不是说IVSoftware's answer不起作用，它起作用了，我试过了。这是因为我的解决方案有一些与我正在尝试做的事情相关的优点。要点是：

• 利用IMessageFilter（多亏了SwDevMan81's answer），它提醒我“全局”处理消息的正确方法是 * 不要 * 覆盖WndProc）
• 在所有屏幕上布置一组透明窗口，以便在任何地方接收鼠标移动消息。

优点

• 它无需执行任何P/Invoke即可工作
• 它允许使用更多的技巧，例如利用透明表单实现“移动边框而不是表单”功能（虽然我没有测试它，但画图可能很棘手）
• 也可以很容易地应用于调整大小。
• 可以使用鼠标左键/主键以外的其他键。

缺点

• 它有太多的“活动部件”。至少对我的口味来说是这样。到处布置透明的Windows？嗯。
• 它有一些极端的情况。在移动窗体的同时按Alt+F4将关闭“画布窗体”。这可以很容易地缓解，但也可能有其他情况。
• 必须有一个操作系统的方式来做到这一点...

代码（基本部分; github上的完整代码）

public enum WindowMessage
{
    WM_MOUSEMOVE = 0x200,
    WM_LBUTTONDOWN = 0x201,
    WM_LBUTTONUP = 0x202,
    WM_RBUTTONDOWN = 0x204,
    //etc. omitted for brevity
}

public class MouseMessageFilter : IMessageFilter
{
    public event EventHandler MouseMoved;
    public event EventHandler<MouseButtons> MouseDown;
    public event EventHandler<MouseButtons> MouseUp;

    public bool PreFilterMessage(ref Message m)
    {
        switch (m.Msg)
        {
            case (int)WindowMessage.WM_MOUSEMOVE:
                MouseMoved?.Invoke(this, EventArgs.Empty);
                break;
            case (int)WindowMessage.WM_LBUTTONDOWN:
                MouseDown?.Invoke(this, MouseButtons.Left);
                break;
            //etc. omitted for brevity
        }

        return false;
    }
}

public partial class CustomForm : Form
{
    private MouseMessageFilter windowMoveHandler = new();
    private Point originalLocation;
    private Point offset;

    private static List<Form> canvases = new(SystemInformation.MonitorCount);

    public CustomForm()
    {
        InitializeComponent();
        
        windowMoveHandler.MouseMoved += (_, _) =>
        {
            Point position = Cursor.Position;
            position.Offset(offset);
            Location = position;
        };
        windowMoveHandler.MouseDown += (_, button) =>
        {
            switch (button)
            {
                case MouseButtons.Left:
                    EndMove();
                    break;
                case MouseButtons.Middle:
                    CancelMove();
                    break;
            }
        };
        moveButton.MouseClick += (_, _) =>
        {
            BeginMove();
        };
    }

    private void BeginMove()
    {
        Application.AddMessageFilter(windowMoveHandler);
        originalLocation = Location;
        offset = Invert(PointToClient(Cursor.Position));
        ShowCanvases();
    }
    
    //Normally an extension method in another library of mine but I didn't want to
    //add a dependency just for that
    private static Point Invert(Point p) => new Point(-p.X, -p.Y);

    private void ShowCanvases()
    {
        for (int i = 0; i < Screen.AllScreens.Length; i++)
        {
            Screen screen = Screen.AllScreens[i];
            Form form = new TransparentForm
            {
                Bounds = screen.Bounds,
                Owner = Owner
            };
            canvases.Add(form);
            form.Show();
        }
    }

    private void EndMove()
    {
        DisposeCanvases();
    }

    private void DisposeCanvases()
    {
        Application.RemoveMessageFilter(windowMoveHandler);
        for (var i = 0; i < canvases.Count; i++)
        {
            canvases[i].Close();
        }
        canvases.Clear();
    }

    private void CancelMove()
    {
        EndMove();
        Location = originalLocation;
    }

    //The form used as a "message canvas" for moving the form outside the client area.
    //It practically helps extend the client area. Without it we won't be able to get
    //the events from everywhere
    private class TransparentForm : Form
    {
        public TransparentForm()
        {
            StartPosition = FormStartPosition.Manual;
            FormBorderStyle = FormBorderStyle.None;
            ShowInTaskbar = false;
        }

        protected override void OnPaintBackground(PaintEventArgs e)
        {
            //Draws a white border mostly useful for debugging. For example that's
            //how I realised I needed Screen.Bounds instead of WorkingArea.
            ControlPaint.DrawBorder(e.Graphics, new Rectangle(Point.Empty, Size),
                Color.White, 2, ButtonBorderStyle.Solid,
                Color.White, 2, ButtonBorderStyle.Solid,
                Color.White, 2, ButtonBorderStyle.Solid,
                Color.White, 2, ButtonBorderStyle.Solid);
        }
    }
}