BufferedGraphics

.NET Framework クラス ライブラリ リファレンス

BufferedGraphics クラス

メモ : このクラスは、.NET Framework version 2.0 で新しく追加されたものです。

ダブル バッファリングのためのグラフィックス バッファを提供します。

名前空間: System.Drawing
アセンブリ: System.Drawing (system.drawing.dll 内)
構文

Visual Basic (宣言)

Public NotInheritable Class
 BufferedGraphics
    Implements IDisposable

Visual Basic (使用法)

Dim instance As BufferedGraphics

C#

public sealed class BufferedGraphics : IDisposable

C++

public ref class BufferedGraphics sealed :
 IDisposable

J#

public final class BufferedGraphics implements
 IDisposable

JScript

public final class BufferedGraphics implements
 IDisposable

解説

BufferedGraphics クラスでは、グラフィックスのカスタム ダブル バッファリングを実装できます。このクラスは、グラフィックス バッファのラッパーと、バッファに書き込みを行ったりその内容を出力デバイスに描画したりするために使用できるメソッドを提供します。

グラフィックスでダブル バッファリングを使用すると、表示面の再描画によって引き起こされるちらつきを低減または除去できます。ダブル バッファリングを使用した場合、更新されたグラフィックスが最初にメモリ内のバッファに描画された後、このバッファの内容が表示面の一部または全部にすばやく書き込まれます。このような表示グラフィックスの比較的簡単な上書きを行うことにより、グラフィックスが更新されるときに発生しやすいちらつきを低減または除去できます。

メモ
ダブル バッファリングを使用する簡単な方法は、SetStyle メソッドを使用して、コントロールの OptimizedDoubleBuffer コントロール スタイル フラグを設定することです。コントロールの OptimizedDoubleBuffer フラグを設定すると、コードを追加することなしに、そのコントロールに関するすべての描画が既定のグラフィックス バッファにリダイレクトされます。既定では、このフラグは true に設定されています。

BufferedGraphics クラスはパブリック コンストラクタを持たず、アプリケーション ドメインの BufferedGraphicsContext によって Allocate メソッドを使用して作成される必要があります。静的 BufferedGraphicsManager.Current プロパティから現在のアプリケーション ドメインの BufferedGraphicsContext を取得できます。

Graphics プロパティは、グラフィックス バッファへの描画を行うために使用できます。このプロパティにより、この BufferedGraphics オブジェクトに対して割り当てられているグラフィックス バッファに対して描画を行う Graphics オブジェクトへアクセスできます。

Render メソッドに引数が指定されない場合、グラフィックス バッファの内容は、バッファの割り当て時に指定された面に描画されます。Render メソッドの他のオーバーロードでは、Graphics オブジェクトを指定したり、グラフィックス バッファの内容を描画するデバイス コンテキストを指す IntPtr オブジェクトを指定したりできます。

ダブル バッファリングが使用されたグラフィックスの描画の詳細については、「ダブル バッファリングされたグラフィックス」を参照してください。

使用例

BufferedGraphics オブジェクトでいくつかの種類のバッファリング実装を使用してグラフィックスを描画する方法を次のコード例に示します。フォームをクリックすると、描画の更新を引き起こすタイマの起動と停止が切り替わります。描画の更新が行われると、ダブル バッファリングの効果を確認できます。フォームを右クリックすると、次の描画モードが順に切り替わります。

• Form の Handle への直接的な描画。

• OptimizedDoubleBuffer コントロール スタイルを使用した OnPaint メソッドをオーバーライドすることによる描画。

• OptimizedDoubleBuffer コントロール スタイルを使用せずにフォーム メソッドの OnPaint メソッドをオーバーライドすることによる描画。

それぞれのモードでは、現在のモードを識別し、それぞれのマウス ボタンが押されたときに発生する動作を説明するテキストが描画されます。

Visual Basic

Imports System
Imports System.ComponentModel
Imports System.Drawing
Imports System.Windows.Forms

Public Class BufferingExample
    Inherits Form
    Private context As BufferedGraphicsContext
    Private grafx As BufferedGraphics
    
    Private bufferingMode As Byte
    Private bufferingModeStrings As String()
 = _
        {"Draw to Form without OptimizedDoubleBufferring control
 style", _
         "Draw to Form using OptimizedDoubleBuffering control
 style", _
         "Draw to HDC for form"}
    
    Private timer1 As System.Windows.Forms.Timer
    Private count As Byte
    
    
    Public Sub New()
        ' Configure the Form for this example.
        Me.Text = "User double buffering"
        AddHandler Me.MouseDown, AddressOf
 Me.MouseDownHandler
        AddHandler Me.Resize, AddressOf
 Me.ResizeHandler
        Me.SetStyle(ControlStyles.AllPaintingInWmPaint Or
 ControlStyles.UserPaint, True)
        
        ' Configure a timer to draw graphics updates.
        timer1 = New System.Windows.Forms.Timer()
        timer1.Interval = 200
        AddHandler timer1.Tick, AddressOf Me.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(Me.Width
 + 1, Me.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(Me.CreateGraphics(), _
            New Rectangle(0, 0, Me.Width, Me.Height))
        
        ' Draw the first frame to the buffer.
        DrawToBuffer(grafx.Graphics)
    End Sub    
    
    Private Sub MouseDownHandler(sender As
 Object, e As MouseEventArgs)
        If e.Button = MouseButtons.Right Then
            ' Cycle the buffering mode.
            bufferingMode = bufferingMode+1
            If bufferingMode > 2 Then
                bufferingMode = 0
            End If 
            ' If the previous buffering mode used 
            ' the OptimizedDoubleBuffering ControlStyle,
            ' disable the control style.
            If bufferingMode = 1 Then
                Me.SetStyle(ControlStyles.OptimizedDoubleBuffer,
 True)
            End If 
            ' If the current buffering mode uses
            ' the OptimizedDoubleBuffering ControlStyle,
            ' enabke the control style.
            If bufferingMode = 2 Then
                Me.SetStyle(ControlStyles.OptimizedDoubleBuffer,
 False)
            End If 
            ' Cause the background to be cleared and redraw.
            count = 6
            DrawToBuffer(grafx.Graphics)
            Me.Refresh()
        Else
            ' Toggle whether the redraw timer is active.
            If timer1.Enabled Then
                timer1.Stop()
            Else
                timer1.Start()
            End If
        End If
    End Sub
     
    Private Sub OnTimer(sender As
 Object, e As EventArgs)
        ' Draw randomly positioned ellipses to the buffer.
        DrawToBuffer(grafx.Graphics)
        
        ' If in bufferingMode 2, draw to the form's HDC.
        If bufferingMode = 2 Then
            ' Render the graphics buffer to the form's HDC.
            grafx.Render(Graphics.FromHwnd(Me.Handle))
        ' If in bufferingMode 0 or 1, draw in the paint method.
        Else
            Me.Refresh()
        End If
    End Sub
     
    Private Sub ResizeHandler(sender As
 Object, e As EventArgs)
        ' Re-create the graphics buffer for a new window size.
        context.MaximumBuffer = New Size(Me.Width
 + 1, Me.Height + 1)
        If Not (grafx Is
 Nothing) Then
            grafx.Dispose()
            grafx = Nothing
        End If
        grafx = context.Allocate(Me.CreateGraphics(), New
 Rectangle(0, 0, Me.Width, Me.Height))
        
        ' Cause the background to be cleared and redraw.
        count = 6
        DrawToBuffer(grafx.Graphics)
        Me.Refresh()
    End Sub    
    
    Private Sub DrawToBuffer(g As
 Graphics)
        ' Clear the graphics buffer every five updates.
        count = count+1
        If count > 5 Then
            count = 0
            grafx.Graphics.FillRectangle(Brushes.Black, 0, 0, Me.Width,
 Me.Height)
        End If
        
        ' Draw randomly positioned and colored ellipses.
        Dim rnd As New Random()
        Dim i As Integer
        For i = 0 To 21
            Dim px As Integer
 = rnd.Next(20, Me.Width - 40)
            Dim py As Integer
 = rnd.Next(20, Me.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, Me.Width
 - px - 20), _
                py + rnd.Next(0, Me.Height - py - 20))
        Next i
        
        ' 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)
    End Sub    
    
    Protected Overrides Sub
 OnPaint(e As PaintEventArgs)
        grafx.Render(e.Graphics)
    End Sub   
    
    <STAThread()>  _
    Public Shared Sub Main(args()
 As String)
        Application.Run(New BufferingExample())
    End Sub

End Class

C#

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

C++

#using <System.Windows.Forms.dll>
#using <System.Drawing.dll>
#using <System.dll>

using namespace System;
using namespace System::ComponentModel;
using namespace System::Drawing;
using namespace System::Windows::Forms;

namespace BufferingExample
{
   public ref class BufferingExample: public
 Form
   {
   private:
      BufferedGraphicsContext^ context;
      BufferedGraphics^ grafx;
      Byte bufferingMode;
      array<String^>^bufferingModeStrings;
      System::Windows::Forms::Timer^ timer1;
      Byte count;

   public:
      BufferingExample()
         : Form()
      {
         array<String^>^tempStrings = {"Draw to Form without OptimizedDoubleBufferring
 control style","Draw to Form using OptimizedDoubleBuffering
 control style","Draw to HDC for form"};
         bufferingModeStrings = tempStrings;

         // Configure the Form for this example.
         this->Text = "User double buffering";
         this->MouseDown += gcnew MouseEventHandler( this,
 &BufferingExample::MouseDownHandler );
         this->Resize += gcnew EventHandler( this,
 &BufferingExample::OnResize );
         this->SetStyle( static_cast<ControlStyles>(ControlStyles::AllPaintingInWmPaint
 | ControlStyles::UserPaint), true );

         // Configure a timer to draw graphics updates.
         timer1 = gcnew System::Windows::Forms::Timer;
         timer1->Interval = 200;
         timer1->Tick += gcnew EventHandler( this, &BufferingExample::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 = System::Drawing::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(),
 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

         // If in bufferingMode 0 or 1, draw in the paint method.
         this->Refresh();
      }

      void OnResize( Object^ /*sender*/, EventArgs^ /*e*/ )
      {
         // Re-create the graphics buffer for a new window size.
         context->MaximumBuffer = System::Drawing::Size( this->Width
 + 1, this->Height + 1 );
         if ( grafx != nullptr )
         {
            delete grafx;
            grafx = nullptr;
         }

         grafx = context->Allocate( this->CreateGraphics(),
 Rectangle(0,0,this->Width,this->Height)
 );

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

      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 = gcnew 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( gcnew Pen( Color::FromArgb( rnd->Next( 0, 255 ),
 rnd->Next( 0, 255 ), rnd->Next( 0, 255 ) ), 1.0f ), px, py, px + rnd->Next(
 0, this->Width - px - 20 ), py + rnd->Next( 0, this->Height - py - 20 ) );
         }

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

   protected:
      virtual void OnPaint( PaintEventArgs^ e ) override
      {
         grafx->Render( e->Graphics );
      }
   };
}

[STAThread]
int main()
{
   Application::Run( gcnew BufferingExample::BufferingExample );
}

J#

package BufferingExample; 

import System.*;
import System.ComponentModel.*;
import System.Drawing.*;
import System.Windows.Forms.*;

public class BufferingExample extends Form
{
    private BufferedGraphicsContext context;
    private BufferedGraphics grafx;
    private ubyte 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 ubyte count;

    public BufferingExample()
    {
        super();
        // Configure the Form for this example.
        this.set_Text("User double buffering");
        this.add_MouseDown(new MouseEventHandler(this.MouseDownHandler));
        this.add_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.set_Interval(200);
        timer1.add_Tick(new EventHandler(this.OnTimer));
        bufferingMode = 2;
        count = 0;
        // Retrieves the BufferedGraphicsContext for the 
        // current application domain.
        context = BufferedGraphicsManager.get_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.set_MaximumBuffer(new Size(this.get_Width()
 + 1, this.get_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.get_Width(), this.get_Height()));
        // Draw the first frame to the buffer.
        DrawToBuffer(grafx.get_Graphics());
    } //BufferingExample

    public void MouseDownHandler(Object sender,
 MouseEventArgs e)
    {
        if (e.get_Button().Equals(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.get_Graphics());
            this.Refresh();
        }
        else {
            // Toggle whether the redraw timer is active.
            if (timer1.get_Enabled()) {
                timer1.Stop();
            }
            else {
                timer1.Start();
            }
        }
    } //MouseDownHandler

    private void OnTimer(Object sender, EventArgs
 e)
    {
        // Draw randomly positioned ellipses to the buffer.
        DrawToBuffer(grafx.get_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(this.get_Handle());
        }
        // If in bufferingMode 0 or 1, draw in the paint method.
        else {
            this.Refresh();
        }
    } //OnTimer

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

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

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

        // Draw randomly positioned and colored ellipses.
        Random rnd = new Random();
        for (int i = 0; i < 20; i++) {
            int px = rnd.Next(20, this.get_Width()
 - 40);
            int py = rnd.Next(20, this.get_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.get_Width() - px - 20),
 
                py + rnd.Next(0, this.get_Height() - py - 20));
        }

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

    protected void OnPaint(PaintEventArgs e)
    {
        grafx.Render(e.get_Graphics());
    } //OnPaint

    /** @attribute STAThread()
     */
    public static void main(String[]
 args)
    {
        Application.Run(new BufferingExample());
    } //main
} //BufferingExample

継承階層

System.Object
  System.Drawing.BufferedGraphics

スレッド セーフ

BufferedGraphics クラスはスレッド セーフではありません。異なるスレッドからグラフィックス バッファにアクセスする場合は、スレッド アクセス制御機構を使用して競合を回避することが重要です。

プラットフォーム

Windows 98, Windows 2000 SP4, Windows Millennium Edition, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

開発プラットフォームの中には、.NET Framework によってサポートされていないバージョンがあります。サポートされているバージョンについては、「システム要件」を参照してください。

バージョン情報

.NET Framework
サポート対象 : 2.0

参照

関連項目
BufferedGraphics メンバ
System.Drawing 名前空間
その他の技術情報
ダブル バッファリングされたグラフィックス

BufferedGraphics プロパティ

パブリック プロパティ

	名前	説明
	Graphics	グラフィックス バッファに出力する Graphics オブジェクトを取得します。

参照

関連項目

BufferedGraphics クラス
System.Drawing 名前空間

その他の技術情報

ダブル バッファリングされたグラフィックス

BufferedGraphics メソッド

パブリック メソッド

( プロテクト メソッド も参照)

	名前	説明
	Dispose	この BufferedGraphics オブジェクトによって使用されているすべてのリソースを解放します。
	Equals	オーバーロードされます。 2 つの Object インスタンスが等しいかどうかを判断します。 ( Object から継承されます。)
	GetHashCode	特定の型のハッシュ関数として機能します。GetHashCode は、ハッシュ アルゴリズムや、ハッシュ テーブルのようなデータ構造での使用に適しています。 ( Object から継承されます。)
	GetType	現在のインスタンスの Type を取得します。 ( Object から継承されます。)
	ReferenceEquals	指定した複数の Object インスタンスが同一かどうかを判断します。 ( Object から継承されます。)
	Render	オーバーロードされます。 グラフィックス バッファの内容を書き込みます。
	ToString	現在の Object を表す String を返します。 ( Object から継承されます。)

プロテクト メソッド

	名前	説明
	Finalize	Object がガベージ コレクションにより収集される前に、その Object がリソースを解放し、その他のクリーンアップ操作を実行できるようにします。 ( Object から継承されます。)
	MemberwiseClone	現在の Object の簡易コピーを作成します。 ( Object から継承されます。)

参照

関連項目

BufferedGraphics クラス
System.Drawing 名前空間

その他の技術情報

ダブル バッファリングされたグラフィックス

BufferedGraphics メンバ

ダブル バッファリングのためのグラフィックス バッファを提供します。

BufferedGraphics データ型で公開されるメンバを以下の表に示します。

パブリック プロパティ

	名前	説明
	Graphics	グラフィックス バッファに出力する Graphics オブジェクトを取得します。

パブリック メソッド

( プロテクト メソッド も参照)

	名前	説明
	Dispose	この BufferedGraphics オブジェクトによって使用されているすべてのリソースを解放します。
	Equals	オーバーロードされます。 2 つの Object インスタンスが等しいかどうかを判断します。 (Object から継承されます。)
	GetHashCode	特定の型のハッシュ関数として機能します。GetHashCode は、ハッシュ アルゴリズムや、ハッシュ テーブルのようなデータ構造での使用に適しています。 (Object から継承されます。)
	GetType	現在のインスタンスの Type を取得します。 (Object から継承されます。)
	ReferenceEquals	指定した複数の Object インスタンスが同一かどうかを判断します。 (Object から継承されます。)
	Render	オーバーロードされます。 グラフィックス バッファの内容を書き込みます。
	ToString	現在の Object を表す String を返します。 (Object から継承されます。)

プロテクト メソッド

	名前	説明
	Finalize	Object がガベージ コレクションにより収集される前に、その Object がリソースを解放し、その他のクリーンアップ操作を実行できるようにします。 (Object から継承されます。)
	MemberwiseClone	現在の Object の簡易コピーを作成します。 (Object から継承されます。)

参照

関連項目

BufferedGraphics クラス
System.Drawing 名前空間

その他の技術情報

ダブル バッファリングされたグラフィックス