C# Bible - Jeff Ferguson, Brian Patterson, Jason Beres

}

public MainForm()

{

Button MyButton = new Button();

Text = "Button Test"; MyButton.Location = new Point(25, 25); MyButton.Text = "Click Me";

MyButton.Click += new EventHandler(MyButtonClicked); Controls.Add(MyButton);

}

public void MyButtonClicked(object sender, EventArgs Arguments)

{

MessageBox.Show("The button has been clicked.");

}

}

Listing 21-7 illustrates several important concepts that you need to keep in mind when working with WindowsForms controls. Consider first the form's constructor. It creates a new object of a Button class and sets its position on the form with the button's Location property. This property is inherited from the Control class (which means that the property is available to any control derived from the Control class), and sets the position of the upper-left corner of the button relative to its container. In Listing 21-7, the button's location is set to a position 25 pixels to the right of the form's left edge and 25 pixels below the top of the form. The position is set with a new instance of a structure called Point, which is available in the .NET Framework System.Drawing namespace:

MyButton.Location = new Point(25, 25);

Tip Listing 21-7 uses the Location property to set the positions of the control. Using this property to programmatically position controls can be tedious for complicated forms with many controls. Visual Studio .NET comes with a forms designer that enables you to visually drag and drop controls onto forms. The designer then generates the equivalent C# forms code for you, freeing you from the burden of having to code all of the positioning logic yourself.

The next important concept in Listing 21-7 has to do with event handling for a control. Control classes support many events that are fired when the user interacts with the control. Many of these events are found in the Control base class, although the specific control class handles other events. The most obvious event for a button control would be a Click event. Buttons on forms are not useful unless they can respond to a user action of clicking the button.

Controls in the .NET Framework use the standard delegate/event model for supporting their events. Control events are installed using instances of a delegate called EventHandler. The EventHandler delegate accepts two arguments, an object specifying the sender of the event and an object of a class called EventArgs that encapsulates the arguments to the event. The form code in Listing 21-7 includes a method called MyButtonClicked that models the EventHandler delegate. This method is used as a new event handler and is wired to the button's Click event:

#=============

Message = Hello from the string table!

String table files must be compiled into an assembly so that they can be read from your C# applications. The files are compiled into an assembly using a tool called ResGen. The ResGen tool ships with the .NET Framework SDK. It is a console application that reads in the text file and outputs a binary representation of the table with an extension of resources. If the string table in Listing 21-8 were written to a text file called Listing21-8.txt, you could compile the string table using the following command line:

resgen Listing21-8.txt

This produces a file called Listing21-8.resources. After you build a resources file for your application, you can compile it into your assembly by using the /res argument to the C# compiler, as shown in the following command line:

csc /res:string.resources /out:test.exe test.cs

This command line instructs the C# compiler to create an executable called test.exe from the C# source file test.cs. It also instructs the C# compiler to embed the resources found in the string.resources file within the test.exe executable. Because the resources are embedded in the executable, you need only ship the executable when you deliver your application. The binary resource file will not be needed at runtime.

After the resources are embedded into your application, you can read the resources from your C# code. Listing 21-9 is a modification of Listing 21-7, in which the message shown in the message box is read from a string resource.

Listing 21-9: Reading from a String Resource

using System;

using System.Drawing; using System.Windows.Forms; using System.Resources; using System.Reflection;

public class MainForm : Form

{

public static void Main()

{

MainForm MyForm = new MainForm();

Application.Run(MyForm);

}

public MainForm()

{

Button MyButton = new Button();

Text = "Button Test";

MyButton.Location = new Point(25, 25);

MyButton.Text = "Click Me";

MyButton.Click += new EventHandler(MyButtonClicked);

Text-based string tables are not the only resources that you can embed in your assemblies. You can also embed binary resources, such as graphics and icons. Binary resources are encoded using BASE64 encoding into a specially formatted XML document. The XML document has an extension of .resx and is compiled into a resource file using resgen. From there, you can use the methods in the ResourceManager class to work with your binary resources just as you do with your text resources.

Unfortunately, the .NET Framework SDK does not include a tool for generating XML documents with BASE64 encoding, given binary file inputs. However, Visual Studio .NET contains support for embedding binary resources into your assemblies.

Summary

This chapter took a look at the basics of the development process for building WindowsForms applications in C#. It investigated some fundamental classes, such as the Application class, which manages the WindowsForms application as a whole, and the Forms class, which manages a form within the application. You also took a tour through the WindowsForms control class architecture and walked through the assembly attributes that can add version and descriptive information to the assembly.

The .NET Framework contains a rich set of classes for building WindowsForms applications. The WindowsForms subsystem is comprised of several classes; unfortunately, space limitations don't permit a full description of them all in this book. You can examine the documentation for each of the WindowsForms classes. Use the concepts explained in this chapter to start your investigation of all of the classes in the WindowsForms namespace.

Chapter 22: Creating Web Applications with WebForms

In This Chapter

The last decade witnessed unprecedented growth of the Internet as a business platform. Today, the majority of business models are centered around or at least include the concept of the Internet. The focus, therefore, has shifted from desktop applications to Web-based applications. This shift has highlighted the need for technologies that can simplify Web-based application development.

To build Web applications, the .NET Framework includes ASP.NET, which is the next version of ASP 3.0. You can build applications in ASP.NET by using Visual Basic .NET or Visual C# as the server-side scripting language. Visual C# enables programmers to develop powerful Web-based applications. More importantly it helps programmers combat increasingly accelerated cycle times, because it enables them to do more with fewer lines of code and fewer errors, which reduces the cost of a project considerably.

Although all that you need for creating ASP.NET Web applications is a text editor, such as Notepad, you will probably use a development platform, such as Visual Studio .NET. Visual Studio .NET provides an extensive set of tools for designing Web pages. In comparison to

earlier Web programming languages, in which you had to do extensive coding, Visual Studio

.NET provides the What You See Is What You Get (WYSIWYG) interface. This interface enables you to drag and drop controls onto WebForms, which you can then program in Visual C#. By programming in Visual Studio .NET, you can separate code and HTML content on a WebForm. This makes it very easy to separate programming logic from presentation logic, which enables you to focus on implementing the functionality of the project, rather than the presentation of data.

In this chapter, you learn to create an ASP.NET Web application by using Visual C#. While creating the application, you design a WebForm that uses server controls, such as labels, text boxes, list boxes, hyperlinks, and buttons. Finally, you learn to handle events that are generated by server controls.

Basics of ASP.NET Web Applications

ASP.NET Web applications are applications that are deployed on Web servers. These applications comprise one or more WebForms that are programmed either in Visual C# or Visual Basic .NET.

In this section, you learn about the features and advantages of ASP.NET Web applications and how Visual C# enables you to create ASP.NET applications. You also learn about how ASP.NET applications are different from ASP 3.0 applications.

New features in ASP.NET

ASP.NET includes several new features that were not present in ASP 3.0. These features are briefly described in this section.

Execution in the .NET Framework environment

In comparison to earlier Web-programming languages, applications in Visual C# (and other Visual Studio .NET languages) execute in the .NET framework environment. Thus, these applications are independent of the client browsers, and function in the same manner on all client platforms.

Another advantage that using a different runtime for ASP.NET is that ASP 3.0 applications can coexist with ASP.NET applications. Thus, you can deploy ASP 3.0 and ASP.NET Web sites on the same Web server.

Introduction of WebForms

WebForms are the foundation of a Web-based application. They are used by the Web application to interact with the user. A WebForm can include a number of server controls, such as text boxes, labels, list boxes, radio buttons, check boxes, and buttons, all of which facilitate the interaction of the user with the application.

A WebForm consists of two components: the user interface (UI) and the programming (application) logic. The user interface is the visual component of a WebForm; it consists of HTML and controls specific to the Web application. The user interface is the container for the

text and the controls that need to be displayed on the Web page. It is specified in a file with the .aspx extension.

The programming logic of a Web application in ASP.NET is contained in a separate file that contains the code to handle the user's interaction with the form. This file is known as the code-behind file. When a form written in C# executes, the code-behind file dynamically generates the HTML output of the page. The code-behind file in C# has an .aspx.cs extension.

The advantage of separating code from content is that the programmer need not concentrate on the logic that is used to display the output. The Web designer can handle this task.

Integration with Visual Studio .NET

Visual Studio .NET is the rapid application-development tool for ASP.NET. Visual Studio

.NET offers complete integration with ASP.NET and enables you to drag and drop server controls and design WebForms as they should appear when a user views them. Some of the other advantages of creating ASP.NET applications in Visual Studio .NET are summarized in the following list:

•Visual Studio .NET is a Rapid Application (RAD) tool. Instead of adding each control to the WebForm programmatically, it helps you to add these controls by using the toolbox, saving programming effort.

•Visual Studio .NET supports custom and composite controls. You can create custom controls that encapsulate a common functionality you might need to use in a number of applications, just as you use the ASP.NET Web controls provided by Visual Studio

.NET.

Introduction of server controls

Apart form the HTML controls that existed in the days of ASP 3.0, ASP.NET introduces server controls that are components of a Web application that are executed at the server end and encapsulate the functionality of the application.

HTML controls refer to the HTML elements that you can use in your WebForms. Normally, when the HTML controls are sent to the server through the browser, the server considers the HTML controls to be opaque. That is, the server does not process them. However, by converting these controls into HTML server controls, they can be exposed to the server for processing. By using attributes, such as ID and RUNAT, you can convert the HTML controls to HTML server controls. You can add these controls to a WebForm by using the HTML tab of the toolbox.

Server controls, on the other hand, are completely transparent to the application and enable a developer to handle events at the server-side to manage the Web application.

Apart from the conventional text box and button controls, this category of controls also includes the validation controls. Validation controls are programmable controls that help you validate user input. For example, you can use these controls to validate the value of a field or the pattern of characters entered by the user. To validate user input, you need to attach these controls to the input controls.

Composite and user controls

If you want to replicate a set of controls on a number of pages, one option is that you draw controls on each form separately. This is not a very useful option. However, another option provided by ASP.NET is by way of user and composite controls.

User controls are ordinary WebForms that have been converted to controls by removing the <HTML> and <FORM> tags of the control. Thus, they represent a unit of code and layout that can be imported into another WebForm.

Another set of controls provided by ASP.NET is composite controls. Composite controls are a set of controls that have been compiled into a library. To use composite controls, you can include a reference to the library as you include references to other libraries.

Controls commonly used in WebForms

The basic task of designing a Web application is to add controls to a WebForm. Some of the most commonly used controls on a WebForm are Label, TextBox, CheckBox, RadioButton, ListBox, DropDownList, HyperLink, Table, Button, and ImageButton. The following sections discuss these controls briefly.

Label control

You use the Label control to display static text in a WebForm. Users cannot edit the text in a Label control. When you add a Label control, the text Label appears as its caption. However, by setting the Text property of the control, you can modify the control's caption.

You can set the properties of the Label control at runtime in the code-behind file (.cs file). For example, you may want to change the text of a label when a user clicks a button. You can do so by using the following code:

Label1.Text="Welcome"

In the preceding code, Label1 is the ID of the Label control for which you want to change the identification. If you want the Label control to disappear when a user clicks a button, you can use the following code:

Label1.Visible=False

TextBox control

The TextBox control is used to get information, such as text, numbers, and dates, from users in a WebForm. By default, a TextBox control is a single-line control that enables users to type characters in a single line only. However, you can also set the TextBox control as a multiline control. A multiline text box displays multiple lines and allows text wrapping.

A TextBox control can also be used to accept passwords. A TextBox control that is used to accept passwords masks the characters typed by users, displaying them as asterisks (*).

You can set the appearance of a TextBox control by using its properties, such as BackColor or ForeColor. You can also change the TextMode property of a TextBox control to determine whether a TextBox control functions as a text box to accept a password, a single line of text, or multiple lines of text.

CheckBox and CheckBoxList controls

Check boxes enable users to select one or more options from a given set of options. You can add check boxes to a WebForm by using the CheckBox or CheckBoxList control. The CheckBox control represents a single check box, whereas the CheckBoxList control represents a collection of several check boxes. To add these controls to the form, simply drag them onto the form from the toolbox.

After adding the CheckBoxList control, you need to add a list of items to it. To do so, perform the following steps:

1.In the Properties window, click the ellipsis button for the Items property of the CheckBoxList control. The ListItem Collection Editor dialog box opens.

Note If the Properties window is not open, press F4. You can also select View → Properties Window, on the menu bar.

2.In the ListItem Collection Editor dialog box, click Add to create a new item. A new item is created and its properties are displayed at the right side of the dialog box.

3.Verify that the item is selected in the Members list, and then set the item properties. Each item is a separate object and has the following properties:

o Selected: Represents a Boolean value that indicates whether the item is

selected.

o Text: Represents the text to be displayed for the item in the list.

oValue: Represents the value associated with the item. The value of a control is not displayed to the user. However, the server uses the value to process information from the control. For example, you might set the Text property of an item as City Name, and the Value property to the postal code of the city, as a unique identification. When the server processes the information represented by the City Name field, the text supplied by the text box would be ignored, and any processing would be based on the corresponding value used by the field.

4.Specify the text to be displayed to the user.

5.Repeat Steps 2-4 to add the required controls to the CheckBoxList control.

6.Click OK to close the ListItem Collection Editor dialog box.

Tip The choice between using the CheckBox control and the CheckBoxList control depends on specific needs. The CheckBox control provides more control over the layout of the check boxes on the page. For example, you can set the font and color of the check boxes individually or include text between different check boxes. On the other hand, the CheckBoxList control is a better choice if you need to add a series of check boxes.

RadioButton and RadioButtonList controls

Radio buttons provide a set of options from which a user can select. You can add radio buttons to a WebForm by using either the RadioButton control or the RadioButtonList

control. The RadioButton control represents a single radio button to work with. The RadioButtonList control is a collection of radio buttons. Radio buttons are seldom used singly. Instead, they are used in a group. A group of radio buttons provides a set of mutually exclusive options. This means that only one radio button in a group can be selected. A set of radio buttons can be grouped in the following two ways:

•You can add a set of RadioButton controls to your page and assign them manually to a group. You can use the GroupName property to do so.

•You can add a RadioButtonList control to the page. The radio buttons in the control are automatically grouped, so you don't need to manually group them.

After adding a RadioButtonList control to the WebForm, you need to add the radio buttons. You can do so by using the Items property in the same way as you do for the CheckBoxList control.

ListBox control

The ListBox control represents a collection of list items. The control enables users to select one or more items from the list. You can add the individual list items using the Items property. You can also specify whether a user can select multiple items from a list of just a single item by using the SelectionMode property of the ListBox control.

DropDownList control

The DropDownList control enables users to select an item from a set of predefined items - each item being a separate object with its own properties. You can add items to a DropDownList control by using its Items property. Unlike the ListBox control, you can select only one item at a time, and the list of items remains hidden until a user clicks the drop-down button.

HyperLink control

The HyperLink control enables users to navigate from one WebForm to another in an application. It also enables users to navigate to a URL that might be associated with the control. With the HyperLink control, either text or an image can act as a hyperlink. When a user clicks the control, the target WebForm or the URL opens. The following code snippet illustrates how to set the NavigateUrl property:

Hyperlink1.NavigateUrl="http://www.amazon.com";

Table, TableRow, and TableCell controls

You use a table to display information in a tabular format. You can add a table to a WebForm by using the Table control. This control can display information statically by setting the rows and columns at design time. However, you can program the Table control to display information dynamically at runtime.

Two other table-related controls that you can use on a WebForm are TableRow and TableCell. Use the TableRow control to declare a row, and use the TableCell control to declare cells in a table.