Is it possible to Let and Get with different data types in VBA? - excel

Question

I'm currently working on an Excel VBA Add-In to process a CSV export from one system into the format the stakeholders would like to view it in. I'm fairly new to OOP, but I thought it might be possible to convert priority types within the Let code and have the data stored in the same format it will be output in.
I've written the following class:
'Class Module "Project"
Option Explicit
Private m_sPriority As String
Property Let Priority(lInput As Long)
Select Case lInput
Case 1
m_sPriority = "High"
Case 2
m_sPriority = "Medium"
Case 3
m_sPriority = "Low"
Case Else
m_sPriority = "No Priority"
End Select
End Property
Property Get Priority() As String
Priority = m_sPriority
End Property
And this is the module to test it:
'Standard Module
Option Explicit
Sub test()
Dim Project As Project
Set Project = New Project
Project.Priority = 1
Debug.Print Project.Priority
End Sub
I would expect to see "High" output to the console when running this.
Is there a way to accomplish this in VBA, or alternately, is my code malformed?

Answer 1

Yes, your code is malformed. For whatever it's worth, you can't do that in .NET either - the syntax makes it rather unambiguous, whether in C#:
private string _priority;
public string Priority
{
get { return _priority; }
private set { _priority = value; }
}
...or in VB:
Private _priority As String
Public Property Priority() As String
Get
Return _priority
End Get
Private Set(ByVal value As String)
_priority = value
End Set
End Property
A property is either a Long or a String, it can't be both. Get/Let/Set accessors must be consistent, in VBA as well.
You can cheat by losing type safety and early binding, by making your property a Variant... but that's not really a good way to get started with OOP ;-)
Public Enum PriorityLevel
NoPriority = 0
HighPriority
MediumPriority
LowPriority
End Enum
Private Type InstanceState
Priority As PriorityLevel
'...
End Type
Private this As InstanceState
Public Property Get Priority() As Variant
Priority = PriorityName(this.Priority)
End Property
Public Property Let Priority(ByVal value As Variant)
this.Priority = value
End Property
Private Function PriorityName(ByVal value As PriorityLevel) As String
Select Case value
Case HighPriority
PriorityName = "High"
Case MediumPriority
PriorityName = "Medium"
Case LowPriority
PriorityName= "Low"
Case Else
PriorityName= "Undefined"
End Select
End Function
While this works perfectly fine and looks pretty neat on the surface, consuming this class when you haven't written it is definitely going to be surprising: if you set (Let) a Long, you rightfully expect to Get a Long too. This class is begging for a PriorityName get-only property:
Public Property Get Priority() As PriorityLevel
Priority = this.Priority
End Property
Public Property Let Priority(ByVal value As PriorityLevel)
this.Priority = value
End Property
Public Property Get PriorityName() As String
Select Case this.Priority
Case HighPriority
PriorityName = "High"
Case MediumPriority
PriorityName = "Medium"
Case LowPriority
PriorityName = "Low"
Case Else
PriorityName = "Undefined"
End Select
End Property
Now, the benefits of early binding and type safety (whatever little of it you get to leverage in VBA) are immediately apparent: when you write code that assigns the Priority property of an object of this type, IntelliSense for the Enum type guides the writing of the expression:
Moreover, the Enum is abstracting the underlying numeric value, which becomes irrelevant: instead of a magic hard-coded 1, the code now says HighPriority. Also, the Get accessor is as simple as it gets, which is very good: a Get accessor should never raise any errors, so the simpler, the better.
Morale of the story: don't hack around type safety if you can help it, do everything you can to keep your code early-bound - avoid Object and Variant as much as possible; cast Object to a known class/interface everywhere you can.
For example prefer this:
Dim sheet As Worksheet
' Workbook.Worksheets(index) returns Object; casting it to Worksheet
Set sheet = ActiveWorkbook.Worksheets(1)
sheet.Range("A1").Value = 42
To this:
' "Range("A1").Value" is entirely late-bound. Beware of typos!
ActiveWorkbook.Worksheets(1).Range("A1").Value = 42