< Day Day Up > |
If you take a look at the source code for the HelloWorld program from the previous chapter, several things should already be obvious. The first thing that should stand out is the way that the Visual Basic .NET language takes advantage of English words and syntax to make code as readable as possible. Compare the following Visual Basic .NET version of the "Hello, world!" program: Module HelloWorld Public Sub Main() Console.WriteLine("Hello, world!") Console.ReadLine() End Sub End Module with the equivalent program in Visual C# .NET. using System; class HelloWorld { public static void Main() { Console.WriteLine("Hello, world!"); Console.ReadLine(); } } In many ways the syntax of the two programs looks similar. But a closer look at how the Main subroutine is defined reveals some differences ”in Visual Basic .NET, the subroutine Main starts with the statement Sub Main and ends with the statement End Sub . In Visual C# .NET, the subroutine Main starts with the statement void Main and an opening curly brace ( { ) and ends with a closing curly brace ( } ). While Visual C# .NET emphasizes conciseness at the cost of some readability, Visual Basic .NET emphasizes readability at the cost of some conciseness. This emphasis on using English (or English-like) words and syntax extends throughout the language and is intended to make reading Visual Basic .NET code as easy as possible. In most cases, keywords in the language describe what they do, and statements can be read as if they were sentences. Case InsensitivityAnother aspect of Visual Basic .NET that is different from many other programming languages is that it is case insensitive . That is, the language does not care whether characters are uppercase or lowercase in a program. The following code compiles just the same as the original HelloWorld program shown earlier. module HelloWorld SUB Main() console.writeline("Hello, world!") ConsolE.ReadlinE() EnD SuB END MODULE The fact that module is not capitalized has no effect on the program, nor does the fact that END is all uppercase.
In the same way that the language is not strict about casing, the language is also relaxed in regard to parts of the language that can be understood implicitly. For example, the following version of the HelloWorld program is also equivalent to the first example. Module HelloWorld Sub Main Console.WriteLine("Hello, World!") Console.ReadLine End Sub End Module This version of the HelloWorld program leaves off the parentheses after the Sub Main and Console.ReadLine statements. This is allowed because it can be reasonably inferred that leaving off the parentheses means that the subroutine has no parameters or arguments ”the same thing that specifying empty parentheses indicates. There are many places in the language where pieces of syntax are optional when the intent is obvious.
Line OrientationAnother fundamental aspect of Visual Basic .NET may have become obvious if you tried typing in the HelloWorld program and didn't type it in exactly as it appeared on the page. Unlike some programming languages, Visual Basic .NET is line-oriented . This means that where a line ends is significant ”lines cannot end just anywhere . This is in contrast to other languages, such as C++, that are free-format . Free-format languages allow ending lines almost anywhere the programmer pleases, even in the middle of a statement (although not in the middle of a word).
Except in the cases discussed later in the chapter, Visual Basic .NET does not allow more than one statement on a line and does not allow a statement to span more than one line. For example, although the follow program looks almost the same as the first HelloWorld program, it will not compile. ' This program will not compile! Module HelloWorld Sub Main ( ) Console.WriteLine("Hello, world!") Console. ReadLine () End Sub End Module Compiling the preceding program will cause many different errors because Visual Basic .NET expects that an entire statement will appear on one line and that each statement will appear on its own line. The statement Sub Main() starts the Main subroutine, so the language expects that the entire statement will be together. Similarly, the End Sub statement ends the Main subroutine, so the language expects that it will be the only statement on that line. When you have a very long line of code, requiring that an entire statement be on one line can be painful. To help with this, a program can use line continuations to break a single statement across multiple lines. A line continuation allows a statement to be extended over one or more lines by placing an underscore ( _ ) at the end of a line. This tells the compiler that the line continues on to the next line. It is important to notice that there has to be at least once space between the line continuation and anything that comes before it.
It is also possible to put more than one statement on a line by using a statement separator . A statement separator separates the statements on a line by placing a colon ( : ) between each statement. The one restriction on statement separators is that a subroutine or function declaration must always be the first statement on a line. For example, the following code is still not valid, because the Sub Main statement must be the first statement on a line. ' This program will not compile! Module HelloWorld : Sub Main() Console.WriteLine("Hello, world!") End Sub : End Module The original example, though, could be made to compile using line continuations and statement separators. Module _ HelloWorld Sub Main _ ( _ ) Console.WriteLine("Hello, world!") Console. _ ReadLine _ () End Sub : End Module The line continuation characters keep the entire Module and Sub declaration statements together, while the statement separator separates the two End statements. CommentsA comment is text that is intended solely for the programmer and not for the compiler. Comments can be used to provide descriptions of what code does or to serve as reminders of things that still need to be done. Comments in Visual Basic .NET are started by using the single quote character ( ' ) anywhere on a line and continue from that point until the end of the line. The language ignores anything in a comment, so a comment may contain any text. For example: ' ' This program prints the string "Hello, world!" to the output ' window. ' ' ' This contains the Main routine and does all the work. ' Module HelloWorld ' ' This is the main routine and prints out the string. ' Public Sub Main() Console.WriteLine("Hello, world!") ' Print the string Console.ReadLine() ' Wait for input End Sub ' Main End Module ' HelloWorld Since everything after a comment begins is ignored, it is not possible to continue a comment across multiple lines. Comments that will not fit on one line must be broken into multiple lines with each line starting with a single quote, as in the preceding example. Comments cannot be placed after a line continuation. ' This program will not compile! Module HelloWorld Sub Main( _ ' Invalid comment Args() As String _ ' Invalid comment ) ' Valid comment Console.WriteLine("Hello, world!") End Sub End Module The second and third comments in this example are not valid comments, because they follow a line continuation. The last comment is valid because it does not.
|
< Day Day Up > |