4.1.1 Outline the Fundamentals of Visual Basic.
NET
Program Development Cycle
The program development cycle is the process of creating a program from scratch. It’s like
cooking a meal—you plan, gather ingredients, cook, taste, and tweak until it’s just right. In
VB.NET, the steps are:
1. Planning: Define the problem and design a solution (maybe sketch a flowchart or
pseudocode).
2. Coding: Write the VB.NET code in an editor.
3. Testing: Run the program to see if it works as expected.
4. Debugging: Fix any errors (bugs) that pop up.
5. Maintenance: Update the program as needs change.
Programming Tools
To work with VB.NET, you need a few tools:
- Text Editor: You could write code in Notepad, but it’s not ideal.
- Compiler: Converts your VB.NET code into something the computer understands (machine
language). This is built into the VB.NET environment.
- IDE: The Integrated Development Environment (more on this below) is your all-in-one tool
for coding, testing, and debugging.
The VB.NET IDE
The VB.NET IDE, typically Visual Studio, is your workspace. Think of it as a high-tech
workbench:
- Code Editor: Where you type your code, with helpful features like auto-complete.
- Designer: Drag-and-drop interface for building forms (e.g., buttons, text boxes).
- Solution Explorer: Shows all your project files.
- Toolbox: Contains controls like buttons and labels.
- Properties Window: Lets you tweak settings for your controls.
Fundamentals of Programming in Visual Basic.NET
VB.NET is object-oriented, meaning it’s built around “objects” (like buttons or forms) that
have properties and actions. Here’s the breakdown:
- Identifiers: Names you give to things like variables or functions. Example: `studentName`.
Rules: Must start with a letter, no spaces, and avoid reserved words.
- Keywords: Reserved words with special meanings, like `If`, `Sub`, or `Dim`. You can’t use
these as identifiers.
- Literals: Fixed values in your code, like `42` (integer), `"Hello"` (string), or `True` (boolean).
- Data Types: Define what kind of data a variable holds:
- `Integer`: Whole numbers (e.g., `10`)
- `Double`: Decimal numbers (e.g., `3.14`)
- `String`: Text (e.g., `"VB.NET rocks"`)
- `Boolean`: True or False
- Operators and Expressions: Math and logic tools. Examples:
- Arithmetic: `+`, `-`, `*`, `/`
- Comparison: `=`, `<`, `>`
- Logical: `And`, `Or`, `Not`
- Example: `x = 5 + 3` (expression assigns 8 to `x`).
- Statements: Instructions in your code. Example: `Dim age As Integer = 25` declares a
variable.
Practical Example
vb.net
Dim name As String = "Alice" ' Identifier: name, Literal: "Alice", Data type: String
Dim age As Integer = 20 ' Operator: = assigns value
Console.WriteLine(name & " is " & age) ' Expression with & (concatenation)
4.1.2 Explain General Procedures
Procedures are reusable blocks of code—think of them as mini-recipes within your program.
Sub Procedures
A `Sub` does something but doesn’t return a value. It’s like a command.
```vb.net
Sub SayHello()
Console.WriteLine("Hello, world!")
End Sub
' Call it
SayHello() ' Outputs: Hello, world!
```
With parameters:
```vb.net
Sub Greet(ByVal name As String)
Console.WriteLine("Hi, " & name)
End Sub
Greet("Bob") ' Outputs: Hi, Bob
```
Function Procedures
A `Function` does something and returns a value. It’s like a calculator.
```vb.net
Function Add(ByVal a As Integer, ByVal b As Integer) As Integer
Return a + b
End Function
' Call it
Dim result As Integer = Add(3, 4) ' result = 7
Console.WriteLine(result)
```
Modular Design
This is about breaking your program into smaller, manageable pieces (procedures). Why?
Easier to debug, reuse, and maintain. Example: Instead of one giant block of code to
calculate grades, split it into functions for input, calculation, and output.
4.1.3 Implement Control Structures
Control structures decide how your code flows. They’re the decision-makers and loopers.
Sequence
Code runs line by line, top to bottom. (Hierarchical)
```vb.net
Dim x As Integer = 5
Console.WriteLine(x) ' Outputs: 5
x=x+1
Console.WriteLine(x) ' Outputs: 6
Selection
Make choices with `If` or `Select Case`.
- If Statement:
vb.net
Dim score As Integer = 85
If score >= 60 Then
Console.WriteLine("Pass")
Else
Console.WriteLine("Fail")
End If
- Select Case:
vb.net
Dim day As Integer = 3
Select Case day
Case 1
Console.WriteLine("Monday")
Case 3
Console.WriteLine("Wednesday")
Case Else
Console.WriteLine("Other day")
End Select
Iteration
Loops repeat code.
- For Loop:
vb.net
For i As Integer = 1 To 5
Console.WriteLine("Count: " & i) ' Outputs 1 to 5
Next
- While Loop:
```vb.net
Dim count As Integer = 0
While count < 3
Console.WriteLine("Loop: " & count)
count += 1
End While
- Do Loop:
```vb.net
Dim num As Integer = 0
Do
Console.WriteLine("Number: " & num)
num += 1
Loop Until num = 4
Final example:
```vb.net
Module Module1
Sub Main()
Dim name As String = "Jane"
Dim age As Integer = 22
' Call a sub procedure
DisplayInfo(name, age)
' Call a function
Dim yearsToRetire As Integer = CalculateRetirement(age)
Console.WriteLine(name & " retires in " & yearsToRetire & " years.")
End Sub
Sub DisplayInfo(ByVal n As String, ByVal a As Integer)
Console.WriteLine("Name: " & n & ", Age: " & a)
End Sub
Function CalculateRetirement(ByVal currentAge As Integer) As Integer
Return 65 - currentAge
End Function
End Module
```
Output:
```
Name: Jane, Age: 22
Jane retires in 43 years.
```
