CS 112D Lecture Notes - Visual Basic .NET Basics - Craig Persiko

Microsoft's .NET Framework

• .NET refers to a new version of all the Microsoft development tools, including Visual Basic.
• Visual Basic .NET has been changed from VB 6 to make it more similar to the other development tools, facilitating cooperation between different languages.
• The Microsoft .NET Framework is a unified system that manages and executes .NET applications. It is detailed in the Common Language Specification (CLS).
• The .NET Framework currently exists for Windows only, but it may soon be available on other operating systems as well.
• Borrowing some ideas from Sun's Java, the Common Language Runtime (CLR) is like Java's runtime environment - it must be installed on a computer before that computer can run a program written using .NET.
• Another idea taken from Sun, the Microsoft Intermediate Language (MSIL) is like Java's Byte Code. It's the language to which all .NET code is compiled.
• compiler - a program which reads an entire source code program (such as C++) and outputs that program in machine language. The machine language program can then be run and understood by the computer. Traditionally, C, C++, and Pascal are examples of compiled languages.
• interpreter - a program which reads a source code program (such as Basic or Lisp) and executes it directly, converting each line of code to machine language as it goes. This is like compiling and running a program all in one step. Traditionally, Basic and Lisp are examples of interpreted languages.
• .NET programs are compiled and run similarly to Java programs - they are both compiled and interpreted:
  1. The VB .NET (or C#, or C++ .NET, etc.) source code you write is compiled into MSIL, which is like assembly language, but it's machine-independent. (However, it's optimized for Windows.) The build command does this for you. The compiler saves the MSIL code in an .exe file in the project's bin directory.
  2. This MSIL code is interpreted and run - it is converted to your specific machine's language as it is run. The .NET Framework does this for you. The .exe file created above can only be run on machines that have the .NET Framework installed.

Major language changes in Visual Basic for .NET

• The data type Variant no longer exists. Object is now the universal data type.
• The data type Integer is 32 bits instead of 16 bits, so its range is now -2,147,483,648 through 2,147,483,647
• VB.NET is much more object-oriented than previous versions. For example, a form that you design with buttons, etc. is a class which inherits from the generic Form class. So if you design a form and name it frmInput, and if you want to load that form from another form (in response to a button click, for example), here is the code to load frmInput:

          Dim frmInputInstance As frmInput
          frmInputInstance = New frmInput()
          frmInputInstance.Show()
    

• The keywords On and Off are now used with Option Strict and Option Explicit
• For parameter passing, ByVal is now the default mechanism instead of ByRef Let's review what this means:
  • Call-by-Value - In this mechanism, the argument and the parameter occupy separate memory spaces, and the value of the argument is copied to give the parameter its initial value. This way, changes to the parameter's value are local to the function, and don't affect the argument.
  • Call-by-Reference In this mechanism, the argument and the parameter use the same memory space. So changes to the parameter are changes to the argument as well.
• In Visual Basic .NET, parentheses are always required around a non-empty argument list in any procedure call. (Sub or Function)
• In VB .NET, the Button and Label components have had their Caption properties renamed to Text.
• a variable declared inside a block (such as a loop) has block scope, and it is not accessible outside the block.
• Short-circuit evaluation: In Visual Basic .NET, the And, Or, Not, and Xor operators still evaluate all expressions contributing to their operands. Visual Basic .NET also introduces two new operators, AndAlso and OrElse, that can reduce execution time by short-circuiting logical evaluations. If the first operand of an AndAlso operator evaluates to False, the second operand is not evaluated. Similarly, if the first operand of an OrElse operator evaluates to True, the second operand is not evaluated.
• Return Statement: the GoSub statement is not supported, and you can use the Return statement to return control to the calling program from a Function or Sub procedure.
• In Visual Basic .NET, default properties are not supported unless they take arguments. Because of this syntax change, the Let and Set statements are not needed to specify what is to be assigned, and they are not used in assignment statements. Example:

      Dim L1, L2 As Label   ' Both become type Label in Visual Basic .NET.
      L1 = New Label        ' Construct a Label object for L1 to refer to.
      L2 = New Label        ' Same for L2: reference variables need to refer to objects.
      L1.Text = "Saving"    ' Assign Text property.
      L2.Text = L1.Text     ' Copy Text property.
      L2 = L1               ' Copy entire object reference, not just default property
    

• Visual Basic .NET retains the While ... Wend construction, but replaces the Wend keyword with the End statement. The Wend keyword is not supported.
• In Visual Basic .NET, structured exception handling code detects and responds to errors during execution by combining a control structure with exceptions, protected blocks of code, and filters. Structured exception handling is done through a Try statement, which is made up of three kinds of blocks: Try, Catch, and Finally. A Try block is a statement block that contains the statement to be executed. A Catch block is a statement block that handles an exception. A Finally block contains statements to be run when the Try statement is exited, regardless of whether an exception has occurred. The Throw statement, used in conjunction with a Catch block, raises an exception that is represented by an instance of a type derived from the System.Exception class. (We'll go into this in more detail when we work with Exception handling)
• More details on these and other changes are available in the MSDN.

Updated 1:00pm 8/22/05

Return to the main CS 112D page