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");
}