Basic Statements [VB/C#] - Printable Version

Basic Statements [VB/C#] - Printable Version

+- Sinisterly (https://sinister.ly)
+-- Forum: Coding (https://sinister.ly/Forum-Coding)
+--- Forum: Visual Basic & .NET Framework (https://sinister.ly/Forum-Visual-Basic-NET-Framework)
+--- Thread: Basic Statements [VB/C#] (/Thread-Basic-Statements-VB-C)

Basic Statements [VB/C#] - Shebang - 07-25-2014

Basic Statements in VB/C#
Written by +.Shebang of +Reverence

Introduction
This is a basic overview of some of the most common (and less common) statements used within VB and C#, which are generally found in most programming languages. Code examples will be provided for both languages so you can learn for either one! There's a table of contents below that should make navigating this thread a little easier. Simply do Ctrl+F, and then the code next to each type of statement. This will allow you to easily jump to the statement you want if you're already familiar with the others.

Table Of Contents
A001: If...Else Statement
A002: Select...Case Statement
A003: Try...Catch...Finally Statement
A004: Using...End Using Statement

A001: If...Else Statement
Basic Layout:

Code:
If <condition> Then
    ' Do something
ElseIf <condition> AndAlso <condition> OrElse <condition> Then
    ' Do something
Else
    ' Do something
End If

Code:
if (condition) {
    // do something
} else if (condition && condition || condition) {
    // do something
} else {
    // do something
}

I'm just going to quickly run through all of the stuff in these statements. Every instance of condition simply shows an area where you are evaluating something, like equal to, less than, or greater than. If is always the first thing that comes in this statement. Else is a generic statement saying that if the first condition is false, the else block will execute. ElseIfs simply provide alternate conditions before it defaults to the else block. AndAlso/&& and OrElse/|| are what to be used when combining conditions. If you want to make sure multiple conditions are met, for example if two boolean values are true, you would use an AndAlso operator. If you only want one condition to be true to execute the block, use an OrElse operator. Using parenthesis in appropriate places can make sure order of operations is followed, so your conditions can be complex, like so:

Code:
If (bool1 = True AndAlso bool2 = False) OrElse (bool3 = False AndAlso int1 = 2)
    ' Do something
End If

Code:
if ((bool1 == true && bool2 == false) || (bool3 == false && int1 == 2)) {
    // do something
}

As you can see, ElseIfs and Elses are allowed to be omitted. However, you must always open with an If condition. Also, if you are in VB you will notice there are And and Or operators as well, but these are not short-circuiting operators. What that means, is when you use an OrElse, if the first condition is true, it will not bother checking the other statement. However, an Or would check both, and then confirm afterwards whether one of them was true. Same goes with And and AndAlso. And and Or are also used for bitwise operations, so it makes more sense to use OrElse and AndAlso.

A002: Select...Case Statement
Basic Layout:

Code:
Select Case <value>
    Case x to y, z, a, b
        ' Do something
    Case c, d, e
        ' Do something
    Case Else
        ' Do something
End Select

Code:
switch (value) {
    case 1:
        // do something
        break;
    case 2:
        // do something
        break;
    default:
        // do something
        break;
}

As you can see, there are a few differences to the statements between the two languages. Each has support for multiple cases, as well as default cases if no other ones are met. However, the one distinct thing you may notice is that each case I showed is closed with a break operator. In C#, if a break is not specified, the cases following the one met will execute regardless, but in VB, all cases automatically have a break at the end. This is an alternative/shorter solution in some cases where an If statement may be necessary.

A003: Try...End Try Statement
Basic Layout:

Code:
Try
    ' Do something
Catch ex As Exception
    ' If error, do this
Finally
    ' Execute this regardless
End Try

Code:
try {
    // do something
} catch (Exception ex) {
    // if error, do this
} finally {
    // execute this regardless
}

Try statements are used to make sure that your code runs smoothly even when presented with errors, so that they can be properly handled. When an error occurs within a try block, the code will automatically default to a blank catch block (in C#. In VB, this is prevented due to being unsafe). Proper practice is to specify specific exceptions for catch statements that are known to possibly occur, and then to include a default catch, ex As Exception. Afterwards, a Finally block is executed if present, however they can be omitted. Keep in mind that if an error occurs, the rest of the code in the Try block that was never executed will not be, so cleaning up in a Finally statement is a good idea to prevent any issues with your application. The next section talks about a specific application of this concept.

A004: Using...End Using Statement
Basic Layout:

Code:
Using obj As New Object
    ' Do something with the above object
End Using

Code:
using (Object obj = new Object()) {
    // do something
}

I will preface this by saying that Using statements are meant solely for objects that implement the IDisposable interface. The Using statement is the simplest way to make sure that objects that use this interface (WebClients and StreamReaders, for example) are disposed of properly. However, these statements do not offer the control of a Try...End Try statement. However, because of how the Using statement works, this will not offer the flexibility of one. Thankfully, the Using statement is simply an adaptation of a Try...End try statement. Below is how the same behaviour can be accomplished with added control:

Code:
Dim obj As New Object
Try
    obj.doWork()
Catch ex As Exception
    ' Handle exception
Finally
    If obj IsNot Nothing Then
        obj.Dispose()
    End If
End Try

Code:
Object obj = new Object();
try {
    obj.doWork();
} catch (Exception ex) {
    // handle exception
} finally {
    if (obj != null) {
        obj.Dispose();
    }
}

Conclusion
Well, that's everything! Hopefully this gave you enough information to use the statements with some knowledge of what actually goes on with them. If you're new, you can look forward to some tutorials I'll put out on loops and a few other things foun in languages based on the .NET Framework.