BA 371 Business Systems Analysis

BA 371 - Datatypes, Control and some I/O

Basic data types in VB.NET

Integers:

Byte (1 byte)

Short or Int16 (2 bytes)

Long or Int32 (4 bytes)

Int64 (8 byte)

Floats:

Single (4 bytes)

Double (8 bytes)

Strings and characters:

Char (2 bytes)

String (10 bytes (fixed) + 2 bytes per character)

Some others:

Boolean (2 bytes)

Date (8 bytes)

Notice that strict type checking does not allow implicit conversion between data types in cases where data might get lost (may implicitly convert from Short to Long, but not from Long to Short).

Control flow

Loops:

For loops


Public Class Hello

  Shared Sub Main()
    Dim i As Short
    
    For i = 1 To 5 Step 1
      System.Console.WriteLine("Hello World...")
      System.Console.WriteLine()
    Next i

  End Sub
End Class

Nested For loop: multiplication table:

 
Public Class Hello
  Shared Sub Main()
    Dim i, j As Short

    For i = 1 To 10 Step 1
      For j = 1 To 10 Step 1
        System.Console.Write(CStr(i * j) + " ")
      Next j
      System.Console.WriteLine()
    Next i

  End Sub
End Class

Notice the use of Write() rather than WriteLine().

Notice how i and j get declared in one Dim statement.

Notice how the new line sits in the outer loop.

Notice how the table is not lined up nicely... we’ll do that later.

Do While loops:


Public Class Hello
  Shared Sub Main()
    Dim i As Short = 1

    Do While i <= 5
      System.Console.WriteLine("Hello World...")
      System.Console.WriteLine()
      i = i + CShort(1)
    Loop

  End Sub
End Class

Nested Do While loop: multiplication table:


Public Class Hello
  Shared Sub Main()
    Dim i, j As Short
    i = 1

    Do While i <= 10
      j = 1
      Do While j <= 10
        System.Console.Write(CStr(i * j) + " ")
        j = j + CShort(1)
      Loop
      System.Console.WriteLine()
      i = i + CShort(1)
    Loop

  End Sub
End Class

Do Until loops:


Do
  some code
  some imore code
Loop Until <condition>

Decision Making: If statement

Decide if a number is prime (make sure you understand the logic of the code below. For instance, note that is_prime() returns a Boolean):

Public Class Hello

  Shared Sub Main()
    Dim count As Short = 1
    Dim number As Integer = 1

    Do While count <= 100
      If is_prime(number) = True Then
        System.Console.WriteLine(CStr(count) + ": " + CStr(number))
        count = count + CShort(1)
      End If
      number = number + 1
    Loop
  End Sub

  Shared Function is_prime(ByVal number As Integer) As Boolean
    Dim Root As Double
    Dim i As Integer

    If number < 4 Then
      Return True
    End If
    If number Mod 2 = 0 Then
      Return False
    End If

    Root = Math.Sqrt(number)
    For i = 3 To CInt(Root) Step 2
      If number Mod i = 0 Then
        Return False
      End If
    Next i

    Return True
  End Function
End Class

Notice how the above program is very inefficient.; e.g., it checks each number, even numbers that are even. Could you modify it so that it does not check even numbers?

Arrays:

Memory construct to hold a 'row' of variables of identical type; e.g. 10 shorts

Dim i(9) as Short

Gives you 10 shorts all addressed by referring to i.

Note!!! the 9 in Dim i(9) denotes the upper bound of the array!

How to get to individual ones? Index into the array using a subscript.

i(1) = 45
i(2) = 45

Store and print the first 100 multiples of 2:


Public Class Hello
  Shared Sub Main()
    Dim i(99), j As Short

    For j = 0 To 99 Step 1
      i(j) = CShort(2) * (j + CShort(1))
    Next j

    For j = 0 To 99 Step 1
      System.Console.Write(CStr(i(j)) + " ")
    Next j

  End Sub
End Class

Notice how the array element subscripts start at 0 (as in C/C++/Java) and how this forces us to add 1 to j when doing the arithmetic.

Also note how VB.NET forces us to explicitly convert 1 and 2 into shorts using the CShort() function.

What happens when you violate the bounds of your array:
- When reading: garbage results (try it!).
- When writing: who knows?

Two-dimensional arrays: store a 10 * 10 multiplication table in a 2-dimensional array, then print to the screen:


Public Class Hello
  Shared Sub Main()
    Dim table(9,9), i,j As Short

      For i = 0 To 9 Step 1
        For j = 0 To 9 Step 1
          table(i,j) = (i+1) * (j+1)
        Next j
      Next i

      For i = 0 To 9 Step 1
        For j = 0 To 9 Step 1
          System.Console.Write(CStr(table(i,j)) + " ")
        Next j
        System.Console.WriteLine()
      Next i

  End Sub
End Class

Passing arrays to subroutines and functions

By reference: a reference to the array is passed (this is how you pass arrays in C; by means of a pointer/address): Fill a small array in Main(); then pass it to a subroutine to have each of its elements doubled:


Public Class Hello
  Shared Sub Main()
    Dim i(4), j As Short

    For j = 0 To 4 Step 1
      i(j) = CShort(2) * (j + CShort(1))
    Next j

    For j = 0 To 4 Step 1
      System.Console.Write(CStr(i(j)) + " ")
    Next j

    do_this(i, 4)

    For j = 0 To 4 Step 1
      System.Console.Write(CStr(i(j)) + " ")
    Next j
  End Sub

  Shared Sub do_this(ByRef num() As Short, ByVal length As Short)
    Dim i As Short

    System.Console.WriteLine()
    For i = 0 To length Step 1
      num(i) = num(i) * CShort(2)
    Next i
  End Sub

End class

By value: an array of references back to the elements in the original is passed. This is not possible in C: same code as above; just change ByRef into ByVal.

Notice!! Works either way but is not at all the same!!! Passing an array ByVal generates an array with references to the elements of the original array on the receiving end (weird!!), whereas passing the array ByRef generates a single reference back to the array held by the caller. There is almost never a good reason to pass an aray ByVal.

Passing a two-dimensional array to a subroutine where it's printed out (notice the notation for receiving this array in the subroutine):


Public Class Hello
  Shared Sub Main()
    Dim table(9,9), i,j As Short

    For i = 0 To 9 Step 1
      For j = 0 To 9 Step 1
        table(i,j) = (i+1) * (j+1)
      Next j
    Next i

    print_them_out(table)
  End sub

  Shared Sub print_them_out(ByRef table(,) as Short)
    Dim i, j as Short

    For i = 0 To 9 Step 1
      For j = 0 To 9 Step 1
        System.Console.Write(CStr(table(i,j)) + " ")
      Next j
      System.Console.WriteLine()
    Next i
  End Sub
End Class

Note that an array can be queried to provide its upper bound using the notation:

array_name.GetUpperBound(array_dimension_for_which_the_upper_bound_is_needed)

I/O: Input Output: Getting external information to and from your program:

Write() and WriteLine() are output functions. Information is sent from your program to an output device, in this case, the console window.

Programs read from (input) and write to (output) so-called I/O streams. I/O streams can be 'hooked up' to a device, e.g., printer, file, port, etc.

Example: Get an integer from the keyboard and print it to the console:


Public Class Hello
  Shared Sub Main()
    Dim i As Short

    System.Console.WriteLine("give me an integer")
    System.Console.WriteLine()
    i = CShort(System.Console.ReadLine())
    System.Console.WriteLine()
    System.Console.WriteLine("You gave me: " + CStr(i))
    System.Console.WriteLine()
  End Sub
End Class

Notice how the return value from ReadLine() (a string) must be converted into a Short before assigning it to i.

The string version:


Public Class Hello
  Shared Sub Main()
    Dim str As String

    System.Console.WriteLine("give me a name")
    System.Console.WriteLine()
    str = System.Console.ReadLine()
    System.Console.WriteLine()
    System.Console.WriteLine("You gave me: " + str)
    System.Console.WriteLine()
  End Sub
End Class

Notice how the string str, is not declared as an array. in VB.NET strings are objects of the so-called string class. This is very(!!) different from C.

File I/O:


Public Class Hello
  Shared Sub Main()

    'Declare two streams (FileStream) for the input and output files:
    Dim InFile As IO.FileStream
    Dim OutFile As IO.FileStream
    Dim my_int As Short

    'Declare StreamReader and StreamWriter for reading and writing:
    Dim Reader As IO.StreamReader
    Dim Writer As IO.StreamWriter

    'Open the streams by hooking them up to the files:
    InFile = New IO.FileStream("c:\temp\in.txt", IO.FileMode.Open, IO.FileAccess.Read)
    OutFile = New IO.FileStream("c:\temp\out.txt", IO.FileMode.OpenOrCreate, IO.FileAccess.Write)

    'Connect the StreamReader and StreamWriter to the streams:
    Reader = New IO.StreamReader(InFile)
    Writer = New IO.StreamWriter(OutFile)

    'Read And Write the integer from and to the Reader/Writer
    my_int = CShort(Reader.ReadLine())
    Writer.WriteLine(CStr(my_int))

    'Close the Reader and Writer
    Reader.Close()
    Writer.Close()

  End Sub
End Class

Now go check the files!

Note the line continuation characters. (_)

Note the comment lines. (')

Exception/Error Handling

What to do if the input file c:\temp\in.txt is not present?

Remove c:\temp\in.txt and rerun the program. What do you observe?

Unhandled Exception: System.IO.FileNotFoundException

Program dies!

Notice that there is no error in the code itself; the problem is that the code does not cover for this situation.

Golden rule of programming: !!! your program should never, never, ever die !!!

Include exception detection and handling in your code


Public Class Hello
  Shared Sub Main()
    Dim my_int As Short
    Dim InFile As IO.FileStream
    Dim OutFile As IO.FileStream
    Dim Reader As IO.StreamReader
    Dim Writer As IO.StreamWriter

    Try
      InFile = New IO.FileStream("C:\temp\in.txt", IO.FileMode.Open, IO.FileAccess.Read)
    Catch Ex As Exception
      System.Console.WriteLine("Error opening 'in' file...")
      System.Environment.Exit(1)
    End Try

    Try
      OutFile = New IO.FileStream("C:\temp\out.txt", IO.FileMode.OpenOrCreate, IO.FileAccess.Write)
    Catch Ex As Exception
      System.Console.WriteLine("Error opening 'in' file...")
      System.Environment.Exit(1)
    End Try

    Reader = New IO.StreamReader(InFile)
    Writer = New IO.StreamWriter(OutFile)
    my_int = CShort(Reader.ReadLine())
    Writer.WriteLine(CStr(my_int))
    Reader.Close()
    Writer.Close()

  End Sub
End Class

Notice the Try ... Catch ... End Try blocks.

Notice how we return the exit status of the program to the OS (nonzero for programs that run into a 'lethal' exception).

Notice that hardwiring the absolute path of the file in the code is bad!!! It is done here for demonstrative purposes only. Always!!! write your code so that it is entirely independent of the local file/machine system.

The Visual Studio.NET Debugger

As in most integrated development environments (IDEs), VS.NET contains a debugger for stepping through code and for inspecting the contents of variables and memory as the program runs.

When you 'build' your VB.NET program, debug information is automatically linked into your code; i.e., the compiler registers the various instructions to particular lines in the source file. Although you can run the debugger stand-alone, it is handy using it from inside the IDE.

To run your program in the debugger, first decide where in your code you want to interrupt its execution. In the IDE, click your left mouse button at the very beginning of that line (in the narrow, gray, vertical band at the left of the text editor) and notice how the line is now marked as a so-called 'breakpoint.' You can set multiple breakpoints.

To now activate the debugger select Start from the Debug menu. The application will run but execution will be interrupted as the debugger reaches one of your breakpoints. At this point you can mouse over your variables and have their value displayed. For more complex variables, such as arrays, you can have them displayed by selecting them with the mouse and then selecting the QuickWatch... option from the Debug menu.

Once you're ready to move on to the next set of instructions, you have several options:

Debug--> Continue will continue execution until the next breakpoint is reached.

Debug --> Step Over will execute the next line of code, but not debug it; i.e., if the next line of code is a function or subroutine call, the function will be executed in its entirety.

Debug --> Step Into will execute the next line of code and debug it; i.e., if the next line of code is a function or subroutine call, the debugger will act as if the first line of code in the function or subroutine has a breakpoint on it.

Debug --> Stop Debugging will quit the debugger (you must stop debugging before you can edit your source code).

Make sure you feel at home with the VS.NET debugger. Debuggers are extraordinarily powerful tools for diagnosing code problems; without using them finding the causes of code problems is very, very laborious work.

Practice exercises

Assignment 1: Program a Tick-Tack-Toe game.

Prompt your user for how many Fibonnaci numbers (0, 1, 1, 2, 3, 5, 8, 13, ...) to compute, then compute them and calculate the average ratio between adjacent numbers (should be close to 1.61804).

Write an HTML multiplication table. Prompt your user to give you the dimensions for the multiplication table (e.g., 10x10, or 5x5, or 10x5). Your program builds an HTML page containing the multiplication table and writes it to a file. Pick it up with your browser to see if the HTML is correct.

The Monty Hall puzzle. Assume you have won a quiz and the quizmaster offers you a choice of three doors. One of the doors hides the prize, the other two doors offer no prizes. You are asked to select a door but not to open it. You tell the quizmaster your choice. The quizmaster then opens one of the doors that you did not select and shows that it does not contain a prize. (S)he now offers you to switch doors; i.e., you can stay with the door you originally selected, or you can switch to the other closed door. Should you switch? The answer to this question is 'yes' and it can be easily proven. However, although not a 'proof' you can write a simple simulator that plays the game a number of times (e.g., 1000) and see what the outcomes of one strategy (not switching) vs. the other strategy (switching) amount to. Note: to write the simulator, you need to draw some random numbers. Use the Help facilities (F1) in VB.NET to figure out how to do this.