WinForms中持续绘制椭圆时固定显示矩形障碍物的实现问题

1. 核心问题修复：让障碍物位置固定 #

你现在的问题是每次重绘时都重新生成Redbox的随机位置，导致它不停跳变还闪烁。把位置初始化移到类的构造函数里，只执行一次就好：

// 先定义规范的IObstacles接口
public interface IObstacles
{
    Position Position { get; }
    Size Size { get; }
    void Draw(Graphics g);
    bool CheckCollision(Ball ball);
}

// Redbox实现接口，位置只在初始化时生成
public class Redbox : IObstacles
{
    public Position Position { get; private set; }
    public Size Size { get; } = new Size(50, 50); // 固定尺寸，也可以构造时传入

    public Redbox(int canvasWidth, int canvasHeight)
    {
        var random = new Random();
        // 避免障碍物超出画布边界
        int x = random.Next(0, canvasWidth - Size.Width);
        int y = random.Next(0, canvasHeight - Size.Height);
        Position = new Position(x, y);
    }

    public void Draw(Graphics g)
    {
        // 直接用初始化好的位置绘制，不再随机生成
        using (var brush = new SolidBrush(Color.Red))
        {
            g.FillRectangle(brush, Position.X, Position.Y, Size.Width, Size.Height);
        }
    }

    public bool CheckCollision(Ball ball)
    {
        // 矩形与小球的碰撞检测逻辑
        var boxRect = new Rectangle(Position.X, Position.Y, Size.Width, Size.Height);
        var ballRect = new Rectangle(ball.Position.X - ball.Radius, ball.Position.Y - ball.Radius, ball.Radius * 2, ball.Radius * 2);
        return boxRect.IntersectsWith(ballRect);
    }
}

2. 解决WinForms重绘闪烁 #

WinForms默认重绘容易闪烁，开启双缓冲就能解决：

方法一：给窗体/绘图控件开双缓冲 #

在窗体构造函数里加：

public MainForm()
{
    InitializeComponent();
    // 给窗体开双缓冲
    this.DoubleBuffered = true;
    // 如果用Panel当绘图容器，也要开
    // drawingPanel.DoubleBuffered = true;
}

方法二：自定义绘图控件（更稳妥） #

如果用自定义控件绘图，重写属性确保双缓冲生效：

public class DrawingPanel : Panel
{
    public DrawingPanel()
    {
        DoubleBuffered = true;
        SetStyle(ControlStyles.OptimizedDoubleBuffer | ControlStyles.AllPaintingInWmPaint, true);
        UpdateStyles();
    }
}

3. 优化Engine的障碍物管理 #

让Engine维护一个固定的障碍物集合，不要每次重绘都重新创建：

public class Engine
{
    private List<IObstacles> _obstacles = new();
    private Ball _ball;
    private readonly int _canvasWidth;
    private readonly int _canvasHeight;

    public Engine(int canvasWidth, int canvasHeight)
    {
        _canvasWidth = canvasWidth;
        _canvasHeight = canvasHeight;
        // 初始化小球
        _ball = new Ball(new Position(100, 100), new Vector(5, 3), 10);
        // 只初始化一次障碍物
        _obstacles.Add(new Redbox(canvasWidth, canvasHeight));
        // 可以添加更多不同障碍物
        // _obstacles.Add(new BlueBox(canvasWidth, canvasHeight));
    }

    public void Update()
    {
        _ball.Move();
        // 遍历检测所有碰撞
        foreach (var obstacle in _obstacles)
        {
            if (obstacle.CheckCollision(_ball))
            {
                // 小球碰到障碍物反弹
                _ball.Velocity = new Vector(-_ball.Velocity.X, -_ball.Velocity.Y);
            }
        }
        // 处理小球边界碰撞
        if (_ball.Position.X - _ball.Radius < 0 || _ball.Position.X + _ball.Radius > _canvasWidth)
        {
            _ball.Velocity = new Vector(-_ball.Velocity.X, _ball.Velocity.Y);
        }
        if (_ball.Position.Y - _ball.Radius < 0 || _ball.Position.Y + _ball.Radius > _canvasHeight)
        {
            _ball.Velocity = new Vector(_ball.Velocity.X, -_ball.Velocity.Y);
        }
    }

    public void Draw(Graphics g)
    {
        // 先清空画布
        g.Clear(Color.White);
        // 绘制小球和所有障碍物
        _ball.Draw(g);
        foreach (var obstacle in _obstacles)
        {
            obstacle.Draw(g);
        }
    }
}

4. 用抽象类共享通用代码（避免无效继承） #

如果后续要加多种障碍物，创建抽象基类来共享位置初始化逻辑，不用每个子类重复写：

// 抽象基类共享通用逻辑
public abstract class BaseObstacle : IObstacles
{
    public Position Position { get; protected set; }
    public Size Size { get; protected set; }

    protected BaseObstacle(int canvasWidth, int canvasHeight, Size size)
    {
        Size = size;
        var random = new Random();
        int x = random.Next(0, canvasWidth - Size.Width);
        int y = random.Next(0, canvasHeight - Size.Height);
        Position = new Position(x, y);
    }

    // 子类必须实现的抽象方法
    public abstract void Draw(Graphics g);
    public abstract bool CheckCollision(Ball ball);
}

// Redbox继承抽象基类，只需要实现特有逻辑
public class Redbox : BaseObstacle
{
    public Redbox(int canvasWidth, int canvasHeight) : base(canvasWidth, canvasHeight, new Size(50, 50))
    {
    }

    public override void Draw(Graphics g)
    {
        using (var brush = new SolidBrush(Color.Red))
        {
            g.FillRectangle(brush, Position.X, Position.Y, Size.Width, Size.Height);
        }
    }

    public override bool CheckCollision(Ball ball)
    {
        var boxRect = new Rectangle(Position.X, Position.Y, Size.Width, Size.Height);
        var ballRect = new Rectangle(ball.Position.X - ball.Radius, ball.Position.Y - ball.Radius, ball.Radius * 2, ball.Radius * 2);
        return boxRect.IntersectsWith(ballRect);
    }
}

这样既满足了“接口统一处理”的要求，又用抽象类复用了通用代码，避免了无效继承。

内容的提问来源于stack exchange，提问作者Darke