Microsoft.ASP.Dot.NET.Programming.with.Visual.Basic.Dot.NET.Version.1002003.Step.By.Step [Electronic resources] نسخه متنی

Expressions, Variables, and Constants

Expressions, variables, and constants are some of the most basic building blocksof computer programs, and you’ll use them all extensively in your ASP.NET applications.

Expressions

Expressions are central to virtually all computer programs. Among other capabilities, expressions let you

Compare values to one another

Perform calculations

Manipulate text values

An expression can be as simple as the following:

1+1

An expression like this isn’t very useful by itself, however. Unlike people, who can easily recognize “one plus one” and fill in the blank (“equals two”), computers aren’t capable of that kind of leap of logic. In order for the expression to be useful, it needs to tell a computer not just to add one and one, but to store the result somewhere so that we can make use of it later (either by displaying it to the user or using it in another expression later). This is where variables come in.

Variables

At some point during the execution of most programs, you’ll need to store values of some sort, such as the results of comparisons or mathematical operations (as in the preceding example), or text input accepted from users. Simply put, variables are storage areas for data. This data can be numeric, text, or any one of a number of special data types.

Data Types

The data type of a variable defines the type of data that can be stored in it, as well as the format in which that data is stored (and the amount of memory that the system needs to allocate for the variable). Table 3-1 lists the data types supported by Visual Basic .NET and C#, as well as the Microsoft .NET Framework SDK types to which they map. The data types marked with an asterisk (*) don’t have a native representation, but you can still access these data types by using the appropriate System (or .NET Framework) type when declaring the variable.

The data type of a variable is determined at the time the variable is declared. This will be discussed further in the section entitled “Declaring Variables” later in the chapter.

Value Types vs. Reference Types

In .NET development, there are two categories of data types: value types and reference types. Although understanding the distinction between these types isn’t absolutely necessary if you want to develop ASP.NET applications, it can help you to better understand how these data types operate and how to deal with error messages resulting from coding errors. (Not that those ever happen, right?)

Value types are data types that store their data directly as values in memory. They include all the numeric types (int32, short, single, and so on), structures (custom data types based on System.ValueType), and enumerations (custom types that represent a defined set of values), as well as boolean, char, and date types. Value types are accessed directly, as in the following example:

'VisualBasic.NETdeclarationforanint32
DimmyIntasInteger
'Expressiontoassignthevalue123directlytothevariable
myInt=123

Reference types are data types that store a reference to another memory location that contains the data, which is usually based on a class, such as the String class in the .NET Framework. Reference types include Object (which acts as a replacement for Visual Basic’s Variant type, no longer supported in .NET), String, and all Arrays, as well as instances of custom classes. Reference types are accessed through members of the class that the type holds a reference to, as in the following example:

'Defineaclass
ClassmySampleClass
PublicmyIntAsInteger
EndClass
'Createaninstanceoftheclass
DimmyClassInstanceAsNewmySampleClass()
'Expressiontoassignthevalue123tomyClassInstancemembermyInt
myClassInstance.myInt=123

Declaring Variables

Before you can use variables in your programs, you need to declare them.Variable declaration is the process of specifying the characteristics of the variable (name, data type, lifetime, scope, and accessibility) so that the run-time system knows how much storage space to allocate for the variable, which actions to allow on the variable, and who can take those actions. A variable declaration takes the following form in Visual Basic .NET:

'DeclaresavariableoftypeInteger

DimxAsInteger

The preceding declaration specifies a variable of type Integer (which maps to the System.Int32 type). In this case, the variable, x, would be accessible only within the module, procedure, or block in which the declaration appeared. In addition to simple declarations like these, you can use the placement of the declarations, as well as Visual Basic .NET keywords, to modify the lifetime, scope, and accessibility of your variables.

Variable Lifetime

Lifetime refers to the span of time from when the variable is declared to when it is destroyed. The lifetime of a variable depends on where it is declared.

For example, the lifetime of a variable declared inside a procedure is limited to the execution of the procedure. Once the procedure has finished executing, the variable is destroyed and the memory it occupied is reclaimed. The following code illustrates a procedure-level declaration:

'VisualBasic.NETSubprocedure
SubHelloWorld()
'Declareprocedure-levelstringvariable
DimHelloStringAsString
HelloString="HelloWorld!"
'WriteHelloStringtobrowser
Response.Write(HelloString)
'LifetimeofHelloStringwillendafternextline
EndSub

When this procedure completes, the variable HelloString no longer exists. Its lifetime has ended. If HelloString had been declared outside the procedure, as shown in the following code example, its lifetime would have lasted until the instance of the class containing it was destroyed.

'Declaremodule-levelstringvariable
DimHelloStringAsString
'VisualBasic.NETSubprocedure
SubHelloWorld()
HelloString="HelloWorld!"
'WriteHelloStringtobrowser
Response.Write(HelloString)
'LifetimeofHelloStringwillnotendafternextline
EndSub

The Visual Basic .NET documentation recommends that you use whole words when naming your variables. You should use mixed case, with the first letter of each word capitalized, as in HelloString. This is called Pascal case. This is one of many possible naming conventions you can use for variables and other elements in your programs. Naming conventions are simply agreed-upon standards for how elements will be named in a program. For instance, using an initial lowercase character and capitalizing the first character of each word is called Camel case. The particular naming convention you choose isn’t important, but you should choose one and use it consistently. Doing so will make it easier for you to maintain your code and will help others understand what your code is doing. Consistent use of a variable naming convention is especially important when several developers are working together on the same project.

You can extend the lifetime of a procedure-level variable through the use of the Visual Basic .NET Static keyword in place of the Dim keyword used earlier. (InC#, you would use the static modifier.) In the following example, MyInt is declared within the procedure, but because it’s declared as Static, its lifetime continues until the class or module containing the procedure has finished running:

'VisualBasic.NETSubprocedure
SubAddInt()
'DeclareastaticIntegervariable
StaticMyIntAsInteger
'Add5toMyInt
MyInt+=5
'WriteMyInttobrowser
Response.Write(MyInt.ToString())
'LifetimeofMyIntwillnotendafternextline
EndSub

Because MyInt is declared as Static, each call to AddInt() will result in MyInt being incremented by 5. If MyInt was instead declared using Dim, each call to AddInt() would result in MyInt being set to 5.

Scope

Scope refers to the region of code in which a variable can be accessed. The scope of a variable depends on where the variable is declared, and in Visual Basic .NET it can include the following levels.

Block level Variables declared within statement blocks such asIf… Then, For…Next , or Do… Loop. Although the scope of block-level variables is limited to the block in which they’re declared, their lifetime is that of the procedure in which the block appears.

Procedure level These variables are visible only within the procedure in which they’re declared.

Module level In modules, classes, or structures, any variable declared outside of a procedure is referred to as a module-level variable.

Namespace level Variables declared at module level, but given public accessibility (Public or Friend), are referred to as namespace-level variables. They’re available to any procedure in the same namespace that contains the module in which the variable is declared.

A namespace is a container used for scoping. Namespaces can contain classes, structures, enumerations, interfaces, and delegates. By using namespaces, you can have more than one class in a given program with the same name, as long as the classes reside in different namespaces. Using namespaces can help ensure that code created by multiple teams of developers can be combined to create larger systems without name collisions.

Namespaces are declared in Visual Basic .NET using the Namespace…End Namespace syntax, where these statements bracket the classes, structures, and so on to be contained within the namespace. C# uses the namespace {} syntax, where the classes and other types to be contained within the namespace are bracketed by the curly braces.

Namespaces can also be nested within other namespaces, forming a hierarchy. This structure allows you to combine classes into logical groupings, making it easier for those using your namespaces to find the classes they’re looking for.

Effective use of namespaces will make your application more memory-efficient and will make maintaining your code easier.

The important distinction between lifetime and scope is that a variable might be out of scope (that is, unavailable) without having reached the end of its lifetime. The preceding example of a Static variable that’s declared within a procedure is a good illustration of this distinction. In that example, the variable MyInt will continue to exist even after the procedure in which it’s declared has completed, but because it has procedure-level scope, it’s only accessible within the procedure. Here are some good programming practices to follow:

Limit your variables to the narrowest possible scope that will allow you to accomplish your objectives.

Avoid using the same name for variables of different scope within the same module, even where it is allowed. Using the same name in such situations can lead to confusion anderrors.

Since module-level and Static variables all continue to consume memory as long as the class or module is running, use them only when necessary.

Accessibility

The last important concept in variable declaration is accessibility. The accessibility of a variable determines whether it can be accessed from outside the module (or application) in which it’s declared. In Visual Basic .NET, accessibility is determined by declaring your variable with one the following keywords, instead of Dim.

Public Variables declared with the Public keyword are accessible from anywhere in the same module (or class) in which they’re declared, from the namespace containing that module, and from anyother applications that refer to the application in which they’re declared. They can be used only at the module or class level, or within Structures.

Frien Variables declared with the Friend keyword are accessible from anywhere in the same module (or class) in which they’re declared, as well as from the namespace containing that module.

Protected Variables declared with the Protected keyword are accessible only within the class in which they’re declared or within a class that inherits from that class. (See “Using Inheritance” later in this chapter.) The Protected keyword can be combined with the Friend keyword and can be used only to declare classmembers.

Private Variables declared with the Private keyword are accessible only from the module, class, or structure in which they’re declared. In classes or modules, declaring a variable with Dim or Private has the same effect on the variable’s accessibility, but Private makes your intentions more explicit. The Private keyword cannot be used within a procedure.

'turnsOptionExpliciton
OptionExplicitOn'turnsOptionExplicitoffOptionExplicitOff

'turnsOptionStricton
OptionStrictOn'turnsOptionStrictoffOptionStrictOff

Constants

Constants are similar to variables, except for one important detail: Once a constant has been declared and initialized, its value cannot be modified. Constants are very useful when you have a literal value that you want to refer to by name. For example, in a program that calculates shipping weights in pounds and ounces, you might want to create a constant to refer to the number of ounces in a pound:

ConstOuncesInAPoundAsInteger=16

Anywhere within your program (subject to the same scope, lifetime, and accessibility rules as variables) you can use the constant name OuncesInAPound instead of the literal value 16.

Constants are particularly handy in place of literal values used as the arguments to methods of components you might use. For example, in classic Microsoft ActiveX Data Objects (ADO), the data types of stored procedure parameters were represented by numeric values. Trying to remember all of those values would be unrealistic, so the developers of ADO also made it possible to use constants (adInteger, adVarChar, and so on) in place of the literal values.

In other words, constants let you substitute easy-to-remember names for difficult- to-remember literal values. This can make your code easier to write and maintain, since you can update the value in a single location (the constant initialization), rather than having to search your code for every instance of a literal value.

Enumerations

Many constants used with ASP.NET are actually created using enumerations. Using enumerations allows you to define a set of related constants and access them in a type-safe way. For instance, if you have a procedure that accepts numeric values, from 1 to 3, representing a color, it might look like this:

SubSetColor(ByValColorAsInteger)
IfColor=3Then
'Codetoapplycolorsetting3.
EndIf
EndSub

This method will, in fact, happily accept any integer value. To limit the possible values, you could declare an enumeration as follows:

EnumColorTypeAsInteger
Red=1
Green
Blue
EndEnum

By default the first element of an enumeration is equal to 0. In this example, since you want an enumeration that contains 1 through 3, you set the first value in the enumeration to 1, and then the subsequent values are each incremented byone. So, Green is 2 and Blue is 3. Now, rather than the previous procedure declaration, you could use the following:

SubSetColor(ByValColorAsColorType)
IfColor=ColorType.BlueThen
'Codetoapplythecolorsettingblue.
EndIf
EndSub

This procedure will require an instance of the ColorType enumeration to be passed as the parameter, ensuring that the value is a valid member of the enumeration, and thus that the value represents a valid color. The following is an example of calling SetColor with a ColorType enumeration member:

SetColor(ColorType.Blue)