Home > Articles > Programming > Windows Programming

C# and Graphical User Interfaces

  • Print
  • + Share This
Learn how to use C# to build a graphical user interface (GUI), using the .NET Windows Forms library classes to build the GUI.
This chapter is from the book

This chapter is from the book

In This Chapter

  • Windows
  • Controls
  • N-Tier Architecture
  • Menus

Windows Forms are the Graphical User Interface (GUI) libraries of the Microsoft .NET Frameworks. The Windows Forms library contains most of the graphical controls familiar to GUI programmers. All of the concepts learned in previous chapters are applied when doing GUI programming. Of special significance is the use of events to connect GUI controls, such as buttons, to the code that implements the program's behavior related to that control.

Windows Forms is not included in the proposed Common Language Infrastructure (CLI) submission to European Computer Manufacturers Association (ECMA). However, it is of such importance to development that its coverage is provided here. Specific emphasis is placed on how C# is used to produce GUIs, and the language constructs involved. The same C# language features are likely to be applied to any future GUI library implementations.

Examples in this chapter begin with the basic element of Windows Forms programming: the window. Then there is an introduction to the standard window controls such as buttons and text boxes. The menu, a common element of GUIs, is included.

Windows

The basic element of most GUI programming in Windows Forms is the window. Essentially, everything on a GUI screen—buttons, text boxes, and icons—are windows. Because of this, most of the windows and controls in the Windows Forms package have the same characteristics. For instance, they all have a Text property. How they use the property is up to the specific type of window.

Building a Windows Forms application is easy once a few basic concepts are understood. This section covers some of these concepts and provides a starting point from which to proceed. Listing 16.1 shows a relatively simple Windows Forms application. To compile the code in Listing 16.1, use the command line in Listing 16.2.

Listing 16.1 A Simple Windows Forms Application

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

public class FirstForm : Form
{
  private Container components;
  private Label   howdyLabel;

  public FirstForm()
  {
    InitializeComponent();
  }

  private void InitializeComponent()
  {
    components = new Container ();
    howdyLabel = new Label ();

    howdyLabel.Location = new Point (12, 116);
    howdyLabel.Text   = "Howdy, Partner!";
    howdyLabel.Size   = new Size (267, 40);
    howdyLabel.AutoSize = true;
    howdyLabel.Font   = new Font (
      "Microsoft Sans Serif", 
      26, System.
      Drawing.FontStyle.Bold);
    howdyLabel.TabIndex = 0;
    howdyLabel.Anchor  = AnchorStyles.None;
    howdyLabel.TextAlign = ContentAlignment.MiddleCenter;

    Text = "First Form";
    Controls.Add (howdyLabel);
  }

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

Listing 16.2 Command Line for Listing 16.1

csc /r:System.Windows.Forms.DLL
_/r:System.Drawing.DLL FirstForm.cs

Listing 16.2 contains a command line that can be used to compile the code from Listing 16.1. The command line references a few dynamic link libraries by using the /r: <dllname> option. The System.Windows.Forms.DLL and System.Drawing.DLL libraries contain all the routines required to present graphical components, such as forms and controls, on the screen.

At the top of the file are a few new namespaces to be familiar with. The most familiar is the System namespace, holding all the basic class libraries. The System.Windows.Forms namespace holds definitions of all the Windows Forms windows and controls. It also has other supporting types including interfaces, structs, delegates, and enumerations supporting the window types. The System.ComponentModel namespace contains several classes and interfaces (language as opposed to graphical interfaces) for providing generalized support of components. The System.Drawing namespace provides access to the operating system graphics functionality.

The first two class members of the FirstForm class are components and howdyLabel. The components field is a Container object from the System.ComponentModel namespace. This object doesn't participate in the graphical presentation of the program. However, it does do a lot of behind-the-scenes work to support timers, multithreading, and cleanup when the program ends. Its declaration and instantiation are mandatory. The other field, howdyLabel, is a Windows Forms Label Control. It is used in this program to display the "Howdy, Partner!" message in the window that is created.

The FirstForm constructor calls the InitializeComponent() method. The InitializeComponent() method creates and instantiates the Windows Forms Controls and Forms that make up the graphical interface of this program. It begins by instantiating the components and howdyLabel fields as objects. The following paragraphs explain the rest of this method.

The first group of statements initializes the howdyLabel label. Labels are well suited to presenting static text. That's exactly what howdyLabel does.

Labels have a Location property, keeping track of where the Label is placed on the screen. The Location property accepts a Point structure, which is a member of the System.Drawing namespace. The Point struct is used frequently in Windows Forms applications to specify X and Y screen coordinates. In the example, the Location of the howdyLabel is 12 pixels from the left and 116 pixels from the top of the main form. Here's how the Location property of the howdyLabel label is set:

howdyLabel.Location = new Point (12, 116);

The static text of a Label is set through the Text property. The following statement sets the text of the Label to the string "Howdy, Partner!:

howdyLabel.Text   = "Howdy, Partner!";

A Label also has a Size property that takes a Size structure. In Listing 16.1, the size of howdyLabel is set to 267 pixels wide by 40 pixels high:

howdyLabel.Size   = new Size (267, 40);

The AutoSize property accepts a Boolean value, which tells whether a Label can automatically resize itself to accommodate its contents. For instance, in this program the actual size of the howdyLabel contents exceeds its set size from the previous statement, so the label must grow to fully show the entirety of its text. Here's how the AutoSize property of the howdyLabel label is set.

howdyLabel.AutoSize = true;

A Label can change its typeface through the Font property. It accepts a Font object. The constructor for the Font object in the following statement accepts three parameters: the font name, the font size, and a font style. The font style is from the FontStyle enum in the System.Drawing namespace.

howdyLabel.Font   = new Font (
  "Microsoft Sans Serif",
  26, 
  System.Drawing.FontStyle.Bold);

When there are multiple controls on a form, each control that can accept input can have its TabIndex property set. This permits the user to press the Tab key to move to the next control on the form, based on TabIndex. In this example, the TabIndex of howdyLabel is set to 0. This is for illustrative reasons only. The fact is that a Label can never be a tab stop because it doesn't normally accept user input. Furthermore, for this program, this is the only control on the form. There isn't any other control to tab to. Here's how the TabIndex property of the howdyLabel label is set:

howdyLabel.TabIndex = 0;

Window layout in Windows Forms is done with the techniques of anchoring and docking. Docking specifies the location of the form that a control will reside in. Anchoring tells which side of a control will be attached to another control. These two techniques permit any type of layout a window design would need. The following code line states that howdyLabel will not be anchored. It uses the AnchorStyles enumeration to set the Anchor property.

howdyLabel.Anchor  = AnchorStyles.None;

The horizontal alignment of a Label may be set with the TextAlign property, which accepts a ContentAlignment enumeration. The following statement sets the horizontal alignment of howdyLabel to be centered between its left and right margins.

howdyLabel.TextAlign = ContentAlignment.MiddleCenter;

The next few statements perform initialization on the main form. Since FirstForm is a Form object, it is considered the main form.

Text = "First Form"; 

All forms and controls have Text properties. What they do with them is unique to each form or control. A Form object sets its title bar with the value of the Text property. This example sets the program's title bar to say "First Form."

Controls.Add (howdyLabel);

A form's Controls object holds a collection of all of its controls. When the form has to redraw itself, it iterates through this collection and sets itself up according to several factors, including the anchoring and docking properties of each control. This example adds howdyLabel to the FirstForm Controls collection object.

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

The Main() method simply gets the program running. It calls the static Run() method of the Application class. Its parameter is a new instance of the FirstForm class. When the HowdyPartner program runs, it looks like the window shown in Figure 16.1.

Figure 16.1 The HowdyPartner Windows Forms

  • + Share This
  • 🔖 Save To Your Account