浅谈C#中的双缓冲

￡神魔★判官ぃ 2022-08-03 03:11 191阅读 0赞

在编程当中，或多或少会接触到图像编程，对于图像编程来说窗口闪烁是个常见的问题，当窗口有大量的复杂的图元数据需要重绘，或者拥有自定义控件中的窗口闪烁问题更是显而易见的。出现闪烁的原因有很多种，大部分原因主要是因为触发WM\_PAINT消息时窗体进行了重绘操作，此过程先是用窗体的背景色擦除窗口表面，再把窗体的图像绘制上去，但是如果这2个操作不在同一时间段完成的话，就会先看到背景色（大部分为白色）接着才看到图像，这样就会出现我们所说的窗体闪烁现象。那么如何解决这个问题呢，解决方法有很多，其中有个比较好的方法（个人认为）就是采用双缓冲机制来绘图，基本上可以解决大部分的问题。

双缓冲的原理：尽量快的输出图像，使输出在一个刷新周期内完成，如果输出内容很多比较慢，那么采用内存缓冲的方法，先把要输出的内容在内存准备好，然后一次性输出到窗体上，简单的说来就是在窗口刷新一次的过程中，让所有图元同时显示到窗口中。

在C\#中 .Net Framework为编程人员提供了很好的操作双缓冲的方法，为采用双缓冲机制绘制比较复杂的图像数据带来便捷。下面简单的介绍在C\#中实现双缓冲的几种方法。

** 一：利用默认的双缓冲**

（1）在应用程序中使用双缓冲的最简便的方法是使用 .NET Framework 为窗体和控件提供的默认双缓冲。通过将 DoubleBuffered 属性设置为 true。

**\[csharp\]** [ view plain][view plain] [copy][view plain] [print][view plain] [?][view plain]

1.  this.DoubleBuffered=true;

this.DoubleBuffered=true;

（2）使用 SetStyle 方法可以为 Windows 窗体和所创作的 Windows 控件启用默认双缓冲，在窗体或者控件的构造函数中添加如下代码即可：

**\[csharp\]** [ view plain][view plain] [copy][view plain] [print][view plain] [?][view plain]

1.  SetStyle(ControlStyles.ResizeRedraw,true);  
2.  SetStyle(ControlStyles.OptimizedDoubleBuffer,true);  
3.  SetStyle(ControlStyles.AllPaintingInWmPaint,true);

SetStyle(ControlStyles.ResizeRedraw,true);
         SetStyle(ControlStyles.OptimizedDoubleBuffer,true);
         SetStyle(ControlStyles.AllPaintingInWmPaint,true);

或者：

**\[csharp\]** [ view plain][view plain] [copy][view plain] [print][view plain] [?][view plain]

1.  this.SetStyle(ControlStyles.ResizeRedraw |  
2.                ControlStyles.OptimizedDoubleBuffer |  
3.                ControlStyles.AllPaintingInWmPaint, true);  
4.  this.UpdateStyles();

this.SetStyle(ControlStyles.ResizeRedraw |
                       ControlStyles.OptimizedDoubleBuffer |
                       ControlStyles.AllPaintingInWmPaint, true);
         this.UpdateStyles();

注：

.net1.1 和 .net 2.0 在处理控件双缓冲上是有区别的。

.net 1.1 中，使用：this.SetStyle(ControlStyles.DoubleBuffer, true);

.net 2.0中，使用：this.SetStyle(ControlStyles.OptimizedDoubleBuffer, true);

** 二：手动管理双缓冲**

在C\# 中手动管理缓冲图像有2中方法，一种是利用单独开辟内存实现双缓冲这种传统的方法，还有一种是利用 .Net Framework 中独有的BufferedGraphicsContext类实现。

方法一： 自己开辟一个缓冲区（如一个不显示的Bitmap对象），在其中绘制完成后，再一次性显示，代码如下：

**\[csharp\]** [ view plain][view plain] [copy][view plain] [print][view plain] [?][view plain]

1.  //1、在内存中建立一块“虚拟画布”   
2.    Bitmap bmp = new Bitmap(200,200);  
3.    
4.  //2、获取这块内存画布的Graphics引用   
5.    Graphics bufferGraphics = Graphics.FromImage(bmp);  
6.    
7.  //3、在这块内存画布上绘图   
8.    bufferGraphics.Clear(this.BackColor);  
9.  bufferGraphics.DrawRectangle(Pens.Black,0,0,bmp.Width -1,bmp.Height -1);  
10. bufferGraphics.DrawEllipse(Pens.Red,10,10,100,50);  
11. bufferGraphics.DrawLine(Pens.Green,10,100,100,200);  
12.   
13. //4、将内存画布画到窗口中   
14.   using(Graphics g = e.Graphics)  
15.   \{  
16.       g.DrawImage(bmp, 10, 10);  
17.   \}  
18.     
19. //5. 释放资源   
20.   bmp.Dispose();  
21. bufferGraphics.Dispose();

//1、在内存中建立一块“虚拟画布”
                Bitmap bmp = new Bitmap(200,200);
    
              //2、获取这块内存画布的Graphics引用
                Graphics bufferGraphics = Graphics.FromImage(bmp);
    
              //3、在这块内存画布上绘图
                bufferGraphics.Clear(this.BackColor);
              bufferGraphics.DrawRectangle(Pens.Black,0,0,bmp.Width -1,bmp.Height -1);
              bufferGraphics.DrawEllipse(Pens.Red,10,10,100,50);
              bufferGraphics.DrawLine(Pens.Green,10,100,100,200);
    
              //4、将内存画布画到窗口中
                using(Graphics g = e.Graphics)
                {
                    g.DrawImage(bmp, 10, 10);
                }
                
              //5. 释放资源
                bmp.Dispose();
              bufferGraphics.Dispose();

方法二：

对于更高级的双缓存情形，可以使用 .NET Framework 类实现自己的双缓存逻辑。负责单独分配和管理图形缓冲区的类是BufferedGraphicsContext 类。每个应用程序都有自己的默认BufferedGraphicsContext 来管理此应用程序的所有默认双缓冲。提供调用Current 可以检索对此实例的引用。通过调用Allocate 方法可以创建与屏幕上的绘图图面关联的BufferedGraphics 类的实例。此方法创建一个与特定呈现图面（如窗体或控件）关联的BufferedGraphics 实例。创建 BufferedGraphics 实例后，可以将图形绘制到由该实例的Graphics 属性表示的缓冲区。 执行所有图形操作后，可通过调用Render 方法将缓冲区的内容复制到屏幕上。 以下代码把方法一实现的效果用此方法来实现：

**\[csharp\]** [ view plain][view plain] [copy][view plain] [print][view plain] [?][view plain]

1.  BufferedGraphicsContext currentContext = BufferedGraphicsManager.Current;  
2.    
3.  BufferedGraphics myBuffer = currentContext.Allocate(e.Graphics,e.ClipRectangle);  
4.    
5.  Graphics g = myBuffer.Graphics;  
6.    
7.  g.Clear(this.BackColor);  
8.  g.DrawRectangle(Pens.Black, 10, 10, 200, 200);  
9.  g.DrawEllipse(Pens.Red, 10, 10, 100, 50);  
10. g.DrawLine(Pens.Green, 10, 100, 100, 200);  
11.   
12. myBuffer.Render(e.Graphics);  //呈现图像至关联的Graphics    
13.   
14. myBuffer.Dispose();  
15. g.Dispose();

BufferedGraphicsContext currentContext = BufferedGraphicsManager.Current;
    
                BufferedGraphics myBuffer = currentContext.Allocate(e.Graphics,e.ClipRectangle);
    
                Graphics g = myBuffer.Graphics;
    
                g.Clear(this.BackColor);
                g.DrawRectangle(Pens.Black, 10, 10, 200, 200);
                g.DrawEllipse(Pens.Red, 10, 10, 100, 50);
                g.DrawLine(Pens.Green, 10, 100, 100, 200);
    
                myBuffer.Render(e.Graphics);  //呈现图像至关联的Graphics
    
                myBuffer.Dispose();
                g.Dispose();

至此，双缓冲问题解决，两种方式的实现效果都一样，笔者私以为第二种方法占有的内存很少，不会出现内存泄露！

以上为网上整理的资料加上笔者自己的陋见，如若有谬误之处还望指正。

[view plain]: http://blog.csdn.net/keep_silence_/article/details/7849880#