Classes

The first thing you may notice is that Visual Basic is an object-oriented language and that every program you write is written as a class. However, simple console applications do not have to use a class and instead use a module definition, which resembles a class (it’s very similar). Just think object-oriented when you see the Class keyword and code module when you see the Module keyword. We will see an example of both in this chapter.

UWP applications are implemented using a class definition. A class is more than a simple data structure. You use classes to model concepts that include data and operations on the data. A class can contain private and public definitions (called members) and any number of operations (called methods) that operate on the data and give the class meaning.

You can use classes to break your programs down into more manageable chunks. That is, you can place a class you’ve implemented in its own .vb file and refer to it in any of the code provided there aren’t namespace issues, and even then you simply use the namespace you want.

This is a basic class that is declared with the keyword Class followed by a name. The name can be any identifier you want to use, but the convention is to use an initial capital letter for the name. All classes are defined using a common indentation that defines the body or structure of the class.

By convention, you list the member variables (also called attributes) indented from the class definition. In this example, you see two member variables that are declared as private. You make them private to hide information from the caller. That is, only member methods inside the class itself can access and modify private member variables. Note that derivatives (classes built from other classes—sometimes called a child class) can also access protected member variables.

Notice we don’t have curly braces. Instead, we use the End <keyword> syntax to define a code block. For example, we use End Class to end the class, End Sub, and End Function to define code blocks for methods (Sub) and functions.

Next, you see a special method named New. This is called the constructor. The constructor is a method that is called when the class is instantiated (used). You call the code that defines the attributes and methods a class, and when executed, you call the resulting object an instance of the class.

In this case, the constructor takes a single integer parameter that is used to define the size of the private member variable that stores the array of double values. Notice how this code is used to dynamically define that array. More specifically, you use the ReDim command to reallocate memory for the array.

Next are three public methods, which users (or callers of the instance) can call. The first method, size(), looks as you would expect and in this case simply returns the value of the private member variable sz. The next methods are the get and set operations for storing a double in the array (setValue) and retrieving a specific double from the array using an index (getValue).

Notice that it is easy to read what the code is doing. Neat, eh?

To add a new source file to a Visual Studio Visual Basic solution, simply right-click the project name in Solution Explorer, and then choose Add ➤ New item… and click the Code section on the tree and then choose Class in the List. At the bottom of the dialog, you can name the file. When ready, click the Add button. You can then create any classes you want (or move classes) in the file. You can also use the same namespace to keep all of your classes in the same namespace. However, if you create a new namespace, you must use the using command to use the new namespace. Figure 7-1 shows an example of adding a new class to an existing Visual Basic solution.

As you may have surmised, classes are the building blocks for object-oriented programming, and as you learn more about using classes, you can build complex libraries of your own.

Comments

One of the most fundamental concepts in any programming language is the ability to annotate your source code with text that not only allows you to make notes among the lines of code but also forms a way to document your source code.¹

Writing good comments and indeed documenting your code well is a bit of an art form, one that I encourage you to practice regularly. Since it is an art rather than a science, keep in mind that your comments should be written to teach others what your code does or is intended to do. As such, you should use comments to describe any preconditions (or constraints) of using the code, limitations of use, errors handled, and a description of how the parameters are used and what data is altered or returned from the code (should it be a method or class member).

The Imports Keyword

This is a very common occurrence in Windows Visual Basic applications. In fact, you will use several namespaces in our example project.

The Main() Method

Next, you see the name, main, followed by a list of parameters enclosed in parentheses. For the Main() method, the parameters are fixed and are used to store any command-line arguments provided by the user. In this case, you have the arguments stored in args, which is a string.

A method in Visual Basic is used as an organizational mechanism to group functionality and make your programs easier to maintain (methods with hundreds of lines of code are very difficult to maintain), improve comprehensibility, and localize specialized operations in a single location, thereby reducing duplication.

Methods and functions therefore are used in your code to express the concepts of the functionality they provide. Notice how I used the convertTemp() method. Here, I declared it as a method that returned a double and takes a character and a double as input. As you can see, the body of the method (defined inside the Function ➤ End Function) uses the character as the scale in the same way as you do in main and uses the double parameter as the target (or base) temperature to convert. Since I made the parameters generic, I can use only one variable.

Notice also that I placed it in the line of code that prints the value to the screen. This is a very common practice in Visual Basic (and other programming languages). That is, you use the method to perform some operation, and rather than store the result in a variable, you use it directly in the statements (code).

Conditionals

Conditional statements allow you to direct execution of your programs to sections (blocks) of code based on the evaluation of one or more expressions. There are two types of conditional statements in Visual Basic—the If...Then statement and the Select...Case statement.

While you can chain the statement as much as you want, use some care here because the more ElseIf sections you have, the harder it becomes to understand, maintain, and avoid logic errors in your expressions.

The case values must match the type of the thing you are evaluating. That is, case values must be the same type as scale. Notice I placed Case statements “stacked” so that multiple cases can be directed to the same code block. That is a simple way of achieving that goal. Finally, there is a Case Else section for code you want to execute should scale fail to match any of the values.

Loops

Loops are used to control the repetitive execution of a block of code. There are three forms of loops that have slightly different behavior. All loops use conditional statements to determine whether to repeat execution or not. That is, they repeat as long as the condition is true. The three types of loops are While, Do, and For. I explain each with an example.

The While loop has its condition at the “top” or start of the block of code. Thus, While loops only execute the body (between the While and End While statements) if and only if the condition evaluates to true on the first pass. This form of loop is best used when you need to execute code only if some expression(s) evaluates to true, for example, iterating through a collection of things whose number of elements is unknown (loop until you run out of things in the collection).

The While loop in Visual Basic permits two additional directives. While developers try to structure their code to avoid such constructs, you can control the flow of the While loop using the Exit While and Continue While clauses.

The Exit While does what you expect—it will immediately stop executing any more statements and return control to the next statement after the End While, which is analogous with the break statement from other languages. The Continue While is interesting because it also stops executing any more statements in the loop but instead returns to the While condition (the top of the loop). As you view more Visual Basic examples, you may encounter these clauses.

The Do loop normally places the condition at the “bottom” of the statement which permits the body of the loop to execute at least once. However, the Do loop in Visual Basic has a second form that permits you to add the condition at the “top” of the loop which performs the same as the While loop.

The Do loop in Visual Basic permits two additional directives. While developers try to structure their code to avoid such constructs, you can control the flow of the Do loop using the Exit Do and Continue Do clauses.

The Exit Do does what you expect—it will immediately stop executing any more statements and return control to the next statement after the End Do, which is analogous with the break statement from other languages. The Continue Do is interesting because it also stops executing any more statements in the loop but instead returns to the While condition (the top or bottom of the loop). As you view more Visual Basic examples, you may encounter these clauses.

This form of loop is handy for cases where you want to execute code that, depending on the results of that execution, may require repetition, for example, repeatedly asking the user for input that matches one or more known values, repeating the question if the answer doesn’t match.

The For loop has two forms and is sometimes called a counting loop because of its unique way of executing a loop for a specific number of iterations or through the members of a container.

The first form of the For loop allows you to define a counting variable, a condition to evaluate, and an operation on the counting variable. Instead of an “End” clause, the For loop is defined by Next at the end of the body of the loop. More specifically, the For loop allows you to define stepping code for a precise number of operations, a <start> TO <stop> clause and optional Step <increment> clause that you can use to count by a constant such as counting by 2s, 3s, and so on. This form of loop is best used for a number of iterations for a known number (either at runtime or as a constant) and commonly used to step through memory, count, and so forth.

The For counting loop in Visual Basic permits two additional directives. While developers try to structure their code to avoid such constructs, you can control the flow of the For loop using the Exit For and Continue For clauses.

The Exit For does what you expect—it will immediately stop executing any more statements and return control to the next statement after the Next, which is analogous with the break statement from other languages. The Continue For is interesting because it also stops executing any more statements in the loop but instead returns to the count evaluation. As you view more Visual Basic examples, you may encounter these clauses.

The second form is the For Each loop that iterates through a collection or container and has a slightly different syntax. Instead of a counting variable and optional step clause, we use a variable that contains the type of the things in the collection. For example, if we have a structure (more on those in the next section), we can use the For Each loop to iterate through a list (array) of books.

Now let’s look at some commonly used data structures.

Deploying Your Application (No Debugging)

Deploying your application with a Visual Basic project template is easy. Simply select the build mode, platform, and then device in Visual Studio. In this case, we want to select the Release or Debug build, the ARM platform, and select the Remote Machine entry in the device drop-down as shown in Figure 7-6. For this form of deployment, it doesn’t matter which build mode you choose.

When you select the Remote Machine entry, a Remote Connections dialog will appear that permits you to select the device from a list as shown in Figure 7-7. Simply select the device and click Select to select it.

OK, we’re almost ready to deploy. There is just one more thing to change. I find it helpful to rename the package name using the package manifest. This is the name that will be displayed in the Device Portal. By default, it uses a generated name, but I find renaming it to the same as the project name helpful for easier tracking. Thus, this is an optional step.

If you look at the left side of Visual Studio, you will see one file in the tree view named Package.appxmanifest. Double-click that file to open it. As you will see, it is a set of options you can set for your package. The one we want is on the last tab named Packaging. Click that and change the Package name, as shown in Figure 7-8.

Now all that is left is to deploy the application. Simply click Build ➤ Deploy Solution, and the deploy will begin. If this is the first time you’re deploying the application (or any application) to your device, the deployment could take a while.

Now, you can go to the Device Portal and observe your application in the Apps manager as shown in Figure 7-9. Recall, you can start it by selecting Start from the Actions drop-down box. Go ahead and do that now. You should see your application start, and you can experiment with it.

After a few moments, you will see the application start on your device. If you have all of the wiring complete, you can click the button and observe the LED blinking until you stop it. Cool, eh?

If the LED is not blinking, double-check your wiring and ensure that you chose pin 4 in the code and pin 7 on the pin header (recall that the pin is named GPIO 4, but it is pin #7 on the header for the Raspberry Pi).

When you’re done, you can stop it from the Apps manager in the Device Portal by using the Actions drop-down box and selecting Stop. It may take a few seconds for the status to change from Running to Stopped.

If you want to start the application again, you do not need to redeploy it. The application is installed on the device. To start it, go back to the Device Portal, click Apps, then Apps manager, and then click the Actions drop-down box for the application and click Start.

Should you want to uninstall the application, go back to the Device Portal, click Apps, then Apps manager, and then click the Actions drop-down box for the application and click Uninstall.

And that’s it! Congratulations, you’ve just written your first Visual Basic application that uses the GPIO header to power some electronics!

Now, let’s see how to deploy and debug our application.

Deploy and Debug

If you want to debug your application, you can, but once again it is not the same process we saw with the C++ application. Specifically, we do not need to use the remote debugger. Instead, we can make the same selections from the debug toolbar, selecting the Debug build, the ARM platform, and the Remote Machine from the device drop-down. If you have previously completed the Remote Connections dialog, you will not see that again. If you do see the dialog, make sure to select your device as described earlier and click the Select button.

Before you start the debugger, let’s check a few settings. Most of these should be set correctly, but I’ve seen a couple of situations where the debug settings have changed. If they are not set correctly, you could have difficulty starting the debug session or may receive a series of strange, cryptic messages explaining either the application is already running or the debug symbols cannot be loaded.⁴

To open the debug settings, right-click the project (not the solution) and choose Properties. Then, select the Debug page. The principal settings we need to check include the following. Figure 7-10 shows the correct settings and their values. Be sure your project has the correct settings (the device name should be the name of your device).

• Target device: Remote Machine

• Remote Machine: The name of your device

• (Optional) Uninstall and then re-install: Checked

• (Optional) Deploy optional packages: Checked

• Application process: Managed Only

• Background task process: Managed Only

Notice there are two optional settings. Checking these will ensure your application will always be deployed (thus overwriting previous installations) and all optional packages are included, which may avoid certain dependency issues if you have installed and uninstalled other applications on the device.

Once you make any changes in this dialog, be sure to save your solution. Building or deploying does not automatically save these settings.

OK, now we are ready to debug our application. I find it helpful to place a breakpoint in the code so that when the application starts, I can step through it. Later, you may want to set a breakpoint somewhere in your code to observe certain variables or check for logic errors.

Recall, we set a breakpoint by clicking the left side of the code window in Visual Studio. A breakpoint is indicated with a red dot on the left side of the code window as demonstrated with an arrow in Figure 7-11.

Now we can start the debugging session. Simply click Debug ➤ Start Debugging or click F5. You should see a lengthy set of messages in the output window under the deployment option, but when done, you will see the application running on your device, and it will also be displayed in the Device Portal under the Apps manager. You should also see the interactive debugger start in Visual Studio as shown in Figure 7-12.

Now, you can step through your application using the debug menu. For example, you can step over method calls by clicking F10 or step into methods with F11. Should you want to continue execution, you can click Continue in the debug toolbar. Or, you can stop the debugger using the Stop button or the Debug menu. Figure 7-13 shows what stepping through your code may look like. Yes, this means we can run the application on the device and debug it on our PC. Excellent!

Go ahead and experiment with the application until you are satisfied it is working correctly. When you want to stop it, go to the Device Portal, and click Apps ➤ Apps manager and use the Actions drop-down to stop the application.

If you get errors during the deployment, go back and check all of your settings to ensure you have everything correct. See the Visual Basic Application Deployment Troubleshooting section for more details.

Application Already/Not Running

If you get an error dialog saying the application is already or not running, you should double-check your debug settings for the project as described earlier. This can happen if you’ve deployed the application numerous times or have previous versions installed. Clearing the debug properties selections usually fixes the problem, but if that does not, change the package name or increment the version number, uninstall the application from the device, and restart your deployment.

Failure to Unregister Application

Once you’ve removed the folder, you can deploy your application.

Deploy Succeeds, but Nothing Happens

It is possible you can deploy your application, but it either doesn’t start or doesn’t show up in your Apps manager on the Device Portal.

If Visual Studio reports the deployment succeeded, but the application doesn’t start, that’s OK and normal if you are doing a straight deployment. If you are deploying and debugging expecting the application to start, check the project properties as described earlier and correct any settings that may have changed. You can also attempt to uninstall the application using the App manager before retrying the deployment. If that still doesn’t work, try removing all applications you’ve built previously.

If the application doesn’t show up in the Apps manager, be sure to double-check all of the project settings in Visual Studio as described earlier, and the device is connected and reachable from the Device Portal. Try using the clean and build solution menu options again before attempting to deploy the application.