Imp, two infrequently used Boolean and bitwise operators
that are present in VB6, have been removed from VB .NET.
Eqv is the logical
equivalence operator. As a Boolean operator, it returns
True if both expressions are either
False, but it returns
False if one is
while the other is
False. As a bitwise operator, it
returns 1 if both bits are the same (that is, if both are 1 or both are 0),
but it returns 0 if they are different. In VB .NET,
Eqv can be replaced with the equals comparison operator
for logical operations. However, for bitwise operations, you'll have to resort
to a bit-by-bit comparison, as the following code fragment shows:
Public Function BitwiseEqv(x1 As Byte, X2 As Byte) _ As Long Dim b1, b2, bRet As Byte Dim iCtr as Integer For iCtr = 0 to len(x1) * 8 - 1 b1 = x1 and 2^iCtr b2 = x2 and 2^iCtr if b1 = b2 then bRet += 2^iCtr next BitwiseEqv = bRet End Function
Imp is the logical
implication operator. As a Boolean operator, it returns
True unless its first expression is
True while the second is
False. As a bitwise operator, it returns 1 unless the bit
in the first expression is 1 while the bit in the second expression is 0. In
Imp can be replaced with a combination of
for logical operations. For example, the code fragment:
bResult = (Not bFlag1) Or bFlag2
is equivalent to the VB6 statement:
bResult = bFlag1 Imp bFlag2
For bitwise operations, a bit-by-bit comparison is again necessary, as the following code fragment shows:
Public Function BitwiseImp(x1 As Byte, X2 As Byte) As Long Dim b1, b2, bRet As Byte Dim iCtr as Integer For iCtr = 0 to len(x1)*8 - 1 b1 = Not(x1) and 2^iCtr b2 = x2 and 2^iCtr if b1 Or b2 then bRet += 2^iCtr end If next BitwiseImp = bRet End Function
VB .NET features a number of changes to the way in which procedures are defined and called, most of which tend to make the language more streamlined and consistent.
In VB 6, parentheses are required around arguments when making
function calls. When calling a subroutine, parentheses are required when using
Call statement and proscribed when not using
In VB .NET, parentheses are always required around a nonempty argument list in any procedure call--function or
subroutine. (In subroutine calls, the
statement is optional.) When calling a parameterless procedure, empty
parentheses are optional.
In VB 6, if the parameters to a function or subroutine were not explicitly prefaced with the ByVal or ByRef keywords, arguments were passed to that routine by reference, and modifications made to the argument in the function or subroutine were reflected in the variable's value once control returned to the calling routine. In VB .NET, on the other hand, if the ByRef or ByVal keyword is not used in a parameter, the argument is passed to the routine by value, and modifications made to the argument in the function or subroutine are discarded once control returns to the calling program.
In VB 6, a procedure parameter can be declared as
Optional without specifying a default value. For optional
Variant parameters, the IsMissing function can be used
to determine whether the parameter is present.
In VB .NET, an optional parameter must declare a default value, which is passed to the procedure if the calling program does not supply an argument for that parameter. The IsMissing function is not supported. The following example shows an optional parameter declaration:
Sub Calculate(Optional ByVal Switch As Boolean = False)
In VB .NET, the
Return statement is
used to return control to the calling program from a function or subroutine.
GoSub statement is not supported. Note that the
Return statement is used to return a value from a
The following function illustrates the
Public Function Test( ) As Integer If MsgBox("Return", MsgBoxStyle.YesNo) = MsgBoxResult.Yes Then Return 0 Else MsgBox("Continue") Return 1 End If End Function
Consider passing a property to a procedure by reference, as in:
Sub ShrinkByHalf(ByRef lSize As Long) lSize = CLng(lSize/2) End Sub Call ShrinkByHalf(Text1.Height)
In VB 6, when passing the value of a property by reference, the property is not updated. In other words, passing a property by reference is equivalent to passing it by value. Hence, in the previous example, the property Text1.Height will not be changed.
In VB .NET, passing a property by reference does update the property, so in this case, the Text1.Height property will be changed. Note, however, that the value of the property is not changed immediately, but rather when the called procedure returns.
In VB 6, if the
ParamArray keyword is
used on the last parameter of a procedure declaration, the parameter can
accept an array of Variant parameters. In addition,
ParamAarray parameters are always passed by
In VB .NET,
ParamArray parameters are
always passed by value, and the parameters in the array may be of any data