Changes

Jump to: navigation, search

Visual Basic Modules and Procedures

15 bytes added, 15:09, 9 April 2009
no edit summary
A key part of developing applications using Visual Basic is ensuring that the code is carefully structured. This involves segmenting the code into ''projects'', ''modules'' and ''procedures'' so that it is easy to understand and maintain.
A complete Visual Basic application is typically contained in a single ''project''. Within a ''project'', code is placed in separate code files called ''modules'', and within each ''module'', the Visual Basic code is further separated into self contained and re-usable ''procedures''.
The topic of ''projects'' was covered in [[Creating a New Visual Basic Project]]. In this chapter we will look in detail at Visual Basic modules and procedures.
Visual Basic application source code is structured into ''module'' files with a ''.vb'' suffix. By default, Visual Studio creates a separate module file for each form in an application containing the code to construct the form. For example, the code to create a form called ''Form1'' will be placed in a module file named ''Form1.Designer.vb''. Similarly, any code that has been defined by the developer to handle events from controls in the form will be placed by Visual Studio into a module file called ''Form1.vb''.
When writing additional Visual Basic for an application, the code should ideally be logically grouped to together with other source code in a module file. When we say ''logically grouped'' we mean that the code should be grouped with other code of a similar nature. For example, code to work with files might be placed in a module called FileIO.vb, while mathematical procedures might all reside in a file name named Math.vb. The idea is to ensure Visual Basic code is placed in a file where it make makes sense for it to be located. This will differ between applications, but it is worth investing the time to ensure code is well structured as doing so makes subsequent maintenance of the code by you or other developers much easier.
We mentioned previously that Visual Studio places the code to construct each form in separate module files. We now need to learn how to create a new module in a project to contain our own Visual Basic code. Begin by creating a new Windows Application project in Visual Studio called ''vbModules''. Add two TextBox controls (named value1TextBox and value2TextBox) , and a button (labeled calculateCalculate) to the Form so that appears as follows:
<google>ADSDAQBOX_FLOW</google>
== Visual Basic Code Procedures ==
Visual Basic procedures provide a way to break up code into logical and re-usable sections that can be called from other sections of Visual Basic code. For example, you might have a section of Visual Basic code which that calculates the interest due on a loan. It is also possible that you need to perform this calculation from a number of different places in your application code. Rather than duplicating the code to perform this task at each code location where it is needed, it is more efficient to place the calculation code in a procedure, and then ''call'' that procedure each time it is needed.
Visual Basic provides two types of procedures:
* '''subroutines''' - Subroutines are procedures which perform a task but return no value when completed.
It is especially useful to be able to return values from ''functions''. For example, the function may need to return the result of the task it performed (perhaps the result of a calculation). A function might also return a ''True '' or ''False '' value to indicate when the task was performed successfully. The Visual Basic code which called the function then then act acts based on the returned value.
In the case of both ''subroutines'' and ''functions'', values (known as ''parameters'') may optionally be passed into the procedure.
</pre>
We are now going to add a subroutine called ''DisplayResult'' to this module. For The syntax for a Visual Basic subroutine is as follows:
''scope'' '''Sub''' ''subroutineName(parameters)''<br>
</pre>
Once the above change has been made, press '''F5''' to build and run the application. When the application is running, pressing the button should cause a message window to appear displaying the text "Test Message".
== Passing Parameters to Functions and Subroutines ==
''scope'' '''Function''' ''functionName(parameters)'' '''As''' ''datatype''<br>
The scope value is either ''Private'' or ''Public'' depending on whether the Function is to be accessible from Visual Basic code outside of the current module. ''Function'' is the Visual Basic keyword which that indicates that this is a Function rather than a Subroutine. ''functionName'' is the name of the function. ''parameters'' allows the parameters accepted by this Function to be defined. Finally, ''datatype'' defines the type of value returned by the Function.
With this syntax in mind we can create a Function for our application which that will accept the values from our two text fields as parameters, perform the calculation and return the result as an Integer:
<pre>
</pre>
In the above Function, we accept two strings (value1 and value2)and declare an Integer variable called ''result'' to hold the result of the calculation. We then divide value1 by value2 and multiply the result by 100 to get value1 as a percentage of value2. The result is assigned to the ''result'' variable and then returned to the code which called the function.
The final step, is to modify our Button control ''Click'' event procedure to call the ''PercentageOf()'' function, passing through the Text properties of our two TextBox controls. The result returned by this function is then passed to the ''DisplayResult()'' Subroutine where it is displayed in a message window:

Navigation menu