Sun, February 18, 2007, 06:26 PM under dotNET
In VB you are always advised to declare all your variables since due to its heritage, VB allowed you not to declare a variable type, which is bad thing:
myVariableName = 6
myVariableName = myVariableNmae + 1
In the code above you were expecting myVariableName
to be 7 when actually it is 1, the reason being that you misspelled your variable. Because you don't have to declare the variable, a new one was created for you when you misspelled it and of course it starts with a value of zero. Crazy world! Luckily, in VB6 and before, you could specify Option Explicit
and that would not allow you to use variables without declaring them... phew. In .NET land with VB 7.0 by default Option Explicit On
is specified for all projects but if people want to be stupid they can turn it off.
Another bad thing you could do in VB6 still remains today and that is the ability to declare untyped variables, for example:
Dim myVariableName = 6
myVariableName = myVariableName + 1
myVariableName = "hello"
o = New Collection
is a Variant
in .NET land) which means it can take any value you want and you never get a compile time error, instead you get a logical error. Similarly for variable o
where the compiler cannot tell you that FeelingLucky
is not a method of the Collection
class so you get a runtime error/exception. So how can you escape this crazy world? A new option in VB 7.0 and beyond is Option Strict
. Unfortunately, to this very day, you have to manually turn this option On
yourself - it is not the default. If you haven't already, do it now for all your projects. You will prevent logical errors at runtime, runtime exceptions *and* you will make your code faster since method calls will be early bound rather than late bound.
Now, there are some niche scenarios where Option Strict Off may be convenient, namely when doing COM Interop with old automation models that are constructed in a certain way or if you have large codebase that already works and you do not want to touch it (hence you do not want to deal with the compile time errors that you will get when you turn option Strict On). The point here is that you can turn this option on/off at the file level. So I suggest that you turn it On at the project level and turn it off for the files that you think could do without the compile time checking.
Before I close this blog post, note that C# does not have either of these options which basically can be seen as that they are both On and you cannot turn them Off. While Option Explicit is useless, the convenience of doing easy late binding in VB with Option Strict Off can be cool. In c#, you have to do explicit late binding using reflection (which is what the VB compiler does for you in the VB case).
For much more on this topic use your favourite search engine i.e. like this
or like that