I'm thinking of starting an ongoing series of posts highlighting some of the more "interesting" things you can do with VB6 that are not, at least to my knowledge, particularly well known. I figure, VB6 has started on that long slow road into SNOBOL-dom, the land where old languages go, not necessarily to die, but to continue living, just with very few people paying any attention. We can only hope C and C++ will head there eventually.
Anyway, might as well collect a few of my favorite hacks, tweaks, and WTF?! bits before they all end up only in the depths of the WayBack machine.
Here's one that you don't see often. If I remember correctly, there is a bit of a performance hit with it, but it's pretty minor.
Did you know a VB module can actually contain properties?
Huh, you say. Interesting, but so what?
Well, since public elements of modules are public project-wide, you can create some pretty handy functions this way.
For instance, say you have a function to read an entire text file in at one shot, and one to write a whole text file. You could have two subs to do the dirty work. Or you could do something like this (put this code in a BAS module, not a class):
Public Property Let FileTextContent(ByVal FileName$, ByRef NewValue$)
'---- Block write the entire file's content in one shot
Dim fh
On Error Resume Next
fh = FreeFile
Open FileName$ For Output As fh Len = 2048
Print #fh, NewValue$;
Close #fh
End Property
Public Property Get FileTextContent(ByVal FileName$) As String
'---- Block read the entire file's content in one shot
Dim buf$
Dim fh
On Error Resume Next
fh = FreeFile
Open FileName$ For Binary Access Read As fh Len = 2048
buf$ = Space$(LOF(fh))
Get #fh, , buf$
Close #fh
FileTextContent = buf$
End Property
With a property like this in place, you can then read a file's content with Just:
x$ = FileTextContent(MyFile$)
Which looks exactly like a function call, granted. But you can write a file's content with:
FileTextContent(MyFile$) = x$
It's a minor syntactic difference from just using two subs, or maybe a sub and a function. But personally, I think it reads a little nicer.
Of course, you can also use this technique to provide for global scope properties, ie properties that don't belong to any particular class. This is sometimes handy when you need to expose a value globally, nut you also want to perform some processing on it during an assignment or a retrieval.
You could define the global property via a GLOBAL variable definition, but that gives you no "hook" to do your processing on the value when code retrieves it or sets it. Instead, use something like this in a BAS module:
Private rMyProp as long
Public Property Let MyProp(Byval NewValue as long)
'---- Block write the entire file's content in one shot
'DO YOUR CODE HERE
rMyProp = NewValue
End Property
Public Property Get MyProp() As Long
'DO YOUR CODE HERE
MyProp = rMyProp
End Property
Now, you have a convenient way to get and set the value from everywhere in your project, AND you have point at which you can hook in to preprocess or post-process the value as necessary.
And, if you name the module something short and sweet, say, like UTILITY, then you'll get handy intellisense as well (just type "UTILITY." to get the props and functions available on it).