Mixed Scope Properties in .Net

Duane Wingett — Thu, 02 Sep 2010 18:06:44 GMT

Mixed Scope Properties in .Net

There may be a time when you want to have mixed scope for your "Getters" and "Setters" in a property. For those of you who are not familiar with the syntax here it is

VB:

Public Property MyProperty as String Get Return _myField End Get Private Set _myField = Value End Set End Property

This example allows a public "Getter" and a private "Setter".

The same can be done in C#:

public string MyProperty
{ get { return _myField;
} private set {
_myField = value;
} }

Hope you find that useful.

Regards,

Dib.

Classic ASP - Introduction to VBScript classes

Duane Wingett — Wed, 09 Apr 2008 19:27:22 GMT

Outline

Background

You may wonder why write an article on classes in VBScript when there are hundreds of articles already on the web about classes? Well, it's because when I first tried to learn about classes I found it hard to visualise and to "get my head around" the concept of using classes let alone finding basic articles showing how to use them within ASP VBScript.

What I hope to acheive with this article is to provide the reader with a basic understanding of classes in a manner that a complete novice programmer, like my self at the time, would find useful and easy to follow. I also hope to provide a first insight into a more object-orientated programming (OOP) approach in VBScript.

Introduction

So what is a class? A class is basically the coding framework we need to enable an object to be created at runtime. A class it's self does not represent any thing, but the object it lets us create can represent any element or entity that we choose, from a real world object like a car, to a virtual object like an XmlCreator for creating XML data files. A class also allows us to encapsulate any code directly relating to the object we wish to create, and abstract this code out of the "presentation layer" (the page HTML).

In our example we are going to create a class which when instantiated will create an object that will represent a car. The code inside the class is split into two main areas; Properties and Methods. A property is a thing that is owned and in a class we treat one exactly as we would a variable. A method is a way of carrying out an action, possibly on values held in the properties, and you will be familiar with these as Functions or Sub Procedures.

In our car example some properties we may have are:

Number of wheels
Colour of paint
Is engine running?
Is clutch engaged?
Current selected gear

Some of the methods we may have are:

Start engine
Stop engine
Depress Clutch
Release Clutch
Select gear

So now we have a basic outline of what a class is let's create one!

Creating our first class

Open your favourite text editor / developement tool, create a new file, save it as classCar.asp and enter the following two lines between the script tags.

<% Class Car End Class %>

"Class Car" defines the name of the class much in the same way that you would define a method "Function AddTax()" but without the parenthesis. As you will no doubt expect "End Class" defines the end of the class, again as you would with a sub or function; "End Sub". With these two lines created we could create our car object using this class in the code of a page, but as there is no functionality within the class yet we will save that for a little later.

Defining Properties

Next we need to define some properties for the object we wish to create but before we can do that we need to define some member level fields to hold the values for the properties. Add the follwing declarations into the top of the class.

<% Class Car 'Member
level fields Private m_intNumberOfWheels 'As
Integer Private m_intCurrentSelectedGear 'As
Integer Private m_strColourOfPaint 'As
String Private m_blnIsEnfgineRunning 'As
Boolean Private m_blnIsClutchEngaged 'As
Boolean End Class %>

I have used an "m_" prefix to my variable names to signify that they are defined at member level, the same level as the properties and methods for the class. You may wish to define your fields with a more current way of thinking as just "_" or maybe without. (Your choice entirely but I found at the time that it helped me keep track of the scope of my variables!) I have also declared the field as "Private" as I do not want them to be "visible" from out side my class. I.e. the page the instantiates the class has no access to these fields.

Now we are going to declare a property for the "Number of wheels"

'Properties Public Property Get NumberOfWheels()
NumberOfWheels = m_intNumberOfWheels End Property Public Property Let
NumberOfWheels(ByVal Value)
m_intNumberOfWheels = Value End Property

You can see that there are two parts to our "Number of wheels" property the first "Get" allows us to retrieve the value stored in it and the second allows us to populate the property with a value. You can see that I have declared both parts of the property as "Public" as I do want this property to be visible from out side the class. Each part of the property is declared just as you would a Function or Sub, along with "End Property" to define the end of the properties functionality. I say functionality, because unlike the static fields that we have declared at the top of the class, a property can hold functionality just like a Sub or Function. At present all the "Get NumberOfWheels" property does return the value held in our m_intNumberOfWheels field. The "Let NumberOfWheels" property allows us to populate the m_intNumberOfWheels field with a value.

Lets add the rest of the properties and see what the code looks like so far.

<% Class Car 'Member
level fields Private m_intNumberOfWheels 'As
Integer Private m_intCurrentSelectedGear 'As
Integer Private m_strColourOfPaint 'As
String Private m_blnIsEngineRunning 'As
Boolean Private m_blnIsClutchEngaged 'As
Boolean 'Properties Public Property Get NumberOfWheels()
NumberOfWheels = m_intNumberOfWheels End Property Public Property Let
NumberOfWheels(ByVal Value)
m_intNumberOfWheels = Value End Property Public Property Get CurrentSelectedGear()
CurrentSelectedGear = m_intCurrentSelectedGear End Property Public Property Let
CurrentSelectedGear(ByVal Value)
m_intCurrentSelectedGear = Value End Property Public Property Get ColourOfPaint()
ColourOfPaint = m_strColourOfPaint End Property Public Property Let
ColourOfPaint(ByVal Value)
m_strColourOfPaint = Value End Property Public Property Get IsEngineRunning()
IsEngineRunning = m_blnIsEngineRunning End Property Public Property Let
IsEngineRunning(ByVal Value)
m_blnIsEngineRunning = Value End Property Public Property Get IsClutchEngaged()
IsClutchEngaged = m_blnIsClutchEngaged End Property Public Property Let
IsClutchEngaged(ByVal Value)
m_blnIsClutchEngaged = Value End Property End Class %>

Now we have some properties for the class we need to create some methods to hold functionality.

Adding functionality

So far we have created a class, defined some private fields to hold values, some public properties to access these values and now we need to add some methods to provide functionality in the class and to work with these values. Methods within a class are written in the same format as you would write one normally within the ASP code of your page, however it is wise to take care of the scope (Public/Private) of the method to restrict it's access from out side of the class where necessary. Anyway, before we start adding our own functionality, willy-nilly, there are two important methods we must first take a look at.

Initialisation and Termination methods

Any code that is present within the "Sub Class_Initialize" method will be fired upon instanciation (creation) of the object. Any code that is present in the "Sub Class_Terminate" method will fire just before the object is destroyed. The "Initialize" method is very useful for instanciating other objects or populating fields with values as soon as the object is created. The "Terminate" method can be used to ensure that any objects instanciated within the class are disposed of correctly before the class is destroyed.

In our Car example we are just going to instanciate the state and values of a few of our private member fields. Add the following code below the class properties.

'Class
Initialisation and Termination Sub Class_Initialize()
m_intNumberOfWheels = 4
m_intCurrentSelectedGear = 0
m_strColourOfPaint = "Blue"
m_blnIsEngineRunning = False m_blnIsClutchEngaged = True End Sub Sub Class_Terminate() ' End Sub

As you can see we have given our car 4 wheels, the colour is blue, we have set the current gear as neutral (well zero!), and the engine is not running and the clutch is engaged.

Right, so now lets give our car some functionality! Add the following methods below the first two.

'Public
methods Public Sub StartEngine() If (m_intCurrentSelectedGear = 0) Or (m_blnIsClutchEngaged = False) Then m_blnIsEngineRunning = True Response.Write "<p>The
engine started." Else Response.Write "<p>You
cannot start the engine if car is in gear unless clutch is dis-engaged!" End If End Sub Public Sub StopEngine()
m_blnIsEngineRunning = False Response.Write "<p>The
engine stopped." End Sub Public Sub DepressClutchPedal()
m_blnIsClutchEngaged = False End Sub Public Sub ReleaseClutchPedal()
m_blnIsClutchEngaged = True End Sub Public Sub SelectGear(ByVal gearNumber) If IsNumeric(gearNumber) Then If (gearNumber
> -1) And (gearNumber
< 6) Then If (m_blnIsClutchEngaged = False) Then m_intCurrentSelectedGear = gearNumber
Response.Write "<p>You
selected gear #" & gearNumber Else Response.Write "<p>You
must select dis-engage the clutch to select a gear" End If Else Response.Write "<p>You
car doesn't have that gear!" End If End If End Sub

We are not really worried about what the actions of the methods are more just to show how they are implemented into the class. The next step is to build a page with that will use our class to create a car object.

Build a page

<%@LANGUAGE="VBSCRIPT" CODEPAGE="1252"%>
<%Option Explicit%>
<!-- #Include File="classCar.asp" -->
<html> <head> <title>Asp Class Example</title> </head>
<body> <% Call RenderCar() %>
</body> </html> <% Private Sub RenderCar() ' End Sub %>

Instanciating an object

The first thing you should notice that we reference the class file by using the "#Include File" method. This "imports" the code from our class file into our page. In the RenderCar method add the following code, then we'll go through it bit by bit.

 Dim MyCar 'As
Car Set MyCar = New Car Response.Write "<p>My
car's colour is " & MyCar.ColourOfPaint Response.Write "<p>My
car has " & MyCar.NumberOfWheels & "
wheels" Response.Write "<p>If
I now paint my car red..."

 MyCar.ColourOfPaint = "Red" Response.Write "<p>My
car's colour is now " & MyCar.ColourOfPaint With MyCar
.StartEngine() .SelectGear(6) .SelectGear(1) .DepressClutchPedal() .SelectGear(1)
.ReleaseClutchPedal() .StopEngine() .StartEngine() .DepressClutchPedal() .StartEngine()
.StopEngine() End With If
Not(MyCar Is Nothing) Then Set MyCar = Nothing End If

Now breaking it down into bite sized chunks... First we declare a new variable "MyCar" to hold an instance of our "Car" object and then set the variable to reference a newly created instance of that object. Note the syntax for setting the reference; unlike setting a value of an integer where we would use intThis = 12, we must use the Set word so Set ThisVariant = ThatObject.

Dim MyCar 'As Car
Set MyCar = New Car

As we used the "Sub New" method in the class to populate some values into the properties as soon as we instanciate the object we can retrieve them right away with... [MyObjectName].[PropertyName] in this case MyCar.ColourOfPaint and MyCar.NumberOfWheels.

Response.Write "<p>My car's colour is " & MyCar.ColourOfPaint
Response.Write "<p>My car has " & MyCar.NumberOfWheels & " wheels"

Now we can change the value of one of our objects properties with [MyObjectName].[PropertyName] = Value. In this case we will change the paint colour to red. MyCar.ColourOfPaint = "Red" and then display the value of the property as before.

Response.Write "<p>If I now paint my car red..."
MyCar.ColourOfPaint = "Red"
Response.Write "<p>My car's colour is now " & MyCar.ColourOfPaint

Next we will call some of the methods of the object. To do this we use [ObjectName].[MethodName]. Also to make the code clearer to read you can use With [ObjectName] and End With blocks. This saves writing out [ObjectName].[MethodName] for each method call. Then you just need to use dot[MethodName] or dot[propertyName]

With MyCar
     .StartEngine()
     .SelectGear(6)
     .SelectGear(1)
     .DepressClutchPedal()
     .SelectGear(1)
     .ReleaseClutchPedal()
     .StopEngine()
     .StartEngine()
     .DepressClutchPedal()
     .StartEngine()
     .StopEngine()
End With

I wont go into the details of what each method does as this should be clear from the method name. What is important is how you access the methods from the page. Please note that any class methods that were declared Private will not be available for use on the page.

Last of all we have to dispose of the object properly to release the memory that the object resided in.

If Not(MyCar Is Nothing) Then
Set MyCar = Nothing
End If

We do this by setting the variable that references the object to reference of Nothing (after of course, checking it was set in the first place).

Multiple instances on one page

So what if we need to have multiple instances on one page? Well all we need to do is declare a different variable to reference each instance.

Dim MyCar 'As
Car Dim YourCar 'As
Car

Set MyCar = New Car Set YourCar = New Car

MyCar.ColourOfPaint = "Black" YourCar.ColourOfPaint = "White"

Response.Write "<p>My
car's colour is " & MyCar.ColourOfPaint Response.Write "<p>Your
car's colour is " & YourCar.ColourOfPaint

You can have as many instances on the page as you like, but each must be referenced from a variable. Try it and see. Remember to clear up all your objects at the end by setting all their references to nothing.

I hope this gives many novice programmers who have not yet used classes in classic asp the inspiration to get on and try it. To me when I started using them it seemed like a lot of effort for what seemed very little gain. But there are many advantages to programming this way, code maintenance of my apps is now much less troublesome, with it being a lot easier to add additional functionality. The code in the pages are now easier to read through as there is little "business logic" embedded within in them, and with all my classes in one folder its easy to find the relevant class and copy it to a new aplication, so developing new applications is getting much quicker. Lastly, but not least is that the transition to ASP.Net if you choose to do it later, will be a little smoother.

Hopefully in the not to distant fututre I will publish an article on using objects wrapped up inside a dictionary object as an alternative to bringing a recordset back to your page or to using GetRows() and arrays. It will also use a dataAccess class to abstract the dataAccess out of the business logic, and get a tiny bit closer to the 'N' tier programming approach.

A point to note

Although in this case I have used Response.Write within the class to output a result, in practice this is not a good idea. One of the advantages of using classes is to abstract out the "Business Logic" of the page from the "Presentation Code" (html) so it is much better practice to populate a property with the results of your method calls and retrieve the value from the property as shown with Response.Write MyCar.ColourOfPaint in the above example.

Please note this is in fact a reprint of the "Classic ASP - Introduction to VBScript classes" article I wrote for Developer Fusion a while back. Thanks for reading this, I hope some of you find it useful. Your comments, good or bad, are as always, very welcome as this was my first ever article.

{ Duane.Wingett } - VB Script

Mixed Scope Properties in .Net