The most common approach to obtaining an instance of System.Drawing.Graphics is to override the Control.OnPaint event handler, which is invoked when a control should repaint itself. The following example demonstrates this approach:

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

public class SimpleForm :Form {

    static void Main() {
        Application.Run(new SimpleForm());
    }

    // Other methods, such as Dispose and a default
    // constructor, would go here.

    protected override void OnPaint(PaintEventArgs p_event) {
        Graphics x_graph = p_event.Graphics;
        // drawing operations
    }
}

The Graphics property of the PaintEventArgs class returns the System.Drawing.Graphics instance for the current control, to which GDI+ operations can be applied. The Paint event is raised automatically when a component should be redrawn or manually by calling the Control.RaisePaintEvent method.

Instances of System.Drawing.Graphics can also be obtained by calling the Control.CreateGraphics method. Drawing operations applied to the Graphics instance that is returned from this method take effect immediately, as opposed to waiting for the component to be repainted.

Unlike Java, the GDI+ Graphics class doesn’t maintain state information for drawing operations. For example, the Java java.awt.Graphics.setColor method specifies a color that will be used for subsequent drawing operations; specifying Color.Red means that all shapes and lines will be drawn in red until the color is changed.

By contrast, the .NET GDI+ classes require the programmer to specify the color settings as part of each draw method. The System.Drawing.Brush class is used to specify fill settings for solid shapes and the System.Drawing.Pen class to specify line settings.

The Brush class is abstract, and drawing operations are performed using a concrete implementation. Table 18-4 describes the brush implementations included in the .NET Framework.

The following example demonstrates how to use a SolidBrush to fill a rectangle. The SolidBrush constructor accepts a value from the System.Drawing.Color structure, which is equivalent to the java.awt.Color class:

Graphics x_graphics = CreateGraphics();
Brush x_brush = new SolidBrush(Color.Red);
x_graphics.FillRectangle(x_brush, 10, 10, 50, 50);

The sealed System.Drawing.Pen class is used to specify properties for drawing lines and shapes. The constructor for the class accepts a Color value and an optional line width; the width defaults to 1 pixel if not specified. The following code fragment demonstrates how to use a Pen to draw a line:

Graphics x_graphics = CreateGraphics();
Pen x_pen = new Pen(Color.Green, 2);
x_graphics.DrawLine(x_pen, 10, 10, 50, 50);

The System.Drawing.Pens class contains properties that can be used to obtain Pen instances for all of the colors specified in the System.Drawing.Color structure; each of the instances has a width of 1 pixel. The statements in the following code fragment are equivalent:

Pen x_pen = new Pen(Color.Green, 1);
Pen x_pen = Pens.Green;

The Pen class defines members that allow a great deal of control over how a line is drawn. Table 18-5 summarizes these members; consult the .NET documentation for more information.

Table 18-6 summarizes the members in the java.awt.Graphics and System.Drawing.Graphics2D classes used for drawing lines, shapes and curves.

The GDI+ approach to drawing text follows a model similar to that of the support for lines and shapes. The System.Drawing.Graphics class doesn’t maintain state information for font or color, so settings must be passed into the drawing method using the Font and Brush classes with each call. The following example demonstrates how to draw a string using the Graphics.DrawString method, which is functionally equivalent to the java.awt.Graphics.drawString method:

Graphics x_graphics = CreateGraphics();

String x_string = "C# for Java Developers";
Font x_font = new Font("TimesRoman", 14);
SolidBrush x_brush = new SolidBrush(Color.Green);

StringFormat x_format = new StringFormat();
x_format.FormatFlags = StringFormatFlags.DirectionVertical;

x_graphics.DrawString(x_string, x_font, x_brush, 10.0F, 20.0F, x_format);

Table 18-7 details the arguments supplied to the Graphics.DrawString method.

The GDI+ managed classes support images through the abstract System.Drawing.Image class, equivalent to java.awt.Image. The .NET Framework provides two concrete implementations of the Image class, System.Drawing.Bitmap and System.Drawing.Imaging.Metafile.

The Bitmap class is responsible for managing bitmap images. GDI+ supports the following formats:

The Metafile class is responsible for vector images, which are represented by a sequence of drawing commands. The Metafile class supports the following formats:

An image can be loaded from a file either by using the constructors of the Bitmap or Metafile class or by using the static FromFile method in the Image class.

Images are drawn onto a Graphics instance using the DrawImage method; this method provides extensive support for scaling and cropping images by providing 30 different overloaded forms. Consult the .NET documentation for details of these members.

The following example demonstrates loading and painting a bitmap, which is contained in the current working directory:

Graphics x_graphics = CreateGraphics();
Bitmap x_bitmap = new Bitmap("myImage.jpg");
x_graphics.DrawImage(x_bitmap, 0, 0);

GDI+ causes the Graphics class to update the screen after every drawing operation, which can be seen by the user as screen flicker; this flickering can be eliminated by a technique known as double buffering, whereby the drawing operations are applied to a Graphics instance held in memory and then copied to the screen in a single operation.

Double buffering can be enabled by using the SetStyle method from the System.Windows.Forms.Control class; this method accepts an argument from the System.Windows.Forms.ControlStyles enumeration, as shown in the following code fragment:

SetStyle(ControlStyles.DoubleBuffer, true);

Flickering can also occur because the contents of a Graphics instance are cleared automatically before a component is asked to repaint itself. This feature can be disabled by specifying the ControlStyles.UserPaint and ControlSyles.AllPaintingInWmPaint values in the SetStyle method. The following statement demonstrates how to completely eliminate flicker:

SetStyle(ControlStyles.DoubleBuffer |
    ControlStyles.UserPaint |
    ControlStyles.AllPaintingInWmPaint, true);

Double buffering can also be performed programmatically by executing drawing operations on an in-memory bitmap, as shown in the following example:

protected override void OnPaint(PaintEventArgs p_event) {
    Bitmap x_bitmap = new Bitmap(Width, Height);
    Graphics x_offscreen = Graphics.FromImage(x_bitmap);
    // drawing operations

    p_event.Graphics.DrawImage(x_bitmap, 0, 0);
    x_bitmap.Dispose();
}

The Bitmap instance is created by specifying the dimensions of the area to draw; in the example, we use the Width and Height properties from the Control class. The off-screen Graphics instance is retrieved from the Bitmap, and the drawing operations are then applied without causing the screen to be updated. Finally, the contents of the Bitmap are drawn to the screen using the Graphics.DrawImage method; it’s important to ensure that the Dispose method is called on the Bitmap to ensure that unmanaged resources are released.

The flicker caused by the automatic clearing of the contents of a specific component can be prevented by overriding the Control.OnPaintBackground method and providing an empty method body.