A Sub statement defines the subroutine's name. It declares the parameters that the subroutine takes as arguments and defines the parameters' data types. Code between the Sub statement and an End Sub statement determines what the subroutine does when it runs.

The syntax for defining a subroutine is as follows:

[attribute_list] [inheritance_mode] [accessibility] _
Sub subroutine_name([parameters]) [ Implements interface.subroutine ]
    [ statements ]
End Sub

The following sections describe the pieces of this declaration.

#Const DEBUG_LIST_CUSTOMERS = True
' #Const DEBUG_LIST_EMPLOYEES = True

Private Sub Form1_Load() Handles MyBase.Load
    ListCustomers()
    ListEmployees()

    txtResults.Select(0, 0)
End Sub

<Conditional("DEBUG_LIST_CUSTOMERS")>
Private Sub ListCustomers()
    txtResults.Text &= "ListCustomers" & vbCrLf
End Sub

<Conditional("DEBUG_LIST_EMPLOYEES")>
Private Sub ListEmployees()
    txtResults.Text &= "ListEmployees" & vbCrLf
End Sub
                                                  

ListCustomers

Private Sub Main()
    Dim A As Integer = 12
    Debug.WriteLine("Main: " & A)
    DisplayDouble(A)
    Debug.WriteLine("Main: " & A)
End Sub

Private Sub DisplayDouble(ByVal X As Integer)
    X *= 2
    Debug.WriteLine("DisplayDouble: " & X)
End Sub

Main: 12
DisplayDouble: 24
Main: 12

Private Sub Main()
    Dim A As Integer = 12
    Debug.WriteLine("Main: " & A)
    DisplayDouble(A)
    Debug.WriteLine("Main: " & A)
End Sub

Private Sub DisplayDouble(ByRef X As Integer)
    X *= 2
    Debug.WriteLine("DisplayDouble: " & X)
End Sub

Main: 12
DisplayDouble: 24
Main: 24

Private Sub DoubleArrayValues(ByVal arr() As Integer)
    ' Double the values.
    For i As Integer = arr.GetLowerBound(0) To arr.GetUpperBound(0)
        arr(i) *= 2
    Next i

    ' Display the values.
    For i As Integer = arr.GetLowerBound(0) To arr.GetUpperBound(0)
        Debug.WriteLine(arr(i))
    Next i
    Debug.WriteLine("----------")

    ' Create a new array of values.
    arr = New Integer() {−1, −2}

    ' Display the values.
    For i As Integer = arr.GetLowerBound(0) To arr.GetUpperBound(0)
        Debug.WriteLine(arr(i))
    Next i
    Debug.WriteLine("----------")
End Sub

Dim the_values() As Integer = {1, 2, 3}
DoubleArrayValues(the_values)

For i As Integer = the_values.GetLowerBound(0) To the_values.GetUpperBound(0)
    Debug.WriteLine(the_values(i))
Next i

2
4
6
----------
−1
−2
----------
2
4
6

Private Sub DoubleArrayValues(ByRef arr() As Integer)

2
4
6
----------
−1
−2
----------
−1
−2

Private Sub Main()
    Dim A As Integer = 12
    Debug.WriteLine("Main: " & A)
    DisplayDouble((A))
    Debug.WriteLine("Main: " & A)
End Sub

Private Sub DisplayDouble(ByRef X As Integer)
    X *= 2
    Debug.WriteLine("DisplayDouble: " & X)
End Sub

Main: 12
DisplayDouble: 24
Main: 12

Private Sub DisplayError(Optional ByVal error_message As String = _
 "An error occurred")
    MessageBox.Show(error_message)
End Sub

Private Sub PlaceOrder(ByVal the_customer As Customer,
 ByVal order_items() As OrderItem)
    ' See if the_customer exists.
    If the_customer Is Nothing Then
        DisplayError("Customer is Nothing in subroutine PlaceOrder")
        Exit Sub
    End If

    ' See if the_customer is valid.
    If Not the_customer.IsValid() Then
        DisplayError()
        Exit Sub
    End If

    ' Generate the order.
    ...
End Sub

Public Sub Sub1(Optional ByVal x? As Integer = Nothing)
    ...
End Sub

Public Sub Sub2(Optional ByVal x As Integer? = Nothing)
    ...
End Sub

Public Sub Sub3(Optional ByVal x As Nullable(Of Integer) = 0)
    ...
End Sub

Public Class DrawableRectangle
    Public Bounds As Rectangle

    Public Sub New(
      Optional ByVal X As Integer = 0,
      Optional ByVal Y As Integer = 0,
      Optional ByVal Width As Integer = 100,
      Optional ByVal Height As Integer = 100
    )
        Bounds = New Rectangle(X, Y, Width, Height)
    End Sub
    ...
End Class

Public Sub FireEmployee(ByVal employee_name As String)
    FireEmployee(employee_name, "Unknown reason")
End Sub

Public Sub FireEmployee(ByVal employee_name As String, ByVal reason As String)
    ...
End Sub

' Display the average of a series of values.
Private Sub DisplayAverage(ByVal ParamArray values()As Double)
    ' Do nothing if there are no parameters.
    If values Is Nothing Then Exit Sub
    If values.Length < 1 Then Exit Sub

    ' Calculate the average.
    Dim total As Double = 0
    For i As Integer = LBound(values) To UBound(values)
        total += values(i)
    Next i

    ' Display the result.
    MessageBox.Show((total / values.Length).ToString)
End Sub

DisplayAverage(1, 2, 3, 4, 5, 6, 7)

DisplayAverage(1, 2, 3, 4, 5, 6, 7)

Dim values() As Double = {1, 2, 3, 4, 5, 6, 7}
DisplayAverage(values)

Public Interface IDrawable
    Sub Draw(ByVal gr As Graphics)
    Function Bounds() As Rectangle
    Property IsVisible() As Boolean
End Interface

Public Class DrawableRectangle
    Implements IDrawable

    Public Function Bounds() As System.Drawing.Rectangle _
     Implements IDrawable.Bounds

    End Function

    Public Sub Draw(ByVal gr As System.Drawing.Graphics) _
     Implements IDrawable.Draw

    End Sub

    Public Property IsVisible() As Boolean Implements IDrawable.IsVisible
        Get

        End Get
        Set(ByVal Value As Boolean)

        End Set
    End Property
End Class

Private Sub ValidatePhoneNumber(ByVal phone_number As String)
    ' Check for a 10-digit phone number.
    If phone_number Like "###-###-####" Then Exit Sub

    ' Check for a 7-digit phone number.
    If phone_number Like "###-####" Then Return

    ' The phone number is invalid.
    MessageBox.Show("Invalid phone number " & phone_number)
End Sub

Functions are basically the same as subroutines, except that they return some sort of value. The syntax for defining a function is as follows:

[attribute_list] [inheritance_mode] [accessibility] _
Function function_name([parameters]) [As return_type] [ Implements interface.function ]
    [ statements ]
End function

This is almost the same as the syntax for defining a subroutine. See the section, "Subroutines," earlier in this chapter for information about most of this declaration's clauses.

One difference is that a function ends with the End Function statement rather than End Sub. Similarly, a function can exit before reaching its end using Exit Function rather than Exit Sub.

The one nontrivial difference between subroutine and function declarations is the clause As return_type that comes after the function's parameter list. This tells Visual Basic the type of value that the function returns.

The function can set its return value in one of two ways. First, it can set its name equal to the value it wants to return. The Factorial function shown in the following code calculates the factorial of a number. Written N!, the factorial of N is N * (N21) * (N22) . . .* 1. The function initializes its result variable to 1, and then loops over the values between 1 and the number parameter, multiplying these values to the result. It finishes by setting its name, Factorial, equal to the result value that it should return.

Private Function Factorial(ByVal number As Integer) As Double
    Dim result As Double = 1

    For i As Integer = 2 To number
        result *= i
    Next i

    Factorial = result
End function

A function can assign and reassign its return value as many times as it wants to before it returns. Whatever value is assigned last becomes the function's return value.

The second way a function can assign its return value is to use the Return keyword followed by the value that the function should return. The following code shows the Factorial function rewritten to use the Return statement:

Private Function Factorial(ByVal number As Integer) As Double
    Dim result As Double = 1

    For i As Integer = 2 To number
        result *= i
    Next i

    Return result
End function

The Return statement is roughly equivalent to setting the function's name equal to the return value, and then immediately using an Exit Function statement. The Return statement may allow the compiler to perform extra optimizations, however, so it is generally preferred to setting the function's name equal to the return value. (Return is also the more modern syntax and has become so common that some developers don't even recognize the other syntax anymore.)

Property procedures are routines that can represent a property value for a class. The simplest kind of property is an auto-implemented property. Simply add the Property keyword to a variable declaration as shown in the following code:

Public Property LastName As String

If you want, you can give the property a default value as in the following code:

Public Property LastName As String = "<missing>"

Behind the scenes, Visual Basic makes a hidden variable to hold the property's value. When other parts of the program get or set the value, Visual Basic uses the hidden variable.

This type of property is easy to make but it has few advantages over a simple variable. You can make the property more powerful if you write your own procedures to get and set the property's value. If you write your own procedures you can add validation code, perform complex calculations, save and restore values in a database, set breakpoints, and add other extras to the property.

A normal read-write property procedure contains a function for returning the property's value and a subroutine for assigning it.

The following code shows property procedures that implement a Value property. The Property Get procedure is a function that returns the value in the private variable m_Value. The Property Set subroutine saves a new value in the m_Value variable.

Private m_Value As Single

Property Value() As Single
    Get
        Return m_Value
    End Get
    Set(ByVal Value As Single)
        m_Value = Value
    End Set
End Property

Although the property is implemented as a pair of property procedures, the program could treat the value as a simple property. For example, suppose that the OrderItem class contains the preceding code. Then the following code sets the Value property for the OrderItem object named paper_item:

paper_item.Value = 19.95

You can add property procedures to any type of object module. For example, you can use property procedures to implement a property for a form or for a class of your own.

It's less obvious that you can also use property procedures in a code module. The property procedures look like an ordinary variable to the routines that use them. If you place the previous example in a code module, the program could act as if there were a variable named Value defined in the module.

For more information on property procedures, see the section "Property Procedures" in Chapter 15.

Extension methods allow you to add a new method to an existing class without rewriting it or deriving a new class from it. To make an extension method, decorate the method declaration with the Extension attribute. Then make a normal subroutine or function that takes one or more parameters. The first parameter determines the class that the method extends. The method can use that parameter to learn about the item for which the method was called. The other parameters are passed into the method so it can use them to perform its chores.

For example, the following code adds a MatchesRegexp subroutine to the String class. The Extension attribute tells Visual Basic that this is an extension method. The method's first parameter is a String so this method extends the String class. The second parameter is a regular expression. The method returns True if the String matches the regular expression.

' Return True if a String matches a regular expression.
<Extension()>
Public Function MatchesRegexp(ByVal the_string As String,
 ByVal regular_expression As String) As Boolean
    Dim reg_exp As New Regex(regular_expression)
    Return reg_exp.IsMatch(the_string)
End function

The following code shows how a program might use this method to decide whether the string stored in variable phone_number looks like a valid 7-digit United States phone number:

if Not phone_number.MatchesRegexp("^[2-9]d{2}-d{4}$") Then
    MessageBox.Show("Not a valid phone number")
End if

Example program ValidatePhone demonstrates the MatchesRegexp extension method. It also uses the MatchesRegexp method to define the following three additional extension methods that determine whether a string looks like a valid 7- or 10-digit United States phone number. These methods simply call the MatchesRegexp method, passing it appropriate regular expressions.

' Return True if a String looks like a 7-digit US phone number.
<Extension()>
Public Function IsValidPhoneNumber7digit(ByVal the_string As String) As Boolean
    Return the_string.MatchesRegexp("^[2-9]d{2}-d{4}$")
End Function

' Return True if a String looks like a 10-digit US phone number.
<Extension()>
Public Function IsValidPhoneNumber10digit(ByVal the_string As String) As Boolean
    Return the_string.MatchesRegexp("^([2-9]d{2}-){2}d{4}$")
End Function

' Return True if a String looks like a 7- or 10-digit US phone number.
<Extension()>
Public Function IsValidPhoneNumberUS(ByVal the_string As String) As Boolean
    Return IsValidPhoneNumber7digit(the_string) OrElse
           IsValidPhoneNumber10digit(the_string)
End function
                                                  

If you build a class and later need to change its features, it's usually easiest to modify its code directly. That will cause less confusion than extension methods, which may lie in some obscure module that seems unrelated to the original class. If you need to add methods to existing classes that you cannot modify directly, such as String and other classes defined by Visual Basic and the .NET Framework, extension methods can be extremely useful.

Lambda functions are functions that are defined within the flow of the program's code. Often they are defined, used, and forgotten in a single statement without ever being given a name.

To define a lambda function for later use, start with the Function keyword. Add the function's name and any parameters that it requires, followed by a single statement that evaluates to the value that the function should return.

Next include either (1) a single statement that evaluates to the value that the function should return, or (2) a function body that ends with an End Function statement.

The following code fragment shows examples of both of these styles. First the program creates a lambda function named square_it that takes parameter n and returns n * n. It then creates a multiline lambda function named factorial that calculates and returns a number's factorial. The code finishes by calling both functions and displaying their results.

Dim square_it = Function(n As Integer) n * n
Dim factorial = Function(n As Integer) As Integer
                    Dim result As Integer = 1
                    For i As Integer = 2 To n
                        result *= i
                    Next i
                    Return result
                End Function

Debug.WriteLine(square_it(5))
Debug.WriteLine(factorial(5))

Example program LambdaFunction contains the following code fragment:

' Define a lambda function that adds two integers.
Dim plus = Function(i1 As Integer, i2 As Integer) i1 + i2

' Get A and B.
Dim A As Integer = Integer.Parse(txtA.Text)
Dim B As Integer = Integer.Parse(txtB.Text)

' Call the lambda function to calculate the result.
txtResult.Text = plus(A, B).ToString
                                                  

This code starts by defining a variable named plus. This variable holds a reference to a lambda function that takes two integers as parameters and returns their sum. The code then gets input values from text boxes and calls the plus function, passing it those values. It converts the result into a string and displays it in the txtResult text box.

This example creates a variable to hold a reference to a lambda function and then invokes the function by using that variable. It could just as easily have invoked the lambda function itself while defining it.

Example program InlineFunction, which is also available for download on the book's web site, demonstrates this in the following line of code. This line defines the function and invokes it without ever saving a reference to it.

txtResult.Text =
    (Function(i1 As Integer, i2 As Integer) i1 + i2)(A, B).ToString

Because lambda functions are declared in a single line of code, they are also called inline functions. A lambda function defined inside a subroutine or function is also sometimes called a nested function.

No matter which method the program uses to define a lambda function, it could then pass the function to another routine that will later call the function. For example, suppose subroutine PerformCalculations takes as a parameter the function it should use to perform its calculations. The following code shows how a program could call subroutine PerformCalculations while passing it the previous lambda functions:

' Define the plus function.
Dim plus = Function(i1 As Integer, i2 As Integer) i1 + i2

' Call PerformCalculations passing it the lambda function.
PerformCalculations(plus)

' Call PerformCalculations passing it an inline lambda function.
PerformCalculations(Function(i1 As Integer, i2 As Integer) i1 + i2)

Inline functions were invented for use by LINQ and are most often used with LINQ. For more information about LINQ, see Chapter 21, "LINQ."

Visual Basic 2010 also adds the ability to write lambda subroutines that are similar to lambda functions except they don't return a value.

The following code defines two named lambda subroutines. The first does all of its work on a single line whereas the second uses the multiline format. After defining the subroutines, the code invokes them to display two messages.

Dim write_msg = Sub(ByRef msg As String) Debug.WriteLine("write_msg: " & msg)
Dim show_msg = Sub(ByRef msg As String)
                   MessageBox.Show("show_msg: " & msg)
               End Sub

write_msg("Hi")
show_msg("Hi again")

As with lambda functions, you can build and pass a lambda subroutine into another routine as a parameter as shown in the following code:

Delegate Sub MsgFunc(ByVal m As String)

Private Sub DisplayMessage(ByVal msg As String, ByVal msg_func As MsgFunc)
    msg_func(msg)
End Sub

Private Sub TestSub()
    DisplayMessage("Hello?", Sub(m As String) MessageBox.Show(m))
End Sub

The code first declares a delegate type named MsgFunc that represents a subroutine that takes a String parameter.

Subroutine DisplayMessage takes as parameters a String and a subroutine of type MsgFunc. It calls the subroutine, passing it the String parameter.

The test subroutine TestSub calls DisplayMessage passing it a String and a lambda subroutine created inline.

If you assign a variable to the value in a variable of a different type, Visual Basic automatically converts the value into the correct type under some circumstances. If you set a Single variable equal to an Integer variable, Visual Basic automatically converts the Integer into a Single.

If Option Strict is off, you can also do the reverse: if you assign an Integer variable equal to a Single variable, Visual Basic converts the Single into an Integer (if it can).

In a similar manner, relaxed delegates let Visual Basic convert method parameters from one data type to another under certain circumstances. If the code invokes a subroutine by using a delegate, Visual Basic tries to convert parameters when it can. Probably the easiest way to understand how this works is to consider an example.

The following code declares a delegate type named TestDelegate. Methods that match this delegate should be subroutines that take a Control as a parameter.

' Declare the delegate type.
Private Delegate Sub TestDelegate(ByVal ctl As Control)

The following code defines three subroutines that take parameters of different types. The first takes an Object as a parameter, the second takes a TextBox, and the third takes no parameters. Note that the first subroutine cannot work if Option Strict is on. Option Strict disallows late binding, so the code cannot use a Text property provided by a generic Object.

' A more general parameter type.
Private Sub Test1(ByVal obj As Object)
    obj.Text = "Test1" ' Needs Option Strict off.
End Sub

' A more specific parameter type.
Private Sub Test2(ByVal text_box As TextBox)
    text_box.Text = "Test2"
End Sub

' Parameter omitted.
Private Sub Test3()
    txtField3.Text = "Test3"
End Sub

The following code declares three variables of the TestDelegate type and sets them equal to the addresses of the three test subroutines:

' Make variables of the delegate type
' hold references to the subroutines.
Private Sub1 As TestDelegate = AddressOf Test1
Private Sub2 As TestDelegate = AddressOf Test2 ' Needs Option Strict off.
Private Sub3 As TestDelegate = AddressOf Test3

The first assignment works even though subroutine Test1 does not exactly match the delegate type. Subroutine Test1 takes an Object as a parameter and TestDelegate takes a Control as a parameter. When Visual Basic invokes the Sub1 variable, it will pass the subroutine a Control object as a parameter because Sub1 has type TestDelegate, and that type takes a Control as a parameter. A Control is a type of Object, so Visual Basic can safely pass a Control in place of an Object parameter. That allows the code assigning Sub1 to the address of subroutine Test1 to work.

The second line of code that assigns variable Sub2 to subroutine Test2 works only if Option Strict is off. When Visual Basic invokes the Sub2 variable, it will pass the subroutine a Control object as a parameter because Sub1 has type TestDelegate, and that type takes a Control as a parameter. Subroutine Test2 takes a TextBox as a parameter, and not every Control is a TextBox. That means at design time Visual Basic cannot tell whether it can safely invoke the Sub2 delegate so, if Option Strict is on, Visual Basic flags this assignment as an error. If Option Strict is off, Visual Basic allows the assignment, although the program will crash if it tries to pass a control that is not a TextBox into Sub2 at runtime.

The final assignment sets variable Sub3 to the address of subroutine Test3. Subroutine Test3 takes no parameters. This is a special case that Visual Basic allows: if the method does not need to use the parameters specified by the delegate, it can omit its parameters. Note that the method must omit all or none of the parameters; it cannot omit some and not others.

The following code invokes the subroutines pointed to by the three TestDelegate variables, passing each a reference to a different TextBox. Sub1 treats txtField1 as an Object, Sub2 treats txtField2 as a TextBox, and Sub3 ignores its parameter completely.

Sub1(txtField1)
Sub2(txtField2)
Sub3(txtField3)
' Test3(txtField3) ' This doesn't work.

The final line of code, that invokes subroutine Test3 directly, doesn't work. Omitting the parameter list from a method only works if you access the method from a delegate. If you call the method directly, the parameter list must match the one declared for the method.

Example program RelaxedDelegates, which is available for download on the book's web site, demonstrates this code.

All of these relaxed delegate rules are somewhat confusing. They give you a little more flexibility, but they can make the code a lot more confusing. You may wonder why you should bother. In fact, if you use delegates such as those shown in this example, you might want to avoid using relaxed delegates to keep the code easier to understand.

These rules also apply to event handlers, and in that context they are fairly useful. They let you change an event handler's parameter types to make them more general or more specific, or to omit them.

The following code shows a simple, standard Button Click event handler. It takes two parameters of types Object and EventArgs. In this example, the code reads a text file into a text box.

Private Sub btnLoad_Click(ByVal sender As System.Object,
 ByVal e As System.EventArgs) Handles btnLoad.Click
    txtContents.Text = System.IO.File.ReadAllText(txtFile.Text)
End Sub

Many event handlers must deal explicitly with the control that raised their event. In that case, the first thing the event handler usually does is convert the generic sender parameter from an Object into a more specific control type.

The following code defines a Button Click event handler similar to the previous one but this one declares its sender parameter to be of type Button. This works as long as the event is actually raised by a Button, so the sender parameter really is a button. If you were to attach this event handler to a TextBox's TextChanged event, the program would crash when Visual Basic tries to convert the TextBox into a Button when it raises the event.

' Needs Option Strict off.
Private Sub btnLoad2_Click(ByVal btn As Button,
 ByVal e As Object) Handles btnLoad2.Click
    txtContents.Text = System.IO.File.ReadAllText(txtFile.Text)
End Sub

Note that this version requires Option Strict off. If Option Strict is on, Visual Basic will not allow this subroutine to handle a Button's Click event. This is similar to the way Option Strict prevents you from setting a Button variable equal to a generic Object variable.

The previous code declares its parameters to have a more restrictive type than those passed into it by the control raising the event. You can also make the parameters more general. You could declare the e parameter to be of type Object instead of EventArgs. Usually, that doesn't help you much. It could be useful if you want to use the same event handler to catch different kinds of events that provide different types of arguments, but it's hard to imagine a really good example where that wouldn't be confusing.

A more common situation is where the event handler ignores its parameters completely. Usually each Button has its own Click event handler so you don't need to look at the parameters to figure out which button was clicked.

The following code defines a Button Click event handler that takes no parameters. When the user clicks the btnLoad3 Button, Visual Basic doesn't pass the event handler any parameters. This code is easier to read than the previous versions, partly because the Sub statement fits all on one line.

Private Sub btnLoad3_Click() Handles btnLoad3.Click
    txtContents.Text = System.IO.File.ReadAllText(txtFile.Text)
End Sub

Example program RelaxedEventHandlers, which is available for download on the book's web site, demonstrates relaxed event handlers.

Relaxed delegates may add more confusion than they're worth if you use delegate variables, but they can be useful for simplifying event handlers. Declaring parameters with a more specific type (for example, Button instead of Object) can make the code easier to write and understand, although it has the large drawback of requiring Option Strict off. Omitting parameters when you don't need them is an even better technique. It simplifies the code without forcing you to turn Option Strict off.

A partial method is a private subroutine that is declared in one place and implemented in another. The code includes a subroutine declaration that uses the Partial keyword and that has an empty body. Another part of the class declares the method again, this time without the Partial keyword and providing a method body.

What's the point? Partial methods were invented for the convenience of code generators. The details are somewhat technical and not relevant for developers at this point so they are only briefly considered here.

Partial methods were designed as a more efficient alternative to events. Rather than raising an event for a class to catch, the generated code can call a partial method. If the method has no body, the compiler optimizes the call away and nothing happens, much as would be the case if an object did not catch an event.

The following list summarizes the differences between event handlers and partial methods:

Partial methods are really intended for use by code generators, but it's conceivable that you might find a use for them. It's also worth knowing about them so you know what's going on if you see them in automatically generated code.

Example program PartialMethods uses the following code to define the TestMethod subroutine:

Public Class Form1
    ' Define the TestMethod subroutine without a method body.
    Partial Private Sub TestMethod(ByVal msg As String)

    End Sub

    ' Other code omitted ...
End Class
                                                  

The example uses the following code in a separate module to define the method's body:

Partial Public Class Form1
    ' Define the implementation for TestMethod.
    Private Sub TestMethod(ByVal msg As String)
        MessageBox.Show(msg)
    End Sub
End Class
                                                  

When you click the program's button, the code calls subroutine TestMethod, passing it a string to display. If you comment out the method's body definition, the program ignores this call.

You can achieve results similar to methods without using partial methods in a couple of ways. First, you can make a class raise an event. If no code catches the event, the event is essentially ignored much as a partial method call is ignored if you have not defined the method body.

A second approach is to decorate a method with the Conditional attribute. In that case, Visual Basic removes the method and any calls to it from the code if the condition is not satisfied. The AttributeConditional example program, which is available for download on the book's web site, demonstrates this approach. For more information about that example, see the section "Attribute_List" earlier in this chapter.

Partial methods are also somewhat similar to interfaces, which also define a method's signature but don't provide an implementation.

Finally, partial methods are similar to classes with overridable methods. Any derived classes can override the overridable methods to give them method bodies. If the parent class gives the method a body, the child class can leave it alone and inherit the parent's version as a default.

Partial methods are really intended for use by code generators, but you can use them if you wish.

Subroutines and functions let you break an application into manageable, reusable pieces. A subroutine performs a series of commands. A function performs a series of commands and returns a value.

Property procedures use paired functions and subroutines to provide the behavior of a simple property using routines.

These form the fundamental building blocks of the procedural part of an application. Chapters 25 through 29 explain the other half of an application's structure: the objects that encapsulate the application's behavior. Together, the program's objects and its procedural subroutines and functions define the application.

This chapter explains how to break an otherwise unwieldy expanse of code into subroutines and functions of manageable size. It also explains techniques related to subroutines and functions, such as extension methods and relaxed delegates, that let you use existing classes and events in new ways.

The chapters so far do not explain how to write anything other than straight-line code that executes one statement after another with no deviation. Most programs need to follow more complex paths of execution, performing some statements only under certain conditions and repeating others a given number of times. Chapter 18, "Program Control Statements," describes the statements that a Visual Basic program uses to control the flow of code execution. These include decision statements (If Then Else, Select Case, IIF, Choose) and looping statements (For Next, For Each, Do While, While Do, Repeat Until).