| home / programming / asp_net3 / 1 |    [previous] [next] |
|
|
|
Functions are exactly the same as subroutines, but for one key difference: they return a value. In VB.NET, we declare a function using the Function keyword in place of Sub, while, in C#, we simply have to specify the return type in place of using void. The following code shows a simple example:
Example 3.14. Functions.aspx
<html> <head> <script runat="server" language="VB"> ' Here's our function Function getName() as String Return "Zak Ruvalcaba" End Function ' And now we'll use it in the Page_Load handler Sub Page_Load(s As Object, e As EventArgs) lblMessage.Text = getName() End Sub </script> </head> <body> <form runat="server"> <asp:Label id="lblMessage" runat="server" /> </form> </body> </html>
Example 3.15. Functions.aspx
<html>
<head>
<script runat="server" language="C#">
// Here's our function
string getName() {
return "Zak Ruvalcaba";
}
// And now we'll use it in the Page_Load handler
void Page_Load() {
lblMessage.Text = getName();
}
</script>
</head>
<body>
<form runat="server">
<asp:Label id="lblMessage" runat="server" />
</form>
</body>
</html>Figure 3.2 shows the result in the browser.
Figure 3.2. The Page_Load event is raised, the function is called, and the code within the function is executed.
Here’s what’s happening: the line in our Page_Load subroutine calls our function, which returns a simple string that we can then assign to our label. I hope this illustrates what functions are about and how you can use them. In this simple example, we’re merely returning a fixed string (my name), but the function could just as well retrieve the name from a database—or somewhere else. The point is that, regardless of how the function gets its data, we use it (that is, call it) in just the same way.
When we’re declaring our function, we must remember to specify the correct return type. Take a look at the following code:
' Here's our function Function addUp(x As Integer, y As Integer) As Integer Return x + y End Function ' And now we use it in Page_Load Sub Page_Load(s As Object, e As EventArgs) lblMessage.Text = addUp(5, 5).ToString() End Sub
// Here's our function
int addUp(int x, int y) {
return x + y;
}
// And now we use it in Page_Load
void Page_Load() {
lblMessage.Text = Convert.ToString(addUp(5, 5));
}You can easily adapt the previous example to use this new code and see the results in your browser.
Have a look at this code, and see if you can spot what’s different and why. The first thing you might notice is that our function now accepts parameters. Any function or subroutine can take any number of parameters, each of any type (there’s no need for parameter types to match the return type—that’s just coincidental in this example).
We can then readily use the parameters inside the function or subroutine just by using the names we gave them in the function declaration (here, we’ve chosen x and y, but we could have chosen different names).
The other difference between this and the function declaration we had before is that we now declare our function with a return type of Integer or int, rather than String, because we want it to return a whole number.
When we now call the new function, we simply have to specify the required number of parameters, and remember that the function will return a value with the type we specified. In this case, that means we have to convert the integer value it returns to a string, so we can assign it to the label.
In VB.NET, we tack .ToString() onto the end of the function call, while in C# we use the Convert.ToString(…). Note the differences in how these two methods are used—converting numbers to strings is a very common task in ASP.NET, so it’s good to get a handle on it early. Don’t be too concerned if you’re a little confused by how these conversions work, though—the syntax will become clear once we discuss the object oriented concepts involved later in this chapter.
Again, a complete discussion of functions could take up an entire chapter, but I hope the brief examples here are enough to prepare you for what we’re going to cover in future chapters. Don’t worry too much if you’re still a bit unsure what functions and subroutines are all about right now—they’ll become second nature very quickly.
Throwing around values with variables and functions isn’t much use unless you can use them in some meaningful way, and to do this we use operators. An operator is a symbol that has a certain meaning when applied to values. Don’t worry—they’re nowhere near as scary as they sound! In fact, in the last example, when our function added two numbers, we were using an operator—the addition operator, +. Most of the other available operators are just as well known, although there are one or two that will probably be new to you. Table 3.2 outlines the operators that you’ll use most often.
Table 3.2. ASP.NET Operators
| VB.NET | C# | Description |
|---|---|---|
| > | > | greater than |
| >= | >= | greater than or equal to |
| < | < | less than |
| <= | <= | less than or equal to |
| <> | != | not equal to |
| = | == | equals |
| = | = | assigns a value to a variable |
| Or | || | or |
| And | && | and |
| & | + | concatenate strings |
| New | New | create object or array |
| * | * | multiply |
| / | / | divide |
| + | + | add |
| - | - | subtract |
The following code uses some of these operators:
If (user = "Zak" And itemsBought <> 0) Then lblMessage.Text = "Hello Zak! Do you want to proceed to " & _ "checkout?" End If
if (user == "Zak" && itemsBought != 0) { lblMessage.Text = "Hello Zak! Do you want to proceed to " + "checkout?"; }
Here, we use the equality, inequality (not equals to) and logical ‘and’ operators in an If statement to print a message only for a given user, and only when he or she has bought something. Of particular note is C#’s equality operator, ==, which is used when comparing two values to see if they are equal. Don’t use a single equals sign in C# unless you are assigning a value to a variable, or your code will have a very different meaning than you expect!
Since the message string in the above example was too long to fit on one line in this book, I also used the string concatenation operator to combine two shorter strings on separate lines to form the complete message. In VB.NET, I also had to break one line of code into two using the line continuation symbol (_, an underscore at the end of the line to be continued). Since C# marks the end of each command with a semicolon (;), I can split a single command over two lines without having to do anything special.
I’ll use these techniques throughout this book to show long lines of code within a limited page width. Feel free to recombine the lines in your own code if you like—there is no actual length limit on lines of code in VB.NET and C#.
| home / programming / asp_net3 / 1 | [previous] [next] |
Legal Notices, Licensing, Permissions, Privacy Policy.
Advertise | Newsletters | Shopping | E-mail Offers | Freelance Jobs 
Created: March 27, 2003
Revised: July 5, 2004
URL: http://webreference.com/programming/asp_net3/1
