Drag and Drop different graphic shapes within a Form individually

I am trying to be able to pick, move vertically and drop 2 different rectangles (potentially getting their positions, but that's a problem for another day).

Here's the code that I managed to put together for one shape, but couldn't I find a way to make it possible to perform the action by clicking on one without affecting the other.

using System.Collections.Generic;
using System.Drawing;
using System.Linq;

public partial class Form1 : Form
{
    Rectangle topMarker = new Rectangle(50, 125, 50, 2);
    Rectangle bottomMarker = new Rectangle(50, 200, 50, 2);
   
    bool isMouseDown = false;
    
    public Form1()
    {
        InitializeComponent();
    }

    private void pictureBox1_Paint(object sender, PaintEventArgs e)
    {
        e.Graphics.FillRectangle(new SolidBrush(Color.Green), topMarker);
        e.Graphics.FillRectangle(new SolidBrush(Color.Red), bottomMarker);
    }

    
    private void pictureBox1_MouseDown(object sender, MouseEventArgs e)
    {
        isMouseDown = true;
    }

    private void pictureBox1_MouseMove(object sender, MouseEventArgs e)
    {
        if (isMouseDown == true)
        {
            topMarker.Location = e.Location;
            topMarker.X = 50;

             if (topMarker.Y < 0)
             {
                topMarker.Y = 0;
             }

             if (topMarker.Y > pictureBox1.Height)
             {
                 topMarker.Y = pictureBox1.Height - topMarker.Height;
             } 
            Refresh();
        }
    }

    private void pictureBox1_MouseUp(object sender, MouseEventArgs e)
    {
        isMouseDown = false;
    }
}

I suggest to create a class object that describes your shape.
A collection of these object is much easier to handle when you need to interact with one of its objects.

The class object, in my view, should implement an Interface that allows to call methods and use properties that are common to all the shapes you draw (assuming you could add different shapes, not just rectangles).
In the example here, the Marker class objects implements an IShape Interface, which defines which methods and properties all objects must expose.
It also implements IDisposable, since it holds unmanaged resources, in the form of a GraphicsPath, in this case. Remember to call Dispose() on all elements of the collection when the Form closes.

• The Marker's class Move() method allows to specify an offset (difference from the previous position) to move a shape.
• Its Draw() method accepts a Graphics object as argument, you just need to pass the e.Graphics object provided by the PaintEventArgs of the Paint event of the canvas where the shapes are drawn. The Marker draws itself in this device context.
• The IsMouseOver() returns true or false when the Mouse position falls inside the bounds of the shape. It uses the GraphicsPath's IsVisible property

To avoid losing a shape while it's being dragged around (because the Mouse Pointer may move outside it's bounds), we pre-define a selected shape when one of the Marker objects receives a click event and we store the current position of the Pointer. It's then updated in advance while the Mouse is moved. The currently selected shape is also updated (see the mouseTrackLocation and selectedMarker Fields)

Thats' pretty much all about it, except you could add some tolerance to the code that identifies the shape under the Mouse Pointer (could be done inflating the GraphicsPath with some invisible content)

NOTE: This code assumes you're targeting .NET 6+ and nullable enabled. If this is not the case, simply change all object? to object and using declarations in using blocks

<br/>

public partial class SomeForm : Form {

    private List<Marker> markers = new();
    private bool dragShapeStarted = false;
    private Point mouseTrackLocation = Point.Empty;
    private Marker? selectedMarker = null;

    public SomeForm() {
        InitializeComponent();
        markers.AddRange(new[]{
            new Marker(new RectangleF(50, 125, 100, 2), Color.Transparent, Color.Green),
            new Marker(new RectangleF(50, 200, 100, 2), Color.Transparent, Color.Red),
            new Marker(new RectangleF(50, 250, 100, 2), Color.Transparent, Color.Orange),
        });
    }

    private void somePictureBox_MouseDown(object? sender, MouseEventArgs e) {
        if (e.Button == MouseButtons.Left) {
            selectedMarker = markers.FirstOrDefault(m => m.IsMouseOver(e.Location));
            // Mouse Down on a shape & selectedMarker not null => pre-emptive positive result
            if (selectedMarker != null) dragShapeStarted = true;
            mouseTrackLocation = e.Location;
        }
    }

    private void somePictureBox_MouseMove(object? sender, MouseEventArgs e) {
        if (!(sender is PictureBox pBox)) return;

        pBox.Cursor = selectedMarker is null ? Cursors.Default : Cursors.HSplit;
        // We need to move the selected shape as quick as possible: see MouseDown
        if (selectedMarker != null && dragShapeStarted) {
            selectedMarker.Move(new PointF(0, e.Location.Y - mouseTrackLocation.Y));
            mouseTrackLocation = e.Location;
            pBox.Invalidate();
        }
        // Enables curson change while the Mouse Pointer is moved
        selectedMarker = markers.FirstOrDefault(m => m.IsMouseOver(e.Location));
    }

    private void somePictureBox_MouseUp(object? sender, MouseEventArgs e) {
        dragShapeStarted = false;
        selectedMarker = null;
    }

    private void somePictureBox_Paint(object? sender, PaintEventArgs e) {
        markers.ForEach(m => m.Draw(e.Graphics));
    }
}

The Marker class and IShape Interface:

public interface IShape {
    RectangleF Shape { get; }
    GraphicsPath Path { get; }
    void Move(PointF position);
    void Draw(Graphics graphics);
    bool IsMouseOver(PointF mousePosition);
}

public class Marker : IShape, IDisposable {
    private bool disposed = false;
    private GraphicsPath path = new();
    public Marker(RectangleF shape, Color borderColor, Color fillColor) {
        BorderColor = borderColor;
        FillColor = fillColor;
        path.AddRectangle(shape);
        Path = path;
    }

    public RectangleF Shape => path.GetBounds();
    public GraphicsPath Path { get; }
    public Color BorderColor { get; set; }
    public Color FillColor { get; set; }
    public bool IsMouseOver(PointF mousePosition) => path.IsVisible(mousePosition);

    public void Move(PointF position) {
        // Translates by an offset, not absolute position
        using var mx = new Matrix(1, 0, 0, 1, position.X, position.Y);
        path.Transform(mx);
    }

    public void Draw(Graphics canvas) {
        using var brush = new SolidBrush(FillColor);
        using var pen = new Pen(BorderColor);
        canvas.FillPath(brush, path);
        canvas.DrawPath(pen, path);
    }

    public void Dispose() {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    protected virtual void Dispose(bool disposing) {
        if (!disposed) {
            path?.Dispose();
            disposed = true;
        }
    }
}

This is how it works: