Exportar (0) Imprimir
Expandir Tudo
Este artigo foi traduzido por máquina. Coloque o ponteiro do mouse sobre as frases do artigo para ver o texto original. Mais informações.
Tradução
Original

Classe BufferedGraphics

Fornece um buffer de elementos gráficos para bufferização dupla.

System.Object
  System.Drawing.BufferedGraphics

Namespace:  System.Drawing
Assembly:  System.Drawing (em System.Drawing.dll)

public sealed class BufferedGraphics : IDisposable

O tipo BufferedGraphics expõe os membros a seguir.

  NomeDescrição
Propriedade públicaGraphicsObtém um Graphics o objeto que gera a saída para o buffer de elementos gráficos.
Superior

  NomeDescrição
Método públicoDisposeLibera todos os recursos usados pela BufferedGraphics objeto.
Método públicoEquals(Object) Verifica se o objeto especificado é igual ao objeto atual. (Herdado de Object.)
Método públicoGetHashCodeServe como a função de hash padrão. (Herdado de Object.)
Método públicoGetType Obtém o Type da instância atual. (Herdado de Object.)
Método públicoRender()Grava o conteúdo do buffer de elementos gráficos para o dispositivo padrão.
Método públicoRender(Graphics)Grava o conteúdo do buffer de gráficos especificado Graphics objeto.
Método públicoRender(IntPtr)Grava o conteúdo do buffer de elementos gráficos para o contexto para dispositivo associado ao IntPtr manipular.
Método públicoToStringRetorna uma string que representa o objeto atual. (Herdado de Object.)
Superior

O BufferedGraphics classe permite que você implemente o buffer duplo personalizado para os elementos gráficos. Ele fornece um wrapper para um buffer de elementos gráficos, juntamente com métodos que você pode usar para gravar o buffer e processar seu conteúdo para um dispositivo de saída.

Elementos gráficos que usam buffer duplo podem reduzir ou eliminar a cintilação que é causada por redesenho uma superfície de exibição. Quando você usa o buffer duplo, gráficos atualizados primeiro são desenhados em um buffer na memória e o conteúdo desse buffer rapidamente, em seguida, é gravado para alguns ou todos da superfície exibida. Essa substituição relativamente breve dos elementos gráficos exibidos normalmente reduz ou elimina a cintilação que às vezes, ocorre quando os elementos gráficos são atualizados.

ObservaçãoObservação

A maneira mais simples usar buffer duplo é definir o OptimizedDoubleBuffer controlar o sinalizador de estilo em um controle usando o SetStyle método. Definindo a OptimizedDoubleBuffer sinalizar para um controle redireciona todas as pintura para o controle por meio de um buffer de elementos gráficos padrão, sem exigir qualquer código adicional. Este sinalizador estiver definido como true por padrão.

O BufferedGraphics classe não tem nenhum construtor público e deve ser criada pela BufferedGraphicsContext para um domínio de aplicativo usando o seu Allocate método. Você pode recuperar o BufferedGraphicsContext para o domínio de aplicativo atual pelo pool de BufferedGraphicsManager.Current propriedade.

O Graphics propriedade pode ser usada para o desenho para o buffer de elementos gráficos. Essa propriedade fornece acesso para o Graphics que leva para gráficos buffer alocado para este objeto BufferedGraphics objeto.

O Render método com desenha sem argumentos de buffer o conteúdo dos elementos gráficos para a superfície especificada quando o buffer foi alocado. Outras sobrecargas da Render método permitem que você especifique um Graphics objeto ou um IntPtr objeto que aponta para um contexto de dispositivo para o qual desenhar o conteúdo do buffer de elementos gráficos.

Para obter mais informações sobre desenho gráficos buffer duplo, consulte Elementos gráficos em buffer duplo.

O exemplo de código a seguir demonstra o uso de um BufferedGraphics o objeto para desenhar gráficos usando diversos tipos de implementações de armazenamento em buffer. Como alternativa clicando no formulário inicia e pára um temporizador que faz com que desenha as atualizações. As atualizações do draw permitem que você observar o efeito do buffer duplo. Clicando com o botão direito os ciclos de formulário através dos seguintes modos de desenho:

Em cada modo, o texto é desenhado que identifica o modo atual e descreve o comportamento que ocorre quando cada botão do mouse é pressionado.


using System;
using System.ComponentModel;
using System.Drawing;
using System.Windows.Forms;

namespace BufferingExample 
{
    public class BufferingExample : Form
    {
        private BufferedGraphicsContext context;
        private BufferedGraphics grafx;

	private byte bufferingMode;
	private string[] bufferingModeStrings = 
		{ "Draw to Form without OptimizedDoubleBufferring control style",
		  "Draw to Form using OptimizedDoubleBuffering control style",
		  "Draw to HDC for form" };

	private System.Windows.Forms.Timer timer1;
	private byte count;

        public BufferingExample() : base()
        {
            // Configure the Form for this example.
            this.Text = "User double buffering";
            this.MouseDown += new MouseEventHandler(this.MouseDownHandler);
            this.Resize += new EventHandler(this.OnResize);
            this.SetStyle( ControlStyles.AllPaintingInWmPaint | ControlStyles.UserPaint, true );

            // Configure a timer to draw graphics updates.
	    timer1 = new System.Windows.Forms.Timer();
	    timer1.Interval = 200;
	    timer1.Tick += new EventHandler(this.OnTimer);

	    bufferingMode = 2;
	    count = 0;

            // Retrieves the BufferedGraphicsContext for the 
            // current application domain.
            context = BufferedGraphicsManager.Current;

            // Sets the maximum size for the primary graphics buffer
            // of the buffered graphics context for the application
            // domain.  Any allocation requests for a buffer larger 
            // than this will create a temporary buffered graphics 
            // context to host the graphics buffer.
            context.MaximumBuffer = new Size(this.Width+1, this.Height+1);

            // Allocates a graphics buffer the size of this form
            // using the pixel format of the Graphics created by 
            // the Form.CreateGraphics() method, which returns a 
            // Graphics object that matches the pixel format of the form.
            grafx = context.Allocate(this.CreateGraphics(), 
                 new Rectangle( 0, 0, this.Width, this.Height ));

	    // Draw the first frame to the buffer.
	    DrawToBuffer(grafx.Graphics);
        }

	private void MouseDownHandler(object sender, MouseEventArgs e)
        {
	    if( e.Button == MouseButtons.Right )
	    {
                 // Cycle the buffering mode.
	         if( ++bufferingMode > 2 )
                     bufferingMode = 0;

                 // If the previous buffering mode used 
                 // the OptimizedDoubleBuffering ControlStyle,
                 // disable the control style.
                 if( bufferingMode == 1 )
                     this.SetStyle( ControlStyles.OptimizedDoubleBuffer, true );

                 // If the current buffering mode uses
                 // the OptimizedDoubleBuffering ControlStyle,
                 // enabke the control style.
                 if( bufferingMode == 2 )
                     this.SetStyle( ControlStyles.OptimizedDoubleBuffer, false );

                 // Cause the background to be cleared and redraw.
                 count = 6;
    	         DrawToBuffer(grafx.Graphics);                 
		 this.Refresh();
	    }
	    else
	    {
                // Toggle whether the redraw timer is active.
		if( timer1.Enabled )
			timer1.Stop();
		else
			timer1.Start(); 
	    }
        }

	private void OnTimer(object sender, EventArgs e)
	{
            // Draw randomly positioned ellipses to the buffer.
	    DrawToBuffer(grafx.Graphics);

            // If in bufferingMode 2, draw to the form's HDC.
	    if( bufferingMode == 2 )            
                    // Render the graphics buffer to the form's HDC.
		    grafx.Render(Graphics.FromHwnd(this.Handle));            
            // If in bufferingMode 0 or 1, draw in the paint method.
	    else
  		    this.Refresh();
	}

        private void OnResize(object sender, EventArgs e)
        {
           // Re-create the graphics buffer for a new window size.
           context.MaximumBuffer = new Size(this.Width+1, this.Height+1);
           if( grafx != null )
           {
	       grafx.Dispose();
               grafx = null;               
           }
           grafx = context.Allocate(this.CreateGraphics(), 
               new Rectangle( 0, 0, this.Width, this.Height ));

           // Cause the background to be cleared and redraw.
           count = 6;
    	   DrawToBuffer(grafx.Graphics);                 
	   this.Refresh();
        }	

	private void DrawToBuffer(Graphics g)
	{
            // Clear the graphics buffer every five updates.
	    if( ++count > 5 )
            {
                count = 0;                
                grafx.Graphics.FillRectangle(Brushes.Black, 0, 0, this.Width, this.Height);
            }

            // Draw randomly positioned and colored ellipses.
	    Random rnd = new Random();
	    for( int i=0; i<20; i++ )
	    {
		int px = rnd.Next(20,this.Width-40);
		int py = rnd.Next(20,this.Height-40);
		g.DrawEllipse(new Pen(Color.FromArgb(rnd.Next(0, 255), rnd.Next(0,255), rnd.Next(0,255)), 1), 
			px, py, px+rnd.Next(0, this.Width-px-20), py+rnd.Next(0, this.Height-py-20)); 	    			
	    }

            // Draw information strings.
	    g.DrawString("Buffering Mode: "+bufferingModeStrings[bufferingMode], new Font("Arial", 8), Brushes.White, 10, 10);
            g.DrawString("Right-click to cycle buffering mode", new Font("Arial", 8), Brushes.White, 10, 22);
            g.DrawString("Left-click to toggle timed display refresh", new Font("Arial", 8), Brushes.White, 10, 34);
	}

	protected override void OnPaint(PaintEventArgs e)
        {            
	    grafx.Render(e.Graphics);
	}

        [STAThread]
        public static void Main(string[] args)
        {
	    Application.Run(new BufferingExample());
        }
    }
}


.NET Framework

Com suporte em: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Com suporte em: 4, 3.5 SP1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (Função Server Core sem suporte), Windows Server 2008 R2 (Função Server Core com suporte com o SP1 ou posterior, Itanium sem suporte)

O .NET Framework não oferece suporte a todas as versões de cada plataforma. Para obter uma lista das versões com suporte, consulte Requisitos do sistema do .NET Framework.

O BufferedGraphics classe não é thread-safe. Ao acessar um buffer de elementos gráficos de threads separados, é importante usar um mecanismo de controle de acesso do segmento para evitar conflitos.

Contribuições da comunidade

ADICIONAR
Mostrar:
© 2014 Microsoft