Introduction.

Using the .NET Framework, Microsoft Visual Basic developers can build robust applications that were very difficult to write in previous versions of Visual Basic. This article will discuss the some of the key changes requiring redesign under VB.Net compared to VB 6.0.

First, VB.NET includes a host of new features that enable developers to maximize their productivity. In addition to a new unified IDE (integrated development environment), VB developers can take advantage of the new Server Explorer to easily integrate server-side components into their apps, the shared Task List to help organize code, Dynamic Help for instant access to pertinent information, and Macros to customize, extend, and integrate the Visual Studio environment.

Let us see Some of the key changes requiring redesign under VB.Net compared to VB 6.0.

1. Add-In Model has Changed:
   
   Add-Ins are still supported but the underlying extensibility object model has changed and existing add-ins will need to be rewritten. In some cases existing add-ins may no longer be needed as the new IDE is much more robust than the old IDE and also supports the creation of macros. For those that are still needed the new extensibility model is much more complete.
   
   
2. Date and Time are renamed:
   
   In VB.Net the Today function replaces the old Date function and TimeOfDay replaces the Time function. The main difference between VB.Net and earlier versions is that Date/Time values used to be stored as double-precision values and could be manipulated directly. In VB.Net the internal format for dates and times has been changed and is not directly accessible.
   
   
3. File I/O statements have changed:
   
   The VB.Net language does support some basic file I/O operations in the form of functions:
   
   Open:
   
   FileOpen(Channel, FilePath, OpenMode, OpenAccess, OpenShare, RecordSize)
   Read data:
   
   FileGet(Channel, DataBuffer, RecordNumber, ArrayIsDynamic, StringIsFixedLength)
   Input(Channel, DataBuffer)
   DataBuffer = LineInput(Channel)
   
   Write data:
   
   FilePut(Channel, DataBuffer, RecordNumber, ArrayIsDynamic, StringIsFixedLength)
   Print(Channel, DataBuffer)
   PrintLine(Channel, Data{, Data...})
   Write(Channel, Data{, Data...})
   
   Close:
   
   
4. FileClose({Channel{,channel...}})
   Reset() ' close all files
   
   
5. Strings in VB.Net:
   
   The String data type and basic string operations are essentially unchanged in VB.Net. Strings are still unicode and can be manipulated as in earlier versions. Due to the nature of the object-oriented underpinnings of dotnet, however, there are some new performance considerations and some new ways to do things.
   
   Once created, a String in VB.Net is immutable which means that it cannot be modified. That sounds contradictory but what it really means is that any time you make a change to a string value the original string is destroyed and a new string is created. The same was essentially true in earlier versions of VB except that the MID statement could be used to modify an existing string without needing to allocate an entire new string in memory. This technique was frequently used to provide a performance boost but is no longer possible. The MID statement is still supported syntactically but it still creates a new string.
   
   
6. Controls have been redesigned with many properties/methods removed or renamed.
   
   For example the Listbox control in VB 6.0 presented a list of text strings to the user for selection. The VB.Net Listbox control is much more powerful in that it holds an array of objects instead of just strings. The display can be set to present any property of the objects (all objects must expose the same property name) and the click event returns a reference to the individual object. The control also supports using multiple columns, tab stops and sorting on demand.
   
   
7. DAO/RDO Data Binding is not supported by the new controls.
   
   Data Binding is directly supported by the VB.Net controls using ADO.
   
   
8. Parameters are passed ByVal by default.
   
   
9. Control Arrays are gone.
   
   
10. Fixed length strings are gone.
    
    
11. Gosub, On/Gosub, On/Goto are gone.
    
    
12. Names with leading underscores are not hidden.
    
    
13. Implements implementation has changed.
    
    
14. Null is now DBNull.
    
    
15. Property syntax has changed.
    
    
16. ObjPtr, VarPtr and StrPtr are gone.
    
    
17. No more SET and limited default properties.
    
    
18. Static procedures are not supported.
    
    
19. Types are now Structures and LSET is gone.
    
    
20. Variant, Empty, Null, Missing, IsNull and IsMissing are missing.
    
    
21. WebClasses, ActiveX Documents and DHTML projects are now WebForms/ASP+.
    
    
22. While/Wend is now While/End While.
    
    
23. No more windowless controls.
    
    
24. API Calls need updating.
    
    
25. DIM As New is different.
    
    
26. Arrays are always base Zero.
    
    
27. VB.Net is not based on COM.
    
    
28. Integer and Long are redefined.
    
    
29. MsgBox defaults are different.
    
    
30. ParamArrays are passed ByVal instead of ByRef.
    
    
31. Property references can be passed ByRef.
    
    
32. Currency data type is gone.
    
    
33. DEFxxx statements not supported.
    
    
34. DIM does not default to Object.
    
    
35. DIM can be restricted in scope.
    
    
36. ENUMs must be explicity identified.

Thus these are some key changes requiring redesign under VB.Net compared to VB 6.0.

Conclusion:

Visual Basic.NET is the result of a significant rebuild of Visual Basic for the Microsoft .NET Framework. There are a number of changes that make Visual Basic.NET easier to use, more powerful than Visual Basic 6.0, and give it the kind of access to system resources that in the past required the use of languages like C++. Rather than simply adding some new features to Visual Basic 6.0, Microsoft has re-engineered the product to make it easier than ever before to write distributed applications such as Web and enterprise n-tier systems.