Article
ASP.NET 2.0: A Getting Started Guide
Chapter 3. VB and C# Programming Basics
As you learned at the end of the last chapter, one of the great things about using ASP.NET is that we can pick and choose which of the various .NET languages we like. In this chapter, we'll look at the key programming principles that will underpin our use of Visual Basic and C#. We'll start by discussing some basic concepts of programming ASP.NET web applications using these two languages. We'll explore programming fundamentals such as variables, arrays, functions, operators, conditionals, loops, and events, and work through a quick introduction to object oriented programming (OOP). Next, we'll dive into namespaces and address the topic of classes--seeing how they're exposed through namespaces, and which ones you'll use most often.
The final sections of the chapter cover some of the ideas underlying modern, effective ASP.NET design, including 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.
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 ASP.NET, you need to grasp the concept of events. All ASP.NET pages will contain controls such as text boxes, checkboxes, and lists. Each of these controls allows the user to interact with the application in some way: checking checkboxes, scrolling through lists, selecting list items, and so on. Whenever one of these actions is performed, the control will raise an event. It is by handling these events within our code that we get ASP.NET pages to do what we want.
For instance, imagine that a user clicks a button on an ASP.NET page. That button (or, more specifically, the ASP.NET Button control) raises an event (in this case, it will be the Click event). A method called an event handler executes automatically when an event is raised--in this case, the event handler code performs a specific action for that button. For instance, the Click event handler could save form data to a file, or retrieve requested information from a database. Events really are the key to ASP.NET programming, which is why we'll start this chapter by taking a closer look at them.
It wouldn't be practical, or even necessary, to cover all aspects of VB and C# in this book, so we're going to discuss enough to get you started, and complete this chapter's projects and samples using both languages. Moreover, we'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. If you want to test the code, save the file in the Learning virtual directory you've been using for the other examples.
Example 3.1. ClickEvent.aspx (excerpt)
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html>
<head>
<title>Click the Button</title>
</head>
<body>
<form runat="server">
<asp:Button id="button" runat="server"
OnClick="button_Click" Text="Click Me" />
<asp:Label id="messageLabel" runat="server" />
</form>
</body>
</html>
When the button's clicked, it raises the Click event, and ASP.NET checks the button's OnClick attribute to find the name of the handler subroutine for that event. In the code above, we told ASP.NET to call the button_Click routine, so perhaps we'd better write this subroutine! We'd normally place it within a code declaration block inside the <head> tag, like this:
Example 3.2. ClickEvent.aspx (excerpt)
<head>
<title>Click the Button</title>
<script runat="server" language="VB">
Public Sub button_Click(s As Object, e As EventArgs)
messageLabel.Text = "Hello World"
End Sub
</script>
</head>
Example 3.3. ClickEvent.aspx (excerpt)
<head>
<title>Click the Button</title>
<script runat="server" language="C#">
public void button_Click(Object s, EventArgs e)
{
messageLabel.Text = "Hello World";
}
</script>
</head>
This code simply sets a message to display on the label that we 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.
Figure 3.1. Handling the Click event
Hopefully, you're starting to come to grips with the idea of control events, and the ways in which they're used to call particular subroutines. In fact, there are many events that your controls can use, though some of them are found only on certain controls. Here's the complete set of attributes that the Button control supports for handling events:
OnClick- As we've seen, the subroutine indicated by this attribute is called for theClickevent, which occurs when the user clicks the button.OnCommand- As withOnClick, 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--usually when the page first loads.OnInit- When the button is initialized, any subroutine given in this attribute will be called.OnPreRender- We can use this attribute to run code just before the button is rendered.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- The subroutine specified by this attribute is executed when the button is released from memory.OnDataBinding- This attribute 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 occur; 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; the others are only useful in rather obscure circumstances.
When a control raises an event, the specified subroutine (if one is specified) is executed. Let's 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 take a moment to break down all the components that make up a typical subroutine.
Public (Visual Basic), public (C#)
This command 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). (The C# equivalents of Public and Private are, perhaps predictably, public and private.) We'll analyze these options in more detail a bit later in the chapter.
Sub (Visual Basic), void (C#)
This command 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 what the name says. We don't need this in VB, though, because the Sub keyword implies that no value is returned.
mySubName(...)
This part gives the name we've chosen for the subroutine. The parameters and their data types are mentioned in the parentheses.
s As Object (Visual Basic), Object s (C#)
When we write a subroutine that will function as an event handler, it must accept two parameters. The first is a reference to the control that fired the event. Each control has a particular type, such as Label or TextBox, but Object is a generic type that can be used to reference any kind of object in .NET--even basic types, such as numbers or strings. Here, we're putting that Object in a variable named s (again, we'll talk more about variables later in this chapter). We can then use that variable to access features and settings of the specific control from our subroutine.
e As EventArgs (Visual Basic), EventArgs e (C#)
This, the second parameter, contains certain information that's 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 that are associated with particular events by the appropriate attributes on controls can revolutionize the way your user interacts with your application.