Article
About the Author
Zak Ruvalcaba
Involved in the Web since 1995, Zak is founder of and advisor to Module Media, a full service design and development firm in San Diego. He is author of �The Ten Minute Guide to Dreamweaver 4� and �Dreamweaver MX Unleashed�, and SitePoint's own Build Your Own ASP.NET Website Using C# and VB.NET.
Build Your Own ASP.NET Website Using C# And VB.NET, Chapter 3 - VB.NET and C# Programming Basics
As you learned at the end of the last chapter, one of the great things about ASP.NET is that we can pick and choose which of the various .NET languages we like. In this chapter, we'll look at some key programming principles using our two chosen languages, VB.NET and C#. We'll start off with a run-down of some basic programming concepts as they relate to ASP.NET using both languages. We'll introduce programming fundamentals such as control and page events, variables, arrays, functions, operators, conditionals, and loops. Next, we'll dive into namespaces and address the topic of classes—how they're exposed through namespaces, and which you'll use most often.
The final sections of the chapter cover some of the ideas underlying modern, effective ASP.NET design, starting with that of code-behind and the value it provides by helping us separate code from presentation. We finish with an examination of how object-oriented programming techniques impact the ASP.NET developer. Note that you can download these chapters in PDF format if you'd rather print them out and read them offline.
Programming Basics
One of the building blocks of an ASP.NET page is the application logic: the actual programming code that allows the page to function. To get anywhere with this, you need to grasp the concept of events. All ASP.NET pages will contain controls, such as text boxes, check boxes, lists, and more, each of these controls allowing the user to interact with it in some way. Check boxes can be checked, lists can be scrolled, items on them selected, and so on. Now, whenever one of these actions is performed, the control will raise an event. It is by handling these events with code that we get our ASP.NET pages to do what we want.
For instance, say a user clicks a button on an ASP.NET page. That button (or, strictly, the ASP.NET Button control) raises an event (in this case it will be the Click event). When the ASP.NET runtime registers this event, it calls any code we have written to handle it. We would use this code to perform whatever action that button was supposed to perform, for instance, to save form data to a file, or retrieve requested information from a database. Events really are key to ASP.NET programming, which is why we'll start by taking a closer look at them. Then, there's the messy business of writing the actual handler code, which means we need to check out some common programming techniques in the next sections. Specifically, we're going to cover the following areas:
- Control events and handlers
- Page events
- Variables and variable declaration
- Arrays
- Functions
- Operators
- Conditionals
- Loops
It wouldn't be practical, or even necessary, to cover all aspects of VB.NET and C# in this book, so we're going to cover enough to get you started, completing the projects and samples using both languages. Moreover, I'd say that the programming concepts you'll learn here will be more than adequate to complete the great majority of day-to-day Web development tasks using ASP.NET.
Control Events and Subroutines
As I just mentioned, an event (sometimes more than one) is raised, and handler code is called, in response to a specific action on a particular control. For instance, the code below creates a server-side button and label. Note the use of the OnClick attribute on the Button control:
Example 3.1. ClickEvent.aspx (excerpt)
<form runat="server">
<asp:Button id="btn1" runat="server" OnClick="btn1_Click"
Text="Click Me" />
<asp:Label id="lblMessage" runat="server" />
</form>
When the button is clicked, it raises the Click event, and ASP.NET checks the OnClick attribute to find the name of the handler subroutine for that event. Here, we tell ASP.NET to call the btn1_Click() routine. So now we have to write this subroutine, which we would normally place within a code declaration block inside the <head> tag, like this:
Example 3.2. ClickEvent.aspx (excerpt)
<head>
<script runat="server" language="VB">
Public Sub btn1_Click(s As Object, e As EventArgs)
lblMessage.Text = "Hello World"
End Sub
</script>
</head>
Example 3.3. ClickEvent.aspx (excerpt)
<head>
<script runat="server" language="C#">
public void btn1_Click(Object s, EventArgs e) {
lblMessage.Text = "Hello World";
}
</script>
</head>
This code simply sets a message to display on the label that we also declared with the button. So, when this page is run and users click the button, they'll see the message "Hello World" appear next to it.
I hope you can now start to come to grips with the idea of control events and how they're used to call particular subroutines. In fact, there are many events that your controls can use, some of which are only found on certain controls—not others. Here's the complete set of attributes the Button control supports for handling events:
OnClick
As we've seen, the subroutine indicated by this attribute is called for the Click event, which occurs when the user clicks the button.
OnCommand
As with OnClick, the subroutine indicated by this attribute is called when the button is clicked.
OnLoad
The subroutine indicated by this attribute is called when the button is loaded for the first time—generally when the page first loads.
OnInit
When the button is initialized, any subroutine given in this attribute will be called.
OnPreRender
We can run code just before the button is rendered, using this attribute.
OnUnload
This subroutine will run when the control is unloaded from memory—basically, when the user goes to a different page or closes the browser entirely.
OnDisposed
This occurs when the button is released from memory.
OnDataBinding
This fires when the button is bound to a data source.
Don't worry too much about the intricacies of all these events and when they happen; I just want you to understand that a single control can produce a number of different events. In the case of the Button control, you'll almost always be interested in the Click event, as the others are only useful in rather obscure circumstances.
When a control raises an event, the specified subroutine (if there is one) is executed. Let's now take a look at the structure of a typical subroutine that interacts with a Web control:
Public Sub mySubName(s As Object, e As EventArgs)
' Write your code here
End Sub
public void mySubName(Object s, EventArgs e) {
// Write your code here
}
Let's break down all the components that make up a typical subroutine:
Public, public
Defines the scope of the subroutine. There are a few different options to choose from, the most frequently used being Public (for a global subroutine that can be used anywhere within the entire page) and Private (for subroutines that are available for the specific class only). If you don't yet understand the difference, your best bet is to stick with Public for now.
Sub, void
Defines the chunk of code as a subroutine. A subroutine is a named block of code that doesn't return a result; thus, in C#, we use the void keyword, which means exactly that. We don't need this in VB.NET, because the Sub keyword already implies that no value is returned.
mySubName(…)
This part gives the name we've chosen for the subroutine.
s As Object, Object s
When we write a subroutine that will function as an event handler, it must accept two parameters. The first is the control that generated the event, which is an Object. Here, we are putting that Object in a variable named s (more on variables later in this chapter). We can then access features and settings of the specific control from our subroutine using the variable.
e As EventArgs, EventArgs e
The second parameter contains certain information specific to the event that was raised. Note that, in many cases, you won't need to use either of these two parameters, so you don't need to worry about them too much at this stage.
As this chapter progresses, you'll see how subroutines associated with particular events by the appropriate attributes on controls can revolutionize the way your user interacts with your application.
Page Events
Until now, we've considered only events that are raised by controls. However, there is another type of event—the page event. The idea is the same as for control events (Strictly speaking, a page is simply another type of control, and so page events are actually control events. When you're first coming to grips with ASP.NET, however, it can help to think of them differently, especially since you don't usually use OnEventName attributes to assign subroutines to handle them.), except that here, it is the page as a whole that generates the events. You've already used one of these events: the Page_Load event. This event is fired when the page loads for the first time. Note that we don't need to associate handlers for page events the way we did for control events; instead, we just place our handler code inside a subroutine with a preset name. The following list outlines the page event subroutines that are available:
Page_Init
Called when the page is about to be initialized with its basic settings
Page_Load
Called once the browser request has been processed, and all of the controls in the page have their updated values.
Page_PreRender
Called once all objects have reacted to the browser request and any resulting events, but before any response has been sent to the browser.
Page_UnLoad
Called when the page is no longer needed by the server, and is ready to be discarded.
The order in which the events are listed above is also the order in which they're executed. In other words, the Page_Init event is the first event raised by the page, followed by Page_Load, Page_PreRender, and finally Page_UnLoad.
The best way to illustrate the Page_Load event is through an example:
Example 3.4. PageEvents.aspx (excerpt)
<html>
<head>
<script runat="server" language="VB">
Sub Page_Load(s As Object, e As EventArgs)
lblMessage.Text = "Hello World"
End Sub
</script>
</head>
<body>
<form runat="server">
<asp:Label id="lblMessage" runat="server" />
</form>
</body>
</html>
Example 3.5. PageEvents.aspx (excerpt)
<html>
<head>
<script runat="server" language="C#">
void Page_Load(Object s, EventArgs e) {
lblMessage.Text = "Hello World";
}
</script>
</head>
<body>
<form runat="server">
<asp:Label id="lblMessage" runat="server" />
</form>
</body>
</html>
You can see that the control on the page does not specify any event handlers. There's no need, because we're using the special Page_Load subroutine, which will be called when the page loads. As the page loads, it will call the Page_Load routine, to display "Hello World" in the Label control, as shown in Figure 3.1.
Figure 3.1. The Page_Load event is raised, the subroutine is called, and the code within the subroutine is executed.
Variables and Variable Declaration
Variables are fundamental to programming, and you've almost certainly come across the term before. Basically, they let you give a name, or identifier, to a piece of data; we can then use that identifier to store, modify, and retrieve the data.
However, there are, of course, many different kinds of data, such as strings, integers (whole numbers), and floating point numbers (fractions or decimals). Before you can use a variable in VB.NET or C#, you must specify what type of data it can contain, using keywords such as String, Integer, Decimal, and so on, like this:
Dim strName As String
Dim intAge As Integer
string strName;
int intAge;
These lines declare what type of data we want our variables to store, and are therefore known as variable declarations. In VB.NET, we use the keyword Dim, which stands for "dimension", while in C#, we simply precede the variable name with the appropriate data type.
Sometimes, we want to set an initial value for variables that we declare; we can do this using a process known as initialization:
Dim strCarType As String = "BMW"
string strCarType = "BMW";
We can also declare and/or initialize a group of variables of the same type all at once:
Dim strCarType As String, strCarColor = "blue", strCarModel
string strCarType, strCarColor = "blue", strCarModel;
Table 3.1 below lists the most useful data types available in VB.NET and C#.
Table 3.1. A List of the Commonly Used Data Types (larger version).
There are many more data types that you may encounter as you progress, but this list provides an idea of the ones you'll use most often.
So, to sum up, once you've declared a variable as a given type, it can only hold data of that type. You can't put a string into an integer variable, for instance. However, there are frequently times when you'll need to convert one data type to another. Have a look at this code:
Dim intX As Integer
Dim strY As String = "35"
intX = strY + 6
int intX;
String strY = "35";
intX = strY + 6;
Now, while you or I might think that this could make sense—after all, the string strY does contain a number, so we may well wish to add it to another number—the computer will not be happy, and we'll get an error. What we have to do is explicitly convert, or cast, the string into an integer first:
Dim intX As Integer
Dim strY As String = "35"
intX = Int32.Parse(strY) + 6
int intX;
String strY = "35";
intX = Convert.ToInt32(strY) + 6;
Now, the computer will be happy, as we've told it that we want to turn the string into an integer before it's used as one. This same principle holds true when mixing other types in a single expression.
Arrays
Arrays are a special variety of variable tailored for storing related items of the same data type. Any one item in an array can be accessed using the array's name, followed by that item's position in the array (its offset). Let's create a sample page to show what I mean:
Example 3.6. Arrays.aspx
<html>
<head>
<script runat="server" language="VB">
Sub Page_Load()
' Declare an array
Dim drinkList(4) As String
' Place some items in it
drinkList(0) = "Water"
drinkList(1) = "Juice"
drinkList(2) = "Soda"
drinkList(3) = "Milk"
' The line below accesses an item in the array by its position
lblArrayList.Text = drinkList(1)
End Sub
</script>
</head>
<body>
<form runat="server">
<asp:Label id="lblArrayList" runat="server"/>
</form>
</body>
</html>
Example 3.7. Arrays.aspx
<html>
<head>
<script runat="server" language="C#">
void Page_Load() {
// Declare an array
String[] drinkList = new String[4];
// Place some items in it
drinkList[0] = "Water";
drinkList[1] = "Juice";
drinkList[2] = "Soda";
drinkList[3] = "Milk";
// The line below accesses an item in the array by its position
lblArrayList.Text = drinkList[1];
}
</script>
</head>
<body>
<form runat="server">
<asp:Label id="lblArrayList" runat="server"/>
</form>
</body>
</html>
There are some important points to pick up from this code. First, notice how we declare an array. In VB.NET, it looks like a regular declaration for a string, except that the number of items we want the array to contain is given in brackets after the name:
Example 3.8. Arrays.aspx (excerpt)
Dim drinkList(4) As String
In C#, it's a little different. First, we declare that drinkList is an array by following the datatype with two empty square brackets. We must then specify that this is an array of four items, using the new keyword:
Example 3.9. Arrays.aspx (excerpt)
String[] drinkList = new String[4];
A crucial point to realize here is that the arrays in both C# and VB.NET are what are known as zero-based arrays. This means that the first item actually has position 0, the second has position 1, and so on, through to the last item, which will have a position that's one less than the size of the array (3, in this case). So, we specify each item in our array like this:
Example 3.10. Arrays.aspx (excerpt)
drinkList(0) = "Water"
drinkList(1) = "Juice"
drinkList(2) = "Soda"
drinkList(3) = "Milk"
Example 3.11. Arrays.aspx (excerpt)
drinkList[0] = "Water";
drinkList[1] = "Juice";
drinkList[2] = "Soda";
drinkList[3] = "Milk";
Notice that C# uses square brackets for arrays, while VB.NET uses standard parentheses. We have to remember that arrays are zero-based when we set the label text to the second item, as shown here:
Example 3.12. Arrays.aspx (excerpt)
lblArrayList.Text = drinkList(1)
Example 3.13. Arrays.aspx (excerpt)
lblArrayList.Text = drinkList[1];
To help this sink in, you might like to try changing this code to show the third item in the list instead of the second. Can you work out what change you'd need to make?
That's right—you only need to change the number given in the brackets to match the position of the new item (don't forget to start at zero). In fact, it's this ability to select one item from a list using only its numerical location that makes arrays so useful in programming, as we'll see as we get further into the book.