Prizes & Awards
My Profile
Active Members
TodayLast 7 Days
more...
|
Resources » Articles » .NET Framework »
The Transition from Visual Basic 6.0 to Visual Basic.NET
|
Introduction
Microsoft Visual Basic.NET is the next version of Microsoft Visual Basic®, built from the ground up on the .NET Framework to enable you to easily create next-generation applications for the Microsoft Windows® operating system and the Web. With Visual Basic.NET, it's a snap to visually develop Web applications, Web Services, Windows applications, and server-side components. In addition, Visual Basic.NET delivers XCOPY deployment of Windows applications, so you no longer need to worry about DLL versioning issues. With Visual Basic.NET, “DLL Hell” is a thing of the past.
When designing Visual Basic.NET, we looked at the top requests of Visual Basic developers worldwide. The Visual Basic language is now truly object-oriented and supports implementation inheritance. The form designer supports visual inheritance and contains new features, such as automatic form resizing, resource localization, and accessibility support. The data tools now inherently support XML data, and the design-time data binding works with disconnected data. In addition, Visual Basic.NET is built directly on the .NET Framework, so you have full access to all of the platform features, as well as interoperability with other .NET languages.
In delivering these features, we have made changes to several aspects of the product. This document describes some of the changes from Visual Basic 6.0 to Visual Basic.NET, and explains the motivation behind them. It also describes capabilities of the Visual Basic.NET Upgrade Wizard, a tool provided as part of the product that will help you upgrade your existing applications to Visual Basic.NET.
Additional information regarding the upgrade from Visual Basic 6.0 to Visual Basic.NET can be found in the white paper Preparing Your Visual Basic 6.0 Applications for the Upgrade to Visual Basic.NET. This paper describes the upgrade process and provides architectural recommendations for making the upgrade as smooth as possible.
Language
Variant
Visual
Basic 6.0 Variant is a special “universal” data type that can contain any kind of data except fixed-length strings. An Object variable is used as a pointer to an object. Variant is the default data type.
Visual Basic.NET
The common language runtime (CLR) uses Object for the universal data type. Visual Basic.NET could have continued to use Variant for the universal data type, but chose to adopt the naming convention of the CLR to avoid confusion for cross-language development. The type system is simplified by having only a single universal data type. The default data type is Object.
Upgrade
Wizard
Variant data types are changed to Object, so the following code:
Dim x As Variant
is upgraded to:
Dim x As Object
Integer and Long
Visual
Basic 6.0 Long variables are stored as signed 32-bit numbers, and Integer variables are stored as 16-bit numbers.
Visual Basic.NET
Long variables are stored as signed 64-bit numbers, Integer variables are stored as 32-bit numbers, and Short variables are stored as 16-bit numbers. On 32-bit systems, 32-bit integer operations are faster than either 16-bit or 64-bit integer operations. This means that Integer will be the most efficient and fundamental numeric type.
As some of the .NET Framework technologies are based around modern 32-bit and 64-bit technologies, it makes sense to update the data sizes to the new technology.
Upgrade
Wizard
The variable types are changed, so the following code:
Dim x As Integer
Dim y As Long
is upgraded to:
Dim x As Short
Dim y As Integer
Currency
Visual
Basic 6.0 Visual Basic 6.0 supports a Currency data type. You cannot declare a variable to be of type Decimal (although variants can have a subtype of Decimal).
Currency variables are stored as 64-bit numbers in an integer format, scaled by 10,000 to give a fixed-point number with 15 digits to the left of the decimal point and 4 digits to the right. This representation provides a range of -922,337,203,685,477.5808 to 922,337,203,685,477.5807.
Decimal variables are stored as 96-bit signed integers scaled by a variable power of 10. The power-of-10 scaling factor specifies the number of digits to the right of the decimal point, and ranges from 0 to 28. With a scale of 0 (no decimal places), the largest possible value is +/-79,228,162,514,264,337,593,543,950,335. With 28 decimal places, the largest value is +/-7.9228162514264337593543950335 and the smallest non-zero value is +/-0.0000000000000000000000000001.
Visual Basic.NET
The Currency data type does not provide sufficient accuracy to avoid rounding errors, so Decimal was created as its own data type.
Upgrade
Wizard
Currency data types are changed to Decimal, so the following code:
Dim x As Currency
is upgraded to:
Dim x As Decimal
Date
Visual
Basic 6.0 A Date variable is stored internally in a Double format and can be manipulated as Double.
Date variables are stored as IEEE 64-bit floating-point numbers that represent dates ranging from 1 January 100 to 31 December 9999 and times from 0:00:00 to 23:59:59. Any recognizable literal date values can be assigned to Date variables.
When other numeric types are converted to Date, values to the left of the decimal represent date information while values to the right of the decimal represent time. Midnight is 0 and midday is 0.5. Negative whole numbers represent dates before 30 December 1899.
Visual Basic.NET
Date variables are stored internally as 64-bit integers, so they cannot be manipulated directly as Double. The .NET Framework provides the ToOADate and FromOADate functions to convert between Double and Date. Representing dates as integers simplifies and speeds up the manipulation of dates.
Upgrade
Wizard
Although not all cases can be detected for example, where a variant is used to store a Date as a Double), the upgrade tool typically inserts the appropriate ToOADate or FromOADate method where a Double is assigned to a Date. For example, the following code:
Dim dbl As Double
Dim dat As Date
Dbl = dat
is upgraded to:
Dim dbl As Double
Dim dat As Date
Dbl = dat.ToOADate
Fixed-length strings
Visual
Basic 6.0 Variables can be declared with a fixed-length string, except for Public variables in a class module.
Visual Basic.NET
Fixed-length strings are not supported in the first version of the CLR. This support will be added in a later version.
Upgrade
Wizard
In most cases, this is not an issue. A compatibility class provides fixed-length string behavior, so the following code:
Dim MyFixedLengthString As String * 100
is upgraded to:
Dim MyFixedLengthString As New VB6.FixedLengthString(100)
See the white paper Preparing Your Visual Basic 6.0 Applications for the Upgrade to Visual Basic.NET for a full discussion of this topic.
Type
Visual
Basic 6.0 The Type statement is used to define a user-defined data type.
Visual Basic.NET
The names Type and User-Defined Type are confusing, because classes, enums, and interfaces are also types that can be defined by users. Type and User-Defined Type are vestiges of QuickBasic, in which structures and records were the only types that a user could define. The CLR uses the name Type in a broad sense to include all data types.
For this reason, the statement Type is changed to Structure in Visual Basic.NET
Upgrade
Wizard
Type statements are changed to Structure, so the following code:
Type MyType
MyVariable As Integer
End Type
is upgraded to:
Structure MyType
Dim MyVariable As Short
End Structure
User-defined type storage
Visual
Basic 6.0 User-defined data types can contain one or more elements of a data type, an array, or a previously defined user-defined type. In Visual Basic 6.0, they are stored in contiguous blocks of memory.
Visual Basic.NET
In the CLR, user-defined types are stored in whatever format is most efficient. This may or may not be a contiguous block of memory. Structures can be marked with marshalling attributes to ensure they are passed to COM components as a contiguous block of memory.
Upgrade
Wizard
APIs are marked with a TODO comment wherever you many need to add marshalling attributes (attributes are not added automatically; they are not needed unless you pass the structures to APIs).
Empty
Visual
Basic 6.0 Variants are initialized to Empty, which automatically converts to zero when used in a numeric expression, or to an empty string when used in a string expression.
Visual Basic.NET
Object variables are initialized to Nothing, which automatically converts to zero when used in a numeric expression, or to an empty string when used in a string expression. Using Nothing instead of a special Empty value reduces complexity in the language and allows for better language interoperability.
Upgrade Wizard
Empty is converted to Nothing.
Null and Null propagation
Visual
Basic 6.0 Null values are Variant subtypes indicating that a variable contains no valid data. Null values "propagate" through expressions and functions. If any part of an expression evaluates to null, the entire expression evaluates to Null. Passing Null as an argument to most functions causes those functions to return Null.
Visual Basic.NET
Null propagation is not supported. The model for programming data with ADO.NET is to test fields explicitly for Null before retrieving their values. Variants containing null are marshalled into the CLR as objects of type DBNull.
Visual Basic.NET makes the rule for Null more intuitive—string functions, such as Left(), always return a string as you would expect.
Upgrade
Wizard
Null values and IsNull functions are commented with an upgrade warning. For example, the following code:
If x Is Null Then MsgBox "Null"
is upgraded to:
' UPGRADE_WARNING: Use of IsNull() detected
If IsDBNull(x) Then MsgBox "Null"
Def
Visual
Basic 6.0 DefBool, DefByte, DefInt, DefLng, DefCur, DefSng, DefDbl, DefDec, DefDate, DefStr, DefObj, and DefVar statements are used at the module level to set the default data type for variables, parameters, and procedure return types whose names start with the specified characters.
Visual Basic.NET
Readability and robustness of code is improved by avoiding the use of implicit type declarations.
Upgrade
Wizard
Explicit declarations of the variable types are inserted into the code. For example, the following code:
DefStr a-z
Sub MySub
s = “Hello”
End Sub
is upgraded to:
Sub MySub
Dim s As String
s = “Hello”
End Sub
Local variables inside blocks
Visual
Basic 6.0 Local variables are visible from the line containing the declaration to the end of the procedure.
Visual Basic.NET
Visual Basic.NET supports block scoping of variables. This means that a local variable is visible from the line containing the declaration to the end of the block in which the declaration appears. For example:
Sub Test(x As Integer)
If x < 0 Then
Dim y As Integer = - x
'...
Else
'...
End If
End Sub
The variable "y" in the example above is available only within the block in which it is declared; specifically, it is available only from its declaration down to the Else statement. If the variable needs to be available to the entire procedure, then it must be declared outside of the If/Else/End If control structure.
Block scoping of variables is a feature common to many structured languages. Just as procedure locals support structured programming by allowing definition of variables that are private to a procedure, block-level variables support structured decomposition by allowing definition of variables that are private to a block of code.
Upgrade
Wizard
If variables are declared inside a block, they are automatically moved to module-level scope. For example, the following code:
If x =1 Then
Dim y As Integer
End If
is upgraded to:
Dim y As Integer
If x =1 Then
End If
New auto-reinstantiation
Visual
Basic 6.0 A class variable declaration of the form "Dim x As New " causes the compiler to generate code on every reference to "x". That code checks to see whether "x" is Nothing; if it is Nothing, a new instance of the class is created. For example, the code:
Dim x As New MyClass
'...
Call x.MyMethod()
is equivalent to:
Dim x As MyClass
'...
If x Is Nothing Then
Set x = New MyClass
End If
Call x.MyMethod()
Even after the variable is set to Nothing, it will be reinstantiated on the next call to it.
Visual Basic.NET
A variable declaration of the form "Dim x As New " is equivalent to "Dim x As = New ". No special code is generated for references to variables that are declared with this syntax.
Visual Basic.NET declarations for "As New" are far more efficient than the same declaration in Visual Basic 6.0. For most references to such variables, the extra overhead is unnecessary. Also, the "auto-instantiation" behavior of Visual Basic 6.0 is a surprise to many programmers when it is discovered.
Upgrade
Wizard
It is rare that this will be an issue. However, if code tries to use a class after it has been set to Nothing, it will cause an easily detectable run-time exception. The code can then be easily modified to instantiate a new version of the class, as in the following example:
Dim x As New MyClass
x = Nothing
x = New MyClass
Object finalization
Visual
Basic 6.0 The COM reference-counting mechanism is used to garbage collect object instances. When objects are not in cycles, reference counting will immediately detect when an object is no longer being used, and will run its termination code.
Visual Basic.NET
A tracing garbage collector walks the objects starting with the reachable references stored in stack variables, module variables, and shared variables. This tracing process runs as a background task, and, as a result, an indeterminate period of time can lapse between when the last reference to an object goes away and when a new reference is added.
In some cases, clients do need the ability to force an object to release its resources. The CLR uses the convention that such an object should implement the IDisposable interface, which provides a Dispose method. When a client has finished using an object with a Dispose method, it can explicitly call the Dispose method so that its resources will be released. For example, an object that wraps a database connection should expose a Dispose method.
The tracing garbage collector can release objects in reference cycles correctly. Also, the performance of the tracing garbage collector is much faster than the performance of reference counting.
Upgrade
Wizard
In most cases, this change will not cause a problem. If you have code that holds a resource handle open (For example., Microsoft SQL Server™ connections or file handles), you should explicitly close the handle. The problem is easily detected and causes a run-time error.
Arrays
Visual
Basic 6.0 Arrays can be defined with lower and upper bounds of any whole number. The Option Base statement is used to determine the default lower bound if a range is not specified in the declaration.
Visual Basic.NET
To enable interoperability with other languages, all arrays must have a lower bound of zero. This makes the Option Base statement no longer necessary.
Upgrade
Wizard
During upgrade, arrays are changed to be zero lower bound, as in the following example:
Dim a(1 To 10) As String
is upgraded to:
'UPGRADE_WARNING: Lower Bound of array a was changed from 1 to 0
Dim a(10) As String
Dim, ReDim, and LBound statements are marked with warnings to help you review the changes.
ReDim
Visual
Basic 6.0 Visual Basic 6.0 has a distinction between fixed-size and variable-size arrays. Fixed-size arrays are declared with the Dim statement, which includes the bounds of the array within this declaration. Dynamic arrays are declared in Dim statements by not specifying bounds information. The dynamic array then needs to be re-dimensioned with the ReDim statement before it can be used. In Visual Basic 6.0, the ReDim statement provides a shorthand way to declare and allocate space for a dynamic array within a single statement. The ReDim statement is the only statement in Visual Basic 6.0 that can be used both to declare and to initialize a variable.
Visual Basic.NET
The ReDim statement is used only for allocating or reallocating the space for an array rather than reallocating the array. This is because all arrays in Visual Basic.NET are dynamic, and a Dim statement can be used in Visual Basic.NET both to declare and to initialize a dynamic array.
Because all variable declarations can both declare and specify an initial value for variables, the use of ReDim to both declare and initialize variables becomes redundant and unnecessary. Requiring that only the Dim statement can be used to declare variables keeps the language simpler and more consistent.
Upgrade
Wizard
If ReDim() is used to declare an array, the appropriate declaration is inserted into the code for you. However, the best practice is to insert the Dim statement into the array first yourself, since using ReDim to declare an array relies on the upgrade tool to infer the correct declaration. Using ReDim also makes for awkward code, since the array is being declared identically in two places.
Assignment
Visual
Basic 6.0 There are two forms of assignment: Let assignment (the default) and Set assignment. Set assignment can be used only to assign object references. The semantics of Let assignment are complex, but can be summarized as follows:
· If the expression on the right-hand side of the Let statement evaluates to an object, the default property of the instance is automatically retrieved and the result of that call is the value that was assigned.
· If the expression on the left-hand side of the Let statement evaluates to an object, the default Let property of that object is called with the result of evaluating the right-hand side. An exception to this rule applies if the left-hand side is a variant containing an object, in which case the contents of the variant are overwritten.
Visual Basic.NET
There is only one form of assignment. "x = y" means to assign the value of variable or property "y" to the variable or property "x". The value of an object type variable is the reference to the object instances, so if "x" and "y" are reference type variables, then a reference assignment is performed. This single form of assignment reduces complexity in the language and makes for much more readable code.
Upgrade Wizard
Set and Let statements are removed. The default properties for strongly typed objects are resolved and explicitly added to the code.
See the white paper Preparing Your Visual Basic 6.0 Applications for the Upgrade to Visual Basic.NET for a full discussion of this topic.
Calling procedures
Visual
Basic 6.0 Two forms of procedure calls are supported: one using the Call statement, which requires parentheses around the list of arguments, and one without the Call statement, which requires that parentheses around the argument list not be used.
It is common in Visual Basic 6.0 for a developer to call a procedure without the call keyword but to attempt to include parentheses around the argument list. Fortunately, when there is more than one parameter, the compiler will detect this as a syntax error. However, when only a single parameter is given, the parentheses around the single argument will have the affect of passing an argument variable as ByVal rather than ByRef. This can result in subtle bugs that are difficult to track down.
Visual Basic.NET
Parentheses are now required around argument lists in all cases.
Upgrade Wizard
Parentheses are inserted for procedure calls that do no have them.
Static procedures
Visual
Basic 6.0 Procedures can be declared with the Static keyword, which indicates that the procedure's local variables are preserved between calls.
Visual Basic.NET
The Static keyword is not supported on the procedure, and all static local variables need to be explicitly declared with the Static statement.
There is very little need to have all the variables within a procedure be static. Removing this feature simplifies the language and improves its readability, because local variables are always stack allocated unless explicitly declared as static.
Upgrade
Wizard
If a procedure is marked as Static, all local variable declarations are changed to Static.
Static Sub MySub()
Dim x As Integer
Dim y As Integer
End Sub
Is upgraded to:
Sub MySub()
Static x As Integer
Static y As Integer
End Sub
Parameter ByVal/ByRef default
Visual
Basic 6.0 Parameters that do not specify either ByVal or ByRef default to ByRef.
Visual Basic.NET
Parameters that do not specify either ByVal or ByRef default to ByVal.
Defaulting to ByVal rather than ByRef eliminates the problem of having a procedure mistakenly modify a variable passed in by the caller. This also makes the default calling convention consistent with assignment, such that parameters are effectively bound to the expressions passed in by an assignment of the expression to the formal parameter.
Note that to avoid confusion for users moving from Visual Basic 6.0 to Visual Basic.NET, the IDE will automatically add the ByVal keyword on any parameter declarations that the user enters without explicitly specifying ByVal or ByRef.
Upgrade
Wizard
ByRef is added to parameters that don't have either a ByVal or ByRef modifier.
IsMissing and optional parameters
Visual
Basic 6.0 Optional Variant parameters with no default values are initialized to a special error code that can be detected by using the IsMissing function.
Visual Basic.NET
Visual Basic.NET requires that a default value be specified for all optional parameters. This simplifies the language by reducing the number of special values in the language.
Upgrade
Wizard
IsMissing functions are replaced with IsNothing functions and are commented with an upgrade warning.
ParamArray parameters
Visual
Basic 6.0 When variables are passed to a ParamArray argument, they can be modified by the called function. ByVal ParamArray elements are not supported.
Visual Basic.NET
When variables are passed to a ParamArray argument, they cannot be modified by the called function. ByRef ParamArray elements are not supported.
A more common scenario for ParamArray arguments is for them not to modify variables that are passed in to them. Not supporting ByRef ParamArray arguments simplifies the ParamArray calling convention by making ParamArray arguments be normal arrays. This enables ParamArray arguments to be extended to any element type and allows functions that expect ParamArray arguments to be called directly with an array rather than an argument list.
Upgrade
Wizard
Procedures that use ParamArray arguments are commented with an upgrade warning. For example, the following code:
Function MyFunction(ParamArray p() As Variant)
'...
End Function
is upgraded to:
' UPGRADE_WARNING: ParamArray p was changed from ByRef to ByVal
Function MyFunction(ByVal ParamArray p() As Object)
'...
End Function
As Any parameters in Declares
Visual
Basic 6.0 A parameter of a native API could be declared "As Any", in which case a call to the native API could pass in any data type. This was supported to enable calling APIs whose parameters supported two or more data types.
Visual Basic.NET
Overloaded Declare statements can be defined so that they allow a native API to be called with two or more data types. For example, the following Declare statement:
Private Declare Function GetPrivateProfileString _
Lib "kernel32" Alias "GetPrivateProfileStringA" ( _
ByVal lpApplicationName As String, _
ByVal lpKeyName As Any, _
ByVal lpDefault As String, _
ByVal lpReturnedString As String, _
ByVal nSize As Integer, _
ByVal lpFileName As String) As Integer
could be replaced with two Declare versions, one that accepts a Integer and one that accepts a string:
Private Declare Function GetPrivateProfileStringKey _
Lib "kernel32" Alias "GetPrivateProfileStringA" ( _
ByVal lpApplicationName As String, _
ByVal lpKeyName As String, _
ByVal lpDefault As String, _
ByVal lpReturnedString As String, _
ByVal nSize As Integer, _
ByVal lpFileName As String) As Integer
Private Declare Function GetPrivateProfileStringNullKey _
Lib "kernel32" Alias "GetPrivateProfileStringA" ( _
ByVal lpApplicationName As String, _
ByVal lpKeyName As Integer, _
ByVal lpDefault As String, _
ByVal lpReturnedString As String, _
ByVal nSize As Integer, _
ByVal lpFileName As String) As Integer
This improves type safety and reduces the chance of a bug causing your program to fail. This can happen because the compiler will not allow the API to be called with data types other than those that it is explicitly defined to accept.
Upgrade
Wizard
Declare statements using As Any parameters are commented with an upgrade warning.
Implements
Visual
Basic 6.0 The Implements statement specifies an interface or class that will be implemented in the class module in which it appears.
The Visual Basic 6.0 model stems from the fact that COM does not actually allow classes to have methods; instead, classes are simply a collection of interface implementations. Visual Basic 6.0 simulates classes with methods by introducing the concept of a default interface. When an Implements statement specifies a class, that class implements the default interface of the class. Unfortunately the default interface concept is not supported in other languages, and any cross-language programming must deal directly with the default interface.
Visual Basic.NET
Implements in Visual Basic.NET is different than in Visual Basic 6.0 in two essential ways:
1. Classes can not be specified in Implements statements.
2. Every method that implements an interface method requires an Implements clause at the end of the method declaration statement. This will specify what interface method it implements.
Visual Basic.NET maintains a strict distinction between interfaces and classes.
Readability is improved by requiring an Implements clause on each method that implements a method in an interface; it is obvious when reading code that the method is being used to implement an interface method.
Upgrade
Wizard
If class "a" implements class "b", the interface is declared for class "b", and class "a" is changed to implement the interface of class "b":
Interface _b
Function MyFunction() As String
End Interface
Class a
Implements _b
Function b_MyFunction() As String Implements _b.MyFunction
End Function
End Class
Property
Visual
Basic 6.0 In Visual Basic 6.0, the Get, Let, and Set property functions for a specific property can be declared with different levels of accessibility. For example, the Property Get function can be Public while the Property Let is Friend.
Visual Basic.NET
The Get and Set functions for a property must both have the same level of accessibility. This allows Visual Basic.NET to interoperate with other .NET languages.
Upgrade
Wizard
If there is a different level of accessibility, the new property is public
Default properties
Visual
Basic 6.0 Any member can be marked as the default for a class.
Visual Basic.NET
Only properties that take parameters can be marked as default. It is common for those properties with parameters to be indexers into a collection.
This makes code more readable, since a reference to an object variable without a member always refers to the object itself, rather than referring to the object in some contexts and to the default property value in other contexts. For example, a statement "Call Display(TextBox1)" might be passing the text box instance to the Display function or it might be passing the contents of the text box.
Also, removing this ambiguity eliminates the need for a separate statement to perform reference assignment. An assignment "x = y" always means to assign the contents of variable "y" to variable "x", rather than to assign the default property of the object that "y" references to the default property of the object that "x" references.
Upgrade
Wizard
Default properties are resolved where possible. Error comments are added where they cannot be resolved (on-late bound objects).
Enumerations
Visual
Basic 6.0 Enumeration constants can be referenced without qualification.
Visual Basic.NET
Enumerations constants can be referenced without qualification if an Import for the enumeration is added at file or project level.
This keeps consistency with classes, structures, and interfaces in which members can be given generic names without a risk of conflict with other members. For example, the Color enumeration and the Fruit enumeration can both contain a constant named Orange. In Visual Basic 6.0, the convention is to prefix enumeration constants to make them unique, which leads to awkward names such as MsColorOrange and MsFruitOrange.
Upgrade
Wizard
References to enumerations are changed to be fully qualified.
While
Visual
Basic 6.0 While statements are ended with a WEnd statement.
Visual Basic.NET
To be consistent with other block structures, the terminating statement for While is now End While. This improves language consistency and readability.
Upgrade
Wizard
WEnd statements are changed to End While.
On…GoTo and On…GoSub
Visual
Basic 6.0 The On expression Goto destinationlist and On expression GoSub destinationlist statements branch to one of several specified lines in the destination list, depending on the value of an expression.
Visual Basic.NET
On…GoTo and On…GoSub are nonstructured programming constructs. Their use makes programs harder to read and understand. Select Case can provide a more structured and flexible way to perform multiple branching.
Note: On Error GoTo is still supported.
Upgrade
Wizard
The following example:
On MyVariable GoTo 100,200,300
is commented with an upgrade error:
' UPGRADE_ISSUE On MyVariable GoTo was not upgraded
On MyVariable GoTo 100,200,300
You should rewrite your code to avoid such statements. For example:
On x Goto 100,200,300
Can be rewritten as:
Select Case x
Case 1: 'Insert the code for line 100
Case 2: 'Insert the code for line 200
Case 3: 'Insert the code for line 300
End Select
GoSub…Return
Visual
Basic 6.0 The GoSub line … Return statement branches to and returns from a subroutine within a procedure.
Visual Basic.NET
GoSub…Return is a nonstructured programming construct. Its use makes programs harder to read and understand. Creating separate procedures that you can call may provide a more structured alternative.
Upgrade
Wizard
As with On...GoTo, these statements are commented with an upgrade error.
LSet
Visual
Basic 6.0 LSet pads a string with spaces to make it a specified length, or copies a variable of one user-defined type to a variable of a different user-defined type.
Visual Basic.NET
The LSet statement is not supported. LSet is not type safe, so it can result in errors at run time. Also, because it is not type safe it requires full trust in order to be executed. Removing the LSet statement discourages the copying of one structure over another; however, you can achieve the same effect by modifying your Visual Basic.NET code to use RtlCopyMemory.
Upgrade
Wizard
This statement:
LSet a1 = a2
It is commented with an upgrade error
' UPGRADE_ISSUE: LSet cannot assign a UDT from one type to another
LSet a1 = a2
VarPtr, StrPtr, and ObjPtr
Visual
Basic 6.0 VarPtr, StrPtr, and ObjPtr return the addresses of variables as integers, which can then be passed to API functions that take addresses, such as RtlCopyMemory. VarPtr returns the address of a variable, StrPtr returns the address of a string, and ObjPtr returns the address of an object. These functions are undocumented.
Visual Basic.NET
The addresses of data items can be retrieved, but retrieval must be done via calls into the CLR. This is because the CLR is normally free to move items within memory, so it needs to know when not to move the item while the address is being used. The following example retrieves the address of an object:
Dim MyGCHandle As GCHandle = GCHandle.Alloc(o, GCHandleType.Pinned)
Dim Address As Integer = CInt(MyGCHandle.AddrOfPinnedObject())
'...
MyGCHandle.Free() 'allows the object instance to be moved again
Allowing data items to be moved by the runtime improves the performance of the runtime.
Upgrade
Wizard
There is no automatic upgrade for these statements, so they are commented with a "(statement) is not supported" upgrade error. For example, the following code:
a = VarPtr(b)
is upgraded to:
' UPGRADE_ISSUE: Function VarPtr() is not supported
a = VarPtr(b)
This also causes a compile error.
File I/O
Visual
Basic 6.0 File I/O statements are included in the language.
Visual Basic.NET
File I/O operations are available only through class libraries. Removing the file I/O statements from the language allows different I/O libraries to be easily used from Visual Basic.NET. This would be more awkward if the file I/O statements were in the language, because identifiers such as Open, Close, Print, and Write would be reserved words.
Upgrade
Wizard
The file I/O statements are upgraded to the corresponding functions. For example, the following code:
Open "MyFile.txt" For Input As #1
is upgraded to:
FileOpen( 1, "MyFile.txt", OpenMode.Input )
Debug.Print
Visual
Basic 6.0 Debug.Print outputs a line of text to the Immediate window.
Visual Basic.NET
In Visual Studio.NET, the Immediate window is replaced with the Immediate and Output windows. The Immediate window is used to enter and display results when an application is in break mode. The Output window shows build information and program output.
Debug.WriteLine outputs a line of text to the Output window. There is also a Debug.Write method that outputs text to the Output window without a linefeed.
Upgrade
Wizard
Debug.Print is upgraded to Debug.WriteLine.
Resource files
Visual
Basic 6.0 Visual Basic 6.0 supports one .res file per project.
Visual Basic.NET
Visual Basic.NET has rich support for resources. Forms can be bound to retrieve resources automatically from the new .resX-formatted resource files. Any CLR class can be stored in a .resX file.
Upgrade
Wizard
Files are upgraded from .res to .resX, and code is changed to load from the .resX files.
Windows Applications
Visual Basic forms
Visual
Basic 6.0 Visual Basic 6.0 has its own forms package for creating graphical Windows applications.
Visual Basic.NET
Windows Forms is a new forms package for Visual Basic.NET. Because Windows Forms is built from the ground up to target the common language runtime (CLR), it can take advantage of all of its features. In particular, because the Windows Forms package takes advantage of the deployment, application isolation, versioning, and code-access security features, you can now build Windows Client applications that are significantly easier to deploy and update. You can even build Windows Forms applications that have the same browser deployment characteristics as HTML. These characteristics, like the granular control of code access security, also make using Windows Forms controls in the browser very compelling.
The Windows Forms set also offers Visual Basic developers many new features, such as visual inheritance, improved localization and accessibility support, automatic form resizing, and an in-place menu editor.
Upgrade
Wizard
Visual Basic forms are upgraded to Windows Forms.
PrintForm method
Visual
Basic 6.0 The PrintForm method sends a bit-by-bit image of a Form object to the printer. However, this printing feature doesn't work correctly on some forms.
Visual Basic.NET
In Windows Forms, Visual Basic.NET has a printing framework that allows you to build complex print documents quickly. It also includes a built-in Print Preview dialog box.
Upgrade
Wizard
PrintForm method calls are commented with an upgrade error. You can use the new printing framework to build a print document, or you can even grab a screenshot of the application window and print it.
Circle, Cls, PSet, Line, and Point methods
Visual
Basic 6.0 The Circle, Cls, PSet, Line, and Point methods allow you to draw graphics on a form as well as to clear them.
Visual Basic.NET
Windows Forms has a new set of graphics commands that replace the Form methods Circle, Cls, PSet, Line, and Point. The Windows Forms package is built on top of GDI+, a feature-rich 2-D text and imaging graphics library that is now directly accessible from Visual Basic.NET. Visual Basic programmers have not been able to access these types of features in previous versions without having to drop down to Declare statements and GDI APIs. While the learning curve is a little steeper, the flexibility and power of GDI+ will allow programmers to quickly develop applications that that would have taken significantly more work in previous versions of Visual Basic.
Upgrade
Wizard
Calls to these methods are commented with an upgrade error. You can write your graphics calls using the GDI+ classes in System.Drawing.
Caption property
Visual
Basic 6.0 Some controls, such as Label, have a Caption property that determines the text displayed in or next to the control. Other controls, such as TextBox, have a Text property that determines the text contained in the control.
Visual Basic.NET
In Windows Forms, the property that displays text in a control is consistently called Text on all controls. This simplifies the use of controls.
Upgrade
Wizard
Caption properties for the controls are changed to Text.
ScaleMode property
Visual
Basic 6.0 The ScaleMode property returns or sets a value that indicates the unit of measurement for coordinates of an object when using graphics methods or when positioning controls.
Visual Basic.NET
Windows Forms simplifies form layout by always making measurements in pixels.
In addition, Windows Forms has a better way to handle resizing. The AutoScaleBaseSize property automatically adjusts the scale according to the resolution (dpi) of the screen and font size you use.
Upgrade
Wizard
Code that used 'twips' (the default Visual Basic 6.0 ScaleMode setting) upgrades perfectly. If ScaleMode is non-twips, you'll have sizing issues.
See the white paper Preparing Your Visual Basic 6.0 Applications for the Upgrade to Visual Basic.NET for a full discussion of this topic.
Fonts
Visual
Basic 6.0 Forms and controls can use any Windows font.
Visual Basic.NET
Forms and controls can only use TrueType or OpenType fonts. These types of fonts solve many inconsistencies across different operating-system versions and their localized versions. These fonts also provide features, such as device resolution independence and anti-aliasing.
Upgrade
Wizard
If you have non-TrueType fonts in your application, these are changed to the default Windows Form font; however, formatting (size, bold, italic, underline) will be lost.
Screen.MousePointer property
Visual
Basic 6.0 The MousePointer property on the Screen object returns or sets a value indicating the type of mouse pointer displayed when the mouse is outside your application's forms at run time.
Visual Basic.NET
The mouse pointer can be manipulated for forms inside of the application, but it cannot when it's outside of the application. We will be addressing this feature in a future release.
Upgrade
Wizard
Use of Sceen.MousePointer is commented with an upgrade error.
Timer.Interval property
Visual
Basic 6.0 The Interval property on a Timer control returns or sets the number of milliseconds between calls to the Timer event. If it's set to 0, it disables the Timer control. The Enabled property also determines whether the timer is running. This is confusing, because even when the Enabled propertyis true, the timer won't be enabled if the interval is 0.
Visual Basic.NET
The Interval property indicates the time, in milliseconds, between timer ticks. This property cannot be set to 0. The Enabled property indicates whether the timer is running. This provides a more intuitive behavior to simplify coding with Timer objects.
Upgrade
Wizard
Where the Upgrade Wizard can detect that Timer.Interval is set to 0, it will be commented with an upgrade error.
You are advised to use Timer.Enabled in your Visual Basic 6.0 applications, as this upgrades perfectly.
Control arrays
Visual
Basic 6.0 A control array is a group of controls that share the same name and type. They also share the same event procedures. A control array has at least one element and can grow to as many elements as your system resources and memory permit. Elements of the same control array have their own property settings.
Visual Basic.NET
The Windows Form architecture natively handles many of the scenarios for which control arrays were used. For instance, in Windows Forms you can handle more than one event on more than one control with a single event handler.
Upgrade
Wizard
A Control Array Windows Forms extender control in the compatibility library provides this feature.
Menu controls
Visual
Basic 6.0 A Menu control represents each item in a menu tree. The same Menu control instance can be used simultaneously as a main menu or a context menu.
Visual Basic.NET
A MenuItem control represents each item in a menu tree. The MenuItem control can be added to either a MainMenu item or a ContextMenu item, but not to both at once. You can use the CloneMenu method on the MenuItem to create a copy if you'd like to share a menu between a MainMenu object and a ContextMenu object.
Upgrade
Wizard
Use of context menus is commented with an upgrade error. You can use MenuItem.CloneMenu to make a copy of the MainMenu item for use as a ContextMenu item.
OLE container control
Visual
Basic 6.0 The OLE container control enables you to add OLE objects to your forms.
Visual Basic.NET
There is no OLE container control in Visual Basic.NET. If you need the equivalent of the OLE container control, you can add the WebBrowser control to a form and use it as an OLE container control.
Upgrade
Wizard
An error is added in the upgrade report, and an unsupported-control placeholder is put on the form.
Image control
Visual
Basic 6.0 The Image and PictureBox controls both display a graphic from a bitmap, icon, metafile, enhanced metafile, JPEG, or GIF file.
Visual Basic.NET
The Visual Basic.NET PictureBox control replaces the Visual Basic 6.0 PictureBox and Image controls. The Windows Forms PictureBox control also supports animated GIFs. However, if you require a very lightweight solution for painting an image onto a form, you can also override the OnPaint event for the form and use the DrawImage method.
Upgrade
Wizard
Image controls are changed to PictureBox controls.
Line and Shape controls
Visual
Basic 6.0 The Line control displays as a horizontal, vertical, or diagonal line. The Shape control displays a rectangle, square, oval, circle, rounded rectangle, or rounded square.
Visual Basic.NET
The GDI+ classes in System.Drawing replace the Line and Shape controls. If you want to draw shapes on the form, override the OnPaint event and paint circles, squares, and so forth by using the GDI+ Draw methods.
Upgrade
Wizard
Horizontal and vertical Line controls are changed to Label controls (no text, with height or width set to 1). Diagonal lines raise an error in the report, and an unsupported-control placeholder is put on the form.
Rectangle and square Shape controls are changed to Label controls. Other Shape controls raise an error in the report, and an unsupported-control placeholder is put on the form.
Windowless controls
Visual
Basic 6.0 Lightweight controls, sometimes referred to as windowless controls, differ from regular controls in one significant way: They don't have a window handle (hWnd property). Because of this, they use fewer system resources. You create a lightweight user control by setting the Windowless property to true at design time. Lightweight user controls can contain only other lightweight controls. Not all containers support lightweight controls.
Visual Basic.NET
Most windowless controls will default to being windowed when used in Windows Forms. The main benefit of using windowless controls is to reduce resource consumption (window handles) when you have a very large number of controls on a form. This applies to Windows 9x only. Windows NT and Windows 2000 do not have these resource constraints.
While there are disadvantages to using windowless controls (layout issues such as layering problems), Microsoft recognizes the value of them and will be releasing samples that show how to achieve similar effects in Windows Forms.
Upgrade
Wizard
No special action is required.
Clipboard
Visual
Basic 6.0 The Clipboard object provides access to the system clipboard.
Visual Basic.NET
The Clipboard class provides methods to place data on and retrieve data from the system clipboard. The new Clipboard class offers more functionality and supports more clipboard formats than the Visual Basic 6.0 Clipboard object. The object model has been restructured to support these.
Upgrade
Wizard
The existing clipboard code cannot automatically be upgraded because of the differences between object models. Clipboard statements will be commented with an upgrade error.
Dynamic data exchange
Visual
Basic 6.0 Certain controls have properties and methods that support Dynamic Data Exchange (DDE) conversations.
Visual Basic.NET
Windows Forms has no built-in DDE support.
Upgrade
Wizard
DDE properties and methods are commented with an upgrade warning.
Web Applications
WebClasses
Visual
Basic 6.0 A WebClass is a Visual Basic component that resides on a Web server and responds to input from the browser. A WebClass typically contains WebItems that it uses to provide content to the browser and expose events.
Visual Basic.NET
Web Forms is a .NET Framework feature that you can use to create a browser-based user interface for your Web applications. Visual Basic.NET has a WYSIWYG designer for graphical Web Form creation using controls from the Toolbox. This gives Web user-interface development the same feel as Windows development. Also, when the project is built, the Internet Information Services (IIS) server does not have to be stopped and restarted to deploy the new bits, as it does with WebClasses.
Upgrade
Wizard
WebClasses are upgraded to Web Forms. Any state storage calls will be commented with an upgrade warning. These can be rewritten to take advantage of the ASP.NET state management features.
You may also choose to leave WebClass applications in Visual Basic 6.0, and navigate from a Visual Basic.NET Web Form to a WebClass, to a WebForm, and so on..
ActiveX documents and DHTML applications
Visual
Basic 6.0 ActiveX® documents can appear within Internet browser windows, and offer built-in viewport scrolling, hyperlinks, and menu negotiation. DHTML applications contain DHTML pages and client-side ActiveX DLLs.
Visual Basic.NET
Web Forms support broad-reach applications through standard HTML. Rich applications can be supported in a much more secure way by using Windows Forms controls hosted in a browser, or with a downloaded "safe Windows Form" EXE. This code runs inside of a secure sandbox, so that it cannot do harm to a user's computer.
Upgrade
Wizard
While ActiveX documents and DHTML applications cannot be directly upgraded, you can still navigate between ActiveX documents, DHTML applications, and Web Forms.
Data
ADO, RDO, and DAO code
Visual
Basic 6.0 ADO, RDO, and DAO objects are used for connected and disconnected data access.
Visual Basic.NET
ADO.NET provides additional classes for disconnected data access. These classes provide performance and scalability improvements over previous versions of ActiveX® Data Objects (ADO) when used in distributed applications. They also allow simpler integration of XML data with your database data.
Upgrade
ADO, RDO, and DAO can still be used in Visual Basic.NET code.
ADO, RDO, and DAO Data Binding
Visual
Basic 6.0 Controls on Visual Basic forms can be bound to ADO, RDO, and DAO data sources.
Visual Basic.NET
ADO.NET offers read/write data binding to controls for Windows Forms and read-only data binding for Web Forms.
Upgrade
Wizard
ADO data binding is upgraded to the new ADO.NET data binding. However, RDO and DAO data binding cannot be upgraded and will add errors to the upgrade report.
Integrated Development Environment
Immediate window
Visual
Basic 6.0 From the Immediate window in Design mode, you can run parts of your code without launching the entire application through its Startup object. For example, you can show forms, call module procedures, and interact with global variables. This is possible because Visual Basic 6.0 is running the application from an in-memory image of the code, and is not debugging the built output that's used at run time.
Visual Basic.NET
From the Command window in Design mode, you can execute IDE commands, but you cannot run individual parts of your application. This is because Visual Basic.NET runs and debugs the actual built output that is used at run time. This form of debugging provides the most accurate replication of the run-time behavior.
IDE and project extensibility
Visual
Basic 6.0 The Visual Basic 6.0 integrated development environment (IDE) extensibility model is supported by Visual Basic 6.0 only.
Visual Basic.NET
The new IDE extensibility model is generic for all project types inside of Visual Studio.NET. This makes it much simpler to create add-ins that work with many different types of projects. The Visual Basic project system extensibility model is also shared with C#--so project specific functions, such as adding a reference or changing a project property, are done the same way in both languages.
A Visual Studio.NET code model also gives extensibility writers a common object model to walk the code in projects of different languages. Visual Basic supports reading code through the code model. To write code, you can grab an insert point from the model and then spit out Visual Basic syntax.
|
Responses
|
| Author: ted calbazana 03 Aug 2004 | Member Level: Bronze Points : 0 | Very well done article Siju
Very clear, concise and useful.
Thank You!
Ted
| | Author: Mike Frysinger 17 Sep 2004 | Member Level: Bronze Points : 0 | this dude didnt write this article, he copied and pasted it and called it his own; Microsoft wrote it! talk about pathetic.
http://www.mvps.org/vb/index2.html?rants/vfred.htm
http://www.mvps.org/vb/rants/VBTransition2.doc
|
|