C# 中双缓冲区的实现示例

// 没有双缓冲的绘制 - 会闪烁
private void onpaint(object sender, painteventargs e)
{
    // 每次绘制都直接显示在屏幕上
    e.graphics.drawline(pens.red, 0, 0, 100, 100);  // 看到第一条线
    e.graphics.drawrectangle(pens.blue, 10, 10, 50, 50); // 看到矩形出现
    e.graphics.drawellipse(pens.green, 20, 20, 30, 30);  // 看到圆形出现
    // 用户看到的是逐步绘制的过程，产生闪烁
}

// 双缓冲的本质就是有两个图形缓冲区
public class doublebufferessence
{
    // 前台缓冲区 - 当前显示在屏幕上的
    private bitmap frontbuffer;
    
    // 后台缓冲区 - 正在绘制中的
    private bitmap backbuffer;
    
    // 交换方法 - 瞬间切换显示内容
    public void swapbuffers()
    {
        // 把后台缓冲区变成前台显示
        var temp = frontbuffer;
        frontbuffer = backbuffer;
        backbuffer = temp;
    }
}

// 1. 准备阶段 - 创建缓冲区
private void initializedoublebuffering()
{
    // 创建与显示区域同样大小的后台缓冲区
    backbuffer = new bitmap(this.width, this.height);
    backbuffergraphics = graphics.fromimage(backbuffer);
}

// 2. 绘制阶段 - 在后台缓冲区绘制
private void drawtobackbuffer()
{
    // 清空后台缓冲区
    backbuffergraphics.clear(color.white);
    
    // 执行所有绘制操作（用户看不到这个过程）
    for (int i = 0; i < 1000; i++)
    {
        backbuffergraphics.drawrectangle(pens.black, i, i, 50, 50);
    }
    // 此时屏幕上没有任何变化！
}

// 3. 显示阶段 - 瞬间显示完整画面
private void displaybackbuffer()
{
    // 获取屏幕的graphics对象
    using (var screengraphics = this.creategraphics())
    {
        // 一次性将整个后台缓冲区绘制到屏幕
        screengraphics.drawimage(backbuffer, 0, 0);
    }
    // 用户瞬间看到完整画面，没有闪烁！
}

public class smoothpanel : panel
{
    public smoothpanel()
    {
        // 一句话启用双缓冲！
        this.doublebuffered = true;
    }
    
    protected override void onpaint(painteventargs e)
    {
        // 现在所有的绘制操作都自动使用双缓冲
        e.graphics.drawstring("不会闪烁的文字!", 
                            this.font, brushes.black, 10, 10);
        
        // 绘制复杂图形也不会闪烁
        for (int i = 0; i < 500; i++)
        {
            e.graphics.drawellipse(pens.red, i * 2, i * 3, 50, 50);
        }
    }
}

public class manualdoublebuffer : control
{
    private bitmap backbuffer;
    private graphics backbuffergraphics;
    
    public manualdoublebuffer()
    {
        this.sizechanged += onsizechanged;
        createbackbuffer();
    }
    
    private void createbackbuffer()
    {
        // 创建后台缓冲区
        backbuffer?.dispose();
        backbuffergraphics?.dispose();
        
        backbuffer = new bitmap(this.width, this.height);
        backbuffergraphics = graphics.fromimage(backbuffer);
    }
    
    protected override void onpaint(painteventargs e)
    {
        // 1. 在后台缓冲区绘制
        drawscene();
        
        // 2. 一次性显示到屏幕
        e.graphics.drawimage(backbuffer, 0, 0);
    }
    
    private void drawscene()
    {
        // 在后台缓冲区进行所有绘制
        backbuffergraphics.clear(color.lightblue);
        
        // 绘制大量图形也不会闪烁
        for (int x = 0; x < this.width; x += 20)
        {
            for (int y = 0; y < this.height; y += 20)
            {
                backbuffergraphics.drawrectangle(pens.black, x, y, 15, 15);
            }
        }
    }
}

public class smoothanimationform : form
{
    private timer animationtimer;
    private double angle = 0;
    private panel drawingpanel;
    
    public smoothanimationform()
    {
        initializecomponent();
        setupanimation();
    }
    
    private void setupanimation()
    {
        drawingpanel = new panel();
        drawingpanel.doublebuffered = true;  // 关键：启用双缓冲
        drawingpanel.size = new size(400, 400);
        drawingpanel.paint += drawingpanel_paint;
        this.controls.add(drawingpanel);
        
        animationtimer = new timer();
        animationtimer.interval = 16; // 约60帧/秒
        animationtimer.tick += (s, e) => 
        {
            angle += 0.1;
            drawingpanel.invalidate(); // 触发重绘
        };
        animationtimer.start();
    }
    
    private void drawingpanel_paint(object sender, painteventargs e)
    {
        e.graphics.smoothingmode = system.drawing.drawing2d.smoothingmode.antialias;
        e.graphics.clear(color.white);
        
        // 绘制旋转的矩形（因为有双缓冲，所以很平滑）
        using (var brush = new solidbrush(color.fromargb(100, color.red)))
        {
            // 应用旋转变换
            e.graphics.translatetransform(200, 200);
            e.graphics.rotatetransform((float)(angle * 180 / math.pi));
            e.graphics.fillrectangle(brush, -50, -25, 100, 50);
        }
    }
}

// 假设这是屏幕刷新的过程
public class screenrefreshexplanation
{
    // 没有双缓冲的情况：
    public void paintwithoutdoublebuffer(graphics g)
    {
        g.clear(color.white);        // 屏幕变白（闪烁一下）
        g.drawline(...);             // 看到线条出现
        g.drawrectangle(...);        // 看到矩形出现  
        g.drawtext(...);             // 看到文字出现
        // 用户看到的是逐步绘制的过程，产生闪烁感
    }
    
    // 有双缓冲的情况：
    public void paintwithdoublebuffer(graphics screengraphics)
    {
        // 第一步：在内存中创建完整画面
        using (var backbuffer = new bitmap(width, height))
        using (var backgraphics = graphics.fromimage(backbuffer))
        {
            backgraphics.clear(color.white);  // 在内存中清空，用户看不到
            backgraphics.drawline(...);       // 在内存中画线，用户看不到
            backgraphics.drawrectangle(...);  // 在内存中画矩形，用户看不到
            backgraphics.drawtext(...);       // 在内存中写文字，用户看不到
            
            // 第二步：一次性显示完整画面
            screengraphics.drawimage(backbuffer, 0, 0);
            // 用户只看到这一瞬间的完整画面，没有闪烁！
        }
    }
}

// 双缓冲的内存消耗计算
public void calculatememoryusage()
{
    int width = 800;
    int height = 600;
    int bitsperpixel = 32; // 32位颜色
    
    // 每个缓冲区的大小（字节）
    long buffersize = width * height * (bitsperpixel / 8);
    
    // 双缓冲总内存 = 2个缓冲区
    long totalmemory = 2 * buffersize; // 约3.66mb
    
    console.writeline($"双缓冲内存占用: {totalmemory / 1024 / 1024}mb");
}