Visual Basic .
NET Fundamentals
Introduction to Visual Studio and [Link]
Visual Basic .NET ([Link]) is an object-oriented programming language developed by Microsoft,
commonly used for creating desktop applications for Windows, but also applicable to a wide
range of other uses.
Visual Studio is the Integrated Development Environment (IDE) used for programming in [Link].
It provides a workspace for writing, debugging, and managing code.
Key IDE Components:
Menu Bar: Contains various options and commands for managing projects and the IDE.
Toolbar: Provides quick access to frequently used commands.
Solution Explorer: Displays the files that make up your application (projects within a solution).
Properties Window: Allows you to view and modify the properties of selected objects (forms,
controls, etc.).
Toolbox: Contains controls (like buttons, text boxes, labels) that can be dragged and dropped
onto a form to build the user interface.
Form Designer: The visual area where you build your application's user interface.
Code Editor: Where you write and edit your [Link] code.
Creating a New Project:
1. Launch Visual Studio.
2. Select "Create a new project."
3. Choose "Windows Forms App" for a Visual Basic project.
4. Give your project a meaningful name and specify a save location.
5. Click "Create."
Understanding Solutions and Projects:
Project: A collection of code files, resources, and settings that make up a single application.
Solution: A container that can hold one or more related projects.
Customizing Visual Studio:
Color Themes: You can change the overall color theme (e.g., Blue, Dark) via Tools > Options.
Fonts and Colors: Customize the appearance of code elements (keywords, comments, etc.)
via Tools > Options > Environment > Fonts and Colors.
Line Numbers: Toggle line numbers in the code editor via Tools > Options > Text Editor > All
Languages > General.
Default File Locations: Set default project save locations via Tools > Options > Projects and
Solutions > Locations.
Basic Programming Constructs
Sequence
Sequence means that each statement in a program or a block of code runs one after another in
the order they appear.
Variables
A variable is a named location in the computer's memory used to temporarily store data while a
program is running.
Declaration: Use the Dim keyword to declare a variable.
Dim variableName As DataType
Naming Conventions:
Use meaningful names.
Avoid spaces and special characters (except underscore).
Names cannot start with a number.
Camel notation (e.g., firstName, txtInput) is common.
Prefixing with a short identifier for the data type (e.g., st for string, i for integer, dbl for
double, b for boolean, lst for list box, lbl for label, txt for text box, btn for button, hey for
array) is a good practice.
Assignment: Use the single equals sign (=) to assign a value to a variable.
variableName = value
Output
MsgBox() function:
Displays a message in a pop-up window.
MsgBox("Hello, World!")
[Link]() method:
An object-oriented way to display messages.
[Link]("Hello, World!")
String Concatenation
Joining strings together using the ampersand (&) operator.
Dim greeting As String = "Hello"
Dim name As String = "Alice"
Dim message As String = greeting & " " & name ' message will be "Hello Alice"
Special Characters for Newlines
vbNewLine: Inserts a newline character, moving subsequent text to the next line in a message
box or other output.
Variable Data Types
Data types specify the kind of data a variable can hold and the operations that can be performed
on it.
String:
Stores text.
Dim stName As String = "Bob"
Integer:
Stores whole numbers (positive or negative).
Dim iCount As Integer = 10
Boolean:
Stores either
True
or
False
. Useful for yes/no conditions.
Dim bIsEnabled As Boolean = True
Decimal:
Stores money values with high precision. Recommended for financial calculations.
Dim price As Decimal = 19.99D (The D suffix denotes Decimal)
Double:
Stores real numbers (numbers with decimal points). Can store a wide range of values with
good precision, but
Decimal
is preferred for money.
Dim dblValue As Double = 3.14159
Date:
Stores date and time values.
Dates must be enclosed in hash symbols (#) and entered in American format (Month/
Day/Year).
Dim dtRegistered As Date = #11/02/2023# (Represents November 2, 2023)
Data Type Conversion (Casting)
Converting data from one type to another.
Implicit Conversion: [Link] automatically converts data types when appropriate (e.g.,
assigning a string "123" to an Integer variable). This can sometimes lead to errors if the
conversion is not possible.
Explicit Conversion:
You manually convert data types using built-in functions.
CInt(value): Converts to Integer.
CDbl(value): Converts to Double.
CStr(value): Converts to String.
IsNumeric(value): Checks if a value can be converted to a number (returns True or False).
Numeric Data Types and Potential Errors:
Integer Division:
Using the backslash (
\
) operator performs integer division, discarding any remainder.
12 \ 5 results in 2.
Modulo Operator (Mod):
Returns the remainder of an integer division.
24 Mod 9 results in 6 (because 24 divided by 9 is 2 with a remainder of 6).
Overflow Exception: Occurs when a numeric value exceeds the maximum limit for its data
type (e.g., entering a number larger than approximately 2 billion into an Integer).
Conversion Errors: Attempting to convert a non-numeric string to a numeric data type will
cause a runtime error. Use IsNumeric to prevent this.
Empty Text Boxes: When converting text box input, an empty string ("") cannot be converted
to a number, causing a runtime error.
User Input
InputBox Function
A simple way to get string input from the user.
Dim userInput As String = InputBox("Prompt message", "Window Title")
Form Controls for Input
TextBox (txt prefix): Allows users to type text. Access the entered text via its .Text property.
Label (lbl prefix): Displays static text to guide the user. Change its displayed text using
the .Text property.
ListBox (lst prefix): Allows users to select an item from a predefined list. Items can be added
programmatically or through the Properties window (Items property). Access the selected
item using .SelectedItem.
Validation
Ensuring user input is valid before processing it.
Use If statements to check conditions (e.g., IsNumeric, range checks).
Provide informative error messages to the user.
Use Exit Sub to stop the procedure if input is invalid.
Control Flow: Selection
Selection allows your program to make decisions and execute different code paths based on
conditions.
If Statement
Executes a block of code only if a specified condition is true.
One-line If:
Executes a single statement.
If condition Then statement
Block If:
Executes multiple statements.
If condition Then
' Code to execute if condition is true
End If
If...Else:
Executes one block of code if the condition is true, and another block if it's false.
If condition Then
' Code if true
Else
' Code if false
End If
If...ElseIf...Else:
Allows for multiple conditions to be checked in sequence.
If condition1 Then
' Code if condition1 is true
ElseIf condition2 Then
' Code if condition2 is true
Else
' Code if all previous conditions are false
End If
Relational Operators
Used to compare values.
= : Equal to
<> : Not equal to
> : Greater than
< : Less than
>= : Greater than or equal to
<= : Less than or equal to
Logical Operators
Used to combine or modify conditions.
And:
Returns
True
if
both
conditions are true.
If score >= 0 And score <= 100 Then ...
Or:
Returns
True
if
at least one
of the conditions is true.
If score < 0 Or score > 100 Then ...
Not:
Reverses the logical state of a condition.
If Not IsNumeric(input) Then ... (Equivalent to If IsNumeric(input) = False Then ...)
Case Sensitivity
String comparisons in [Link] are case-sensitive by default. Use .ToUpper() or .ToLower() on
strings to perform case-insensitive comparisons.
If [Link]() = "YES" Then ...
Select Case Statement
An alternative to If...ElseIf...Else for testing a single variable against multiple possible values or
ranges. Often more readable for such scenarios.
Select Case variableName
Case value1
' Code for value1
Case value2, value3
' Code for value2 or value3
Case minVal To maxVal
' Code for values within the range
Case Else
' Code if no other case matches
End Select
Limitation: Select Case can only test one variable at a time. For complex conditions involving
multiple variables, If statements are necessary.
Control Flow: Iteration (Looping)
Iteration (looping) allows you to execute a block of code repeatedly.
For...Next Loop (Count-Controlled)
Executes a block of code a specific number of times.
For counterVariable = startValue To endValue [Step stepValue]
' Code to repeat
Next [counterVariable]
Step is optional; defaults to 1. Can be used to count up or down.
The counterVariable can be used within the loop.
Do Loops (Condition-Controlled)
Execute a block of code repeatedly based on a condition.
Do While Loop
Condition at the Top:
Do While condition
' Code to repeat (must include logic to eventually make condition false)
Loop
The code inside the loop may not execute if the condition is initially false.
Condition at the Bottom:
Do
' Code to repeat (guaranteed to execute at least once)
Loop While condition
The code inside the loop executes at least once before the condition is checked.
Do Until Loop
Similar to Do While, but the loop continues as long as the condition is false and stops when it
becomes true.
Condition at the Top:
Do Until condition
' Code to repeat
Loop
Condition at the Bottom:
Do
' Code to repeat
Loop Until condition
Key Difference from For...Next: Do loops are "condition-controlled," meaning they repeat based
on a logical condition, not a fixed count. This makes them more flexible for situations where the
number of repetitions is not known in advance (e.g., reading user input until valid data is
entered).
Arrays
Array variables store a collection of related data items of the same type under a single variable
name.
One-Dimensional Arrays
Declaration:
Dim arrayName(upperBound) As DataType
The upperBound is the highest index. Arrays are zero-based, so Dim arr(4) creates an array
with 5 elements (indices 0, 1, 2, 3, 4).
Initialization:
Values are assigned to individual elements using their index.
arrayName(index) = value
Accessing Elements:
Use the index within parentheses.
Dim firstElement As String = arrayName(0)
Iterating:
Use loops (
For...Next
or
Do
loops) to process all elements.
For i As Integer = 0 To [Link] - 1
' Process arrayName(i)
Next
.Length property gives the total number of elements in the array.
Two-Dimensional Arrays
Arrays with rows and columns, like a table.
Declaration:
Dim arrayName(upperXBound, upperYBound) As DataType
upperXBound refers to the columns (first dimension).
upperYBound refers to the rows (second dimension).
Both dimensions are zero-based.
Initialization:
Assign values using both indices (column, row).
arrayName(columnIndex, rowIndex) = value
Accessing Elements:
Use both indices.
Dim dataItem As String = arrayName(2, 1) (Column 2, Row 1)
Iterating:
Typically requires nested loops.
Row-wise Traversal:
Outer loop iterates through rows, inner loop through columns.
For row As Integer = 0 To upperYBound
For col As Integer = 0 To upperXBound
' Process arrayName(col, row)
Next
Next
Column-wise Traversal:
Outer loop iterates through columns, inner loop through rows.
For col As Integer = 0 To upperXBound
For row As Integer = 0 To upperYBound
' Process arrayName(col, row)
Next
Next
Algorithms
Linear Search
An algorithm to find a specific item within a list (array) by sequentially checking each element.
1. Initialize a boolean variable (e.g., bFound) to False.
2. Loop through each element of the array.
3. Inside the loop, compare the current element with the target item.
4. If a match is found:
Set bFound to True.
Optionally, use Exit For to stop searching early (efficiency).
5. After the loop, check the value of bFound. If True, the item was found; otherwise, it was not.
Case-Insensitive Search: Convert both the target item and the array element to the same case
(e.g., using .ToUpper() or .ToLower()) before comparison.
Complex Arithmetic Expressions
Expressions involving multiple arithmetic operators follow a specific order of operations.
Order of Operations (PEMDAS/BODMAS):
1. Parentheses / Brackets
2. Exponents / Orders (powers)
3. Multiplication and Division (from left to right)
4. Addition and Subtraction (from left to right)
Controlling Order: Use parentheses () to explicitly define the order in which operations should
be performed.
Arithmetic Operators:
+ : Addition
- : Subtraction
* : Multiplication
/ : Division (results in a Double or Decimal)
\ : Integer Division (results in an Integer, truncates remainder)
Mod : Modulo (remainder of integer division)
^ : Exponentiation (raised to the power of)
Example:
Dim price As Decimal = 5.0D
Dim quantity As Integer = 10
Dim discount As Decimal = 2.0D
Dim postage As Decimal = 3.0D
Incorrect Calculation (without parentheses):
Dim totalCost As Decimal = price - discount * quantity + postage
Here, discount * quantity (2.0 * 10 = 20.0) is calculated first.
Then, price - 20.0 + postage (5.0 - 20.0 + 3.0 = -12.0) is calculated.
Correct Calculation (with parentheses):
Dim totalCost As Decimal = (price - discount) * quantity + postage
Here, (price - discount) (5.0 - 2.0 = 3.0) is calculated first due to parentheses.
Then, 3.0 * quantity + postage (3.0 * 10 + 3.0 = 33.0) is calculated.
Debugging Code
Debugging is the process of finding and fixing errors in your code.
Breakpoints
Set a breakpoint by clicking in the grey margin to the left of a line of code.
When the program runs, execution will pause at the breakpoint, entering "Debug Mode."
Stepping Through Code
Once in Debug Mode, you can execute code line by line:
Step Into (F8): Executes the current line and steps into any function/subroutine calls.
Step Over: Executes the current line without stepping into function/subroutine calls.
Step Out: Executes the rest of the current function/subroutine and returns to the calling code.
Inspecting Variables
Hovering: While in Debug Mode, hover your mouse cursor over a variable name to see its
current value.
Locals Window: Accessible via Debug > Windows > Locals. Displays all local variables within
the current scope and their values. You can even modify variable values directly in this
window.
Types of Errors
Syntax Errors: Errors in the structure or grammar of the code (e.g., missing parentheses,
misspelled keywords). [Link] usually highlights these with red wavy lines. The program will
not compile/run until fixed.
Runtime Errors (Exceptions): Errors that occur while the program is running (e.g., division by
zero, invalid data conversion, index out of range). These can cause the program to crash
("unhandled exception"). Use techniques like IsNumeric and range checks to prevent them.
Logic Errors: The code runs without crashing but produces incorrect results due to flawed
logic. Debugging tools like breakpoints and stepping are crucial for finding these.
Build Process
Compilation/Building: Before running, Visual Studio attempts to compile (build) your source
code into machine code.
Build Errors: If syntax errors exist, the build will fail, and an "Output" window will list the
errors.
"Last Successful Build": If a build fails, Visual Studio might offer to run the last version of the
program that compiled successfully.