Beginning Visual Basic 2005 Express Edition - From Novice To Professional (2006)

But what if you wanted to give the user the flexibility to set the FullName property and then automatically have it set up the surname and forename values inside the class? Realistically that would be unwise—it’s adding code that you don’t really need into the class. You should have either a writeable property or that SetName() method, not both. For the sake of a full example, though, we’ll go ahead and do just that. We’ll stretch our coding legs a little here and use some of the methods on the string to split a larger string into two parts.

I’ll walk you through this step-by-step, so drink that coffee and keep up.

First, remove the word ReadOnly, and add Set to the property:

Public Property FullName() As String

Get

Return _forename + " " + _surname

End Get

Set(ByVal value As String)

End Set

End Property

Like Get, Set is a method. The difference of course is that Get returns a value (it’s a function), and Set expects one and returns nothing (it’s a subroutine). You automatically get a parameter that you can use in your property Set code called value. This is the value that the user of your class is trying to set into the property.

What you need to do is take this value and get the forename and surname from it. One way to do this is to find the first space in the words, because the surname and forename are always separated by a space. That’s not going to work, though, for “John Wilkes Booth” or “Lee Harvey Oswald.” A better way to do it would be to “split” the string based on spaces:

Set(ByVal value As String)

Dim parts() As String = value.Split(" ")

End Set

It looks terribly complex, but it’s really not. In the case of this Set, value will be a String, and String has a method on it called Split(). The Split() method returns an array of strings (after it has split one string into many, you need a place to store the many different words that result).

Split() expects to be passed a list of all the possible things that could be used to split the string. We’re interested only in spaces. We pass just one value into Split()—a space.

So, the result of calling Split() will be that you get an array of strings, called names, that hold the various names in FullName. If you had tried to set the property to John Wilkes Booth, you would have an array of three strings, the first item being John, the second Wilkes, and the third Booth.

We’re interested in only the first and last entries, so all that’s required now is a couple of lines to get just those two entries:

Set(ByVal value As String)

Dim parts() As String = value.Split(" ")

_forename = parts(0)

_surname = parts(parts.Length - 1)

End Set

You just set the _forename member to the first item in the array (remember, the first item in an array is always numbered 0), and set the _surname member to the last item in the array (if you have an array of 10 strings, the last item is item number 9). Even if the user just entered a single name (Jason, for example), Split() would still return a single element array.

That’s all there is to it. All that remains is to change the code in Module1.vb to test it out:

Sub Main()

Dim scientist As New Person() scientist.SetName("Albert", "Einstein")

Console.WriteLine("Fullname = {0}", scientist.FullName)

Dim badguy As New Person() badguy.FullName = "John Wilkes Booth"

Console.WriteLine("Fullname = {0}", badguy.FullName)

Console.ReadLine()

End Sub

Notice that you’re intentionally setting FullName to a three-part name. When you run the program, though, you’ll find that only the forename and surname are used, just as we had hoped. You can see the new output in Figure 4-17.

Public Sub StoreStation(ByVal stationNumber As Integer)

End Sub

Public Sub TuneRadio(ByVal frequency As Double)

End Sub

Public Sub TurnOn()

End Sub

Public Sub TurnOff()

End Sub

Public Sub ChangeVolume(ByVal level As Integer)

End Sub

End Class

As you can see, this is a simple class with a bunch of public methods and properties to enable users of objects from this class to use it.

Now, because these things are public, they can all interact with each other. For example, calling SetStation() would undoubtedly do something to update the NowPlaying property.

Private

Behind the sleek user interface of any car stereo is a complex set of chips, circuits, and wires that make the stereo do its job. You, the user, don’t need to see these things—the public interface of the class provides you with a simple way to control them. However, there will be stuff behind the scenes that all code in the class needs to work with. By expanding the definition of the class, you get this:

Public Class CarStereo

Public CurrentTime As Date

Public NowPlaying As String

Public Sub SetStation(ByVal stationNumber As Integer)

End Sub

Public Sub StoreStation(ByVal stationNumber As Integer)

End Sub

Public Sub TuneRadio(ByVal frequency As Double)

End Sub

Public Sub TurnOn()

End Sub

Public Sub TurnOff()

End Sub

Public Sub ChangeVolume(ByVal level As Integer)

End Sub

Private _tuner As Tuner

End Class

Public Class Tuner

Public Frequency As Double

Public FM As Boolean

Public Sub ChangeFrequency()

End Sub

Public Sub Play()

End Sub

Private Sub ConnectToSpeaker()

End Sub

End Class

Just as your car’s dashboard is made up of various objects, each with its own function, so too is your car stereo. It has a tuner embedded inside, for example, to tune to different radio stations. A tuner is not something anyone would normally want to use outside of the box, but it is a vital component, so in the new code notice how a new class is created, but it’s private. This means that only code that lives inside the same namespace (CarStereo, if you take a look at the top of the source) can use the Tuner class. It’s private to that namespace.

The tuner is a private variable within the Stereo class as well. It’s used by most of the other methods, especially the public ones, within the Stereo, but it’s not exposed as a public part of the interface to the stereo’s user.

You’ll also notice that the Tuner has a private method of its own, called ConnectToSpeaker(). The stereo box itself doesn’t need to know how the Tuner makes noise; it just wants it to do so. The Tuner then has a private method just for hooking up its own output to the stereo’s speaker.

Shared

Shared methods are where my stereo analogy falls down a little. Everything you’ve seen so far in this walk-through is collectively called instance members. You need to create an instance of a class (an object) in order to use instance members, and even then there may be restrictions (Public can be used by anyone, Private cannot). Shared methods, on the other hand, are known as class members. These are methods and properties/variables that can be used without actually generating an object. In addition, shared methods can be public or private. A brochure for stereos, for example, may tell you about the stereo but until you go and buy one (and turn the class into an object), you can’t access the instance members. The brochure, then, could be thought of as being a shared method of the class.

Shared methods in particular are very useful when you need a block of code that you can call over and over but that doesn’t really apply to an instance of a class. A good example (which you’ll come across later in the book) is getting connection info to talk to a database. This is typically a string that’s stored in a config file (a text file) that the application needs to read in order to be able to connect to the database. The signature of the method, at least, would look like this:

Public Class DatabaseStuff

Public Shared Function GetConnectionString() As String

End Function

End Class

This looks pretty much like any other method definition, doesn’t it, with the obvious addition of the word Shared. What this means is that the method can be called like this:

Dim dbString As String = DatabaseStuff.GetConnectionString()

Notice that instead of creating an object from the class first, and prefixing the name of the method with the name of the object, you can just use the class name, in this case DatabaseStuff. No instantiation required.

This is called a shared method. You’ll see a lot more about shared methods throughout the rest of the book, in large part because the starting point for every .NET application is a shared method called Main() that you’ve seen a few times now.

DON’T USE SHARED METHODS EVERYWHERE

At my last job, a company director felt the need to get involved in coding on an internal project. He’d had a lot of experience with classic ASP and Visual Basic, but this was to be his first .NET project.

I kick-started his work and gave him a brief hands-on walk-through of things he should know. Included in that demo, I created a shared method to grab a database connection string, just as I’ve just shown you.

I next saw his code about a month later, and to my horror found he had about 30 classes in his project with every single method being a shared method. This is bad. Don’t do it.

If you use shared methods all the time, you aren’t giving .NET a chance to clean up memory from unused objects (because you are never creating objects, just calling class methods on classes). The net result is that your program bogs down and starts to get slow. More to the point, by using shared methods you are forgoing all the benefits that object-oriented programming can bring you, such as inheritance and encapsulation of data and functionality.

Using shared methods everywhere is an easy trap to fall into if you come from a classic VB background, so be aware of it and try to use them sparingly.

Summary

As usual, we’ve covered a lot in this chapter—more than I had originally planned, in fact. But, it’s all vitally important. Visual Basic 2005 is an object-oriented programming language and so everything you do will make use of the OOP facilities the language provides. By using these tools effectively and really working in a true OOP style, your programs can become a lot easier to maintain, extend, and work on than their non-object-oriented cousins. But, you’ll notice that so far you haven’t really looked at just what is a good way to use these facilities to design a great OOP app. The bad news is that I don’t really have the time or scope to do that in this book. Throughout the rest of this book and especially

in the next chapter (where you’ll look at some of the more advanced OOP features of Visual Basic 2005), I’ll try to coax you toward the good habits and away from the bad. But it’s well worth picking up one or two other books after you have Visual Basic 2005 figured out to get a good grip on just what is, and what isn’t, good OOP design.