For over six years, developers wishing to migrate their VB6 to .NET could only choose between two tools:
In spite of their different names and features, these two tools have a lot in common, in that they share the same conversion engine and the same approach to code migration. In 2008 Code Architects made the choice wider by launching an innovative VB conversion software:
Competition is always a good thing because it drives innovation, and customers are those who benefit most from it. With more choices, however, VB6 developers now face the difficult task of selecting the right product for their needs.
To make such a decision easier, this document summarizes and compares the features of Microsoft Upgrade Wizard 2008 (UW), Artinsoft’s VB Upgrade Companion Enterprise Edition (VBUC), and Code Architects’ VB Migration Partner (VBMP).
We are aware that preparing a feature comparison is a very delicate matter, even if we tried to be as objective as possible.
We support our descriptions by means of links to online documentation when such documentation is available.
At the bottom of the table we even describe a few features that are available only in our competitor’s product, a kind of bona fide that you don’t see often in marketing literature.
|
Feature
|
Benefits
|
UW
|
VBUC
|
VBMP
|
Notes
|
|
General
|
|
Generates both VB.NET and C#
|
CT
|
|
|
|
Starting with version 1.50, VBMP supports both VB.NET and C# code generation. See below about the differences in how VBUC and VBMP generate C# code.
|
|
Conversion of VB6 project groups
|
CT
|
|
|
|
VBMP can convert VB6 projects groups in a fully automated way.
VBUC performs a separation between the pre-processing and conversion stages and a certain amount of manual labor may be necessary when migrating VB6 project groups.
|
|
Automated batch migrations
|
T
|
|
|
|
The command-line version of VBMP can be integrated in build scripts and batch files to automated complex project migrations.
|
|
Super-fast parsing/code generation
|
T
|
|
|
|
VBMP runs at least 5x faster than UW, even if it delivers VB.NET code with about 10-15x fewer compile and runtime errors.
VBUC uses that same conversion engine on which UW is based.
|
|
Granular control over code generation
|
CRT
|
|
|
|
VBUC Enterprise Edition uses customized profiles to enable conversion features at the project level only (Profiles aren’t allowed in VBUC Develop Edition). VBMP pragmas allow you a higher degree of granularity in that they can have global, project, file, method, and variable scope.
|
|
Support library
|
CROT
|
|
|
|
VBMP’s supports library ensures that converted VB.NET preserves full functional equivalence with the original VB6 code. VBUC comes with a limited set of helper classes and methods. VBMP support library has many other advantages, too.
|
|
Integrated code editor
|
T
|
|
|
|
VBMP is a stand-alone software that contains a VB6 and VB.NET code editor with syntax highlighting, search capabilities, and support for inserting pragmas in source code without using the VB6 IDE.
|
|
Pre- and post-processing features
|
CR
|
|
|
|
VBMP can use regular expressions to pre-process VB6 code or post-process the generated VB.NET or C# code (PreProcess and PostProcess pragmas), can add or remove source files (AddSourceFile and ExcludeCurrentFile pragmas), can exclude or include portions of VB6 code during parsing or during code generation (ParseMode and OutputMode pragmas), and a lot more.
|
|
Repeated conversion of VB6 apps that evolve during the migration process
|
T
|
|
|
|
VBMP’s convert-test-fix methodology allows to keep the VB6 and .NET apps in sync during the entire migration and modernization initiative. Other conversion tools work on a snapshot of the VB6 code, further changes in VB6 code must be manually applied to the VB.NET code.
VBUC uses a merge mechanism named continuous migration that should permit to preserve portions of VB.NET or C# code from being overwritten, yet it fails if the original VB6 code for those portions has changed.
|
|
Interoperability with VB6 apps and staged migration scenarios
|
T
|
|
|
|
VBMP generates VB.NET (but not C#) components that are binary-compatible with the original VB6 component, so that existing COM clients can reference the new .NET DLL without having to be recompiled (see BinaryCompatibility pragma). Read this article for more information about the importance of binary compatibility in migration scenarios. VBUC supports COM visibility, not backward compatibility at the binary level.
|
|
Partial conversions of individual source files (incremental migrations)
|
CT
|
|
|
|
The SetOption RemarksMethodBody pragma allows you to migrate a portion of the entire VB6 project. For example, you can migrate individual forms, classes, and modules, and even individual methods. This feature allows you to focus on a subset of the project so that you can keep the compilation and runtime errors to the minimum and have a running .NET project in less time.
|
|
Support for source control tools
|
T
|
|
|
|
When re-migrating a given VB6 project or group, VBMP ensures that the re-generated project is recognized by source code control tools.
|
|
Full control over migration warnings
|
T
|
|
|
|
VBMP allows you to control the amount of migration warnings, by disabling or enabling specific migration messages
(DisableMessage and EnableMessage pragmas) as well as entire categories of messages, e.g. all messages related to code analysis
(DisableMessages and EnableMessages pragmas). You decide whether these pragmas affect the entire project, a single file, a given method or variable.
|
|
Extendibility for customization purposes
|
CRT
|
|
|
|
VBMP offers several extendibility mechanisms, ranging from simple hooks during the migration process to the ability to generate custom code for
3rd-party ActiveX controls. Some VBUC extensions must be written using Kablok, a proprietary programming language by Artinsoft.
|
|
Unlimited duration for user license
|
T
|
|
|
|
VBUC’s user license has a limited duration (3 months for the Developer Edition, 1 year for the Enterprise Edition).
|
|
Support for Windows 7 and 64-bit version of Windows
|
T
|
|
|
|
Both VBMP and VBUC can be installed under all recent versions of Windows.
|
|
Language
|
|
Arrays with nonzero lower bound
|
CR
|
|
|
|
VBMP offers several pragmas that allow you to precisely indicate how such arrays are handled.
(See ArrayBounds and ShiftIndexes pragmas.) VBUC attempts to detect the best way to convert these arrays, but isn’t able to generate the best code in all circumstances.
|
|
Assignments between arrays
|
R
|
|
|
|
UW uses the Array.Clone method to preserve VB6 semantics when assign an array to another array. VBMP goes one step further in that it can perform deep array copying and can correctly deal with arrays containing nested objects.
|
|
Erase keyword
|
R
|
|
|
|
The behavior of the VB6 Erase keyword depends on whether the array is static or dynamic. (A static array is declared and instantiated in a single Dim statement, whereas a dynamic array is instantiated in a separate ReDim statement.) VBMP accounts for this difference, whereas both UW and VBUC always deal with arrays as if they were dynamic.
|
|
Array rank inference
|
CR
|
|
|
|
VBMP is able to infer the correct number of dimensions of an array in virtually all cases, a feature that UW apparently lacks.
|
|
Fixed-length strings
|
CR
|
|
|
|
VBMP supports fixed-strings and arrays thereof, including correctly passing them to Windows API and writing them to binary files.
|
|
Operators and expressions with Variants
|
R
|
|
|
|
UW always converts Variants into Object variables. VBMP optionally converts Variants into the VB6Variant special type that preserves VB6/COM behavior, for example in how math and string operators are evaluated
|
|
Null propagation in expressions
|
R
|
|
|
|
VBMP can generate code that preserves the propagation of Null values in expression (see NullSupport pragma).
|
|
Gosub, On Goto, On Gosub keywords
|
C
|
|
|
|
VBMP supports these keywords and is also capable, where possible, to refactor Gosubs into calls to separate methods (see ConvertGosubs).
|
|
Structures assignment and initialization
|
CR
|
|
|
|
VBMP automatically initializes Structures and arrays of Structures even if the Structure contains arrays, fixed-length strings, As New objects, or nested structures. It also takes care of performing a deep copy when a structure is assigned to another structure variable.
|
|
Binary file I/O (Get#, Put# keywords)
|
R
|
|
|
|
UW uses FileGet and FilePut VB.NET methods, which don’t work well if the structure contains arrays,
fixed-length strings, or nested structures; VBMP uses custom helper methods that don’t suffer from these issues.
|
|
As New variables with true auto-instancing semantics
|
R
|
|
|
|
VBMP can enforce true auto-instancing semantics for variables, fields, local variables, and UDT items
(see AutoNew pragma).
|
|
As New keyword used with arrays
|
R
|
|
|
|
VBMP preserves functional equivalence also when As New is used in array declarations.
(Read here for more details.)
|
|
ByRef ParamArray method parameters
|
R
|
|
|
|
.NET only supports by-value ParamArray parameters. VBMP preserve functional equivalence also when a method modifies an element in a ParamArray parameter (see FixParamArray pragma).
|
|
As Any parameters in Declare methods
|
C
|
|
|
|
VBMP gets rid of the Any keyword by generating one or more overloads for the Declare method. VBUC generates a separate project that contains these overloads.
|
|
AddressOf keyword in calls to Declare methods
|
CR
|
|
|
|
VBMP generates a Delegate type and an overload for the Declare method. Just as important, VBMP is able to generate code that avoids subtle bugs caused by orphaned delegates passed to Windows API (see WrapDeclareWithCallbacks pragma).
VBUC generates a separate project that contains these overloads, but don’t fix the problem with orphaned delegates.
|
|
VarPtr, StrPtr, ObjPtr undocumented functions
|
C
|
|
|
|
VBMP maps these keywords to methods that throw an exception; this approach is useful to avoid compilation errors.
In addition, VBMP offers limited support for the VarPtr keyword when used on local variables and structures.
|
|
Byte-oriented string functions
|
CR
|
|
|
|
VBMP offers replacement methods that behave exactly like the original LeftB, MidB, AscB, etc. functions in most cases.
|
|
Behavior differences in VB functions
|
R
|
|
|
|
The following VB.NET keywords and functions don’t work exactly like the VB6 original functions: Abs, AppActivate, CStr, Dir, DoEvents, FileAttr, FileDateTime, CDate, IsDate, InputBox, Mod, MsgBox, Str, TypeName, TypeOf. VBMP offers replacement methods that preserve functional equivalence, both when generating VB.NET and C# code.
|
|
VB6 language objects (e.g. App, Screen)
|
CR
|
|
|
|
VBMP supports all the VB6 language objects – App, Clipboard, Screen, Printer, Printers, Forms, etc - and guarantees functional equivalence with original VB6 code, except for a few members that have no equivalence in .NET (e.g. OleServerBusy property).
|
|
Printing
|
CR
|
|
|
|
VBMP supports all print-related features, including Print and Print Setup common dialogs that communicate with the Printer object by means of its hDC property. UW supports printing by means of the Printer object in VB Power Packs, which lacks these features. Optionally, VBMP allows you to use the Printer object included in MS VB PowerPacks, which is how VBUC implements this functionality.
|
|
Fully compatibility with VB6 enums
|
RT
|
|
|
|
All enumerated properties in VBMP support library use the same enum values as in VB6; this detail ensures that assignments to these properties always work as intended even if the enum value is an integer read from a file, the registry, or returned by a method in the same project or in an external COM component, in both early-bound and late-bound scenarios. (Useful in phased migration scenarios.)
|
|
Full control over project-level settings
|
T
|
|
|
|
VBMP permits to control the project-level settings of the .NET application being generated. For example you can change the default output path, the Option Explicit setting, whether a .pdb file has to be generated, and so forth. (Read here for more information.)
|
|
Built-in debugging features
|
M
|
|
|
|
VBMP support library includes a few debugging and tracing features, such as the ability to dump the call stack when a fatal error occurs in the .NET application. (Useful to remotely diagnose malfunctioning.)
|
|
Ignore fatal runtime error
|
M
|
|
|
|
.NET applications generated by VBMP can optionally ignore fatal runtime errors, by simply setting the VB6Config.LogFatalError property to True. This feature is quite useful during the test and debug phase of a migrated project.
|
|
Language (C# specific)
|
|
Convert ByRef parameters into by-value parameters if possible
|
RMO
|
|
|
|
Both VBUC and VBMP analyze the way each by-reference parameter is used inside the method and transform it into a by-value parameter if possible. (This feature is crucial because it simplifies all calls to the method.)
|
|
Generate “out” parameters if possible
|
MO
|
|
|
|
If the CSharpOption UseOut pragma is used, VBMP analyzes the way each method parameter is used and used the out keyword if possible.
|
|
Generate methods overloads to get rid of “ref” and “out” parameters
|
CMO
|
|
|
|
VBMP can optionally generate method overloads that don’t contain any “ref” or “out” parameter. (This feature is crucial because it simplifies all calls to the method.) For more info, see CSharpOption OverloadsForByval pragma.
|
|
Optional parameters
|
CMO
|
|
|
|
VBMP can optionally generate method overloads that don’t contain any “ref” or “out” parameter. (This feature is crucial because it simplifies all calls to the method.) For more info, see CSharpOption OverloadsForByval pragma.
|
|
“ref” and “out” optional parameters
|
CMO
|
|
|
|
C# doesn’t support optional parameters that require by-reference semantics. VBMP converts these parameters into ref/out nonoptional parameters; VBUC often fails to correctly handle this case.
|
|
Date constants
|
CRMO
|
|
|
|
C# doesn’t natively support DataTime constants. VBMP converts these constants into static readonly fields, whereas VBUC leaves them as-is and generate compilation errors.
|
|
Late-bound calls with helper methods
|
CR
|
|
|
|
Both VBUC and VBMP can handle late-bound calls by generating calls to helper methods in the support library.
|
|
Late-bound calls with “dynamic” variables
|
CRMO
|
|
|
|
VBMP leverages C# 2010 dynamic variables to handle late-bound calls, when the UseDynamic pragma is used; VBUC doesn’t use this important new C# feature and can only handle late-bound calls by generating bloated and inefficient code that uses helper methods.
|
|
Properties with parameters
|
CM
|
|
|
|
Both VBUC and VBMP convert properties with parameters into either indexer methods (if it’s the default property) or into a pair of get/set methods.
|
|
Properties with distinct Let/Set accessors
|
CRM
|
|
|
|
VBMP can optionally generate a separate setobj_propname method, if the original VB6 property exposed both Property Let and Property Set accessors (see the PreservePropertyAssignmentKind pragma.)
|
|
WithEvents variables
|
CRM
|
|
|
|
Both VBUC and VBMP convert WithEvents variables into properties whose set accessor correctly registers/unregisters event handlers.
|
|
Implicit interface implementation
|
C
|
|
|
|
Both VBUC and VBMP convert VB6 methods that implement an interface member into a public C# method with same name.
|
|
Explicit interface implementation
|
C
|
|
|
|
Only VBMP can optionally convert VB6 methods that implement an interface member into a private C# method that adopts the interfacename.methodname syntax. (For more info, see the CSharpOption ExplicitInterfaceImplementation pragma.) This feature can avoid name collisions and keeps the class’s object model tidier.
|
|
On Error Goto statement
|
CRM
|
|
|
|
Both VBUC and VBMP convert On Error Goto statements into a try-catch block; however, in both cases the resulting C# might not be fully functional equivalent to the original VB6 code (in this case VBMP emits a warning).
|
|
On Error Resume Next statement
|
CRM
|
|
|
|
Both VBUC and VBMP can convert statements under the scope of a On Error Resume Next statement by generating lambda expressions (see CSharpOption ConvertOnErrorResumeNext pragma for more info.) However, only VBMP allows you to precisely indicate then classes or methods when this replacements must be done (VBUC only supports a project-level setting) and only VBMP works correctly with statements that use ref/out parameters (which can’t appear inside lambda methods).
|
|
The Err object
|
CRM
|
|
|
|
VBMP uses the helper object VB6Helpers.Err to perfectly replicate the behavior of the original VB6 Err object.
|
|
C# strict typing
|
CR
|
|
|
|
Both VBUC and VBMP correctly generate the C# code that coerces/converts values between different data types. However, if necessary VBMP uses helper methods to ensure that values are handled using the VB6 conversion rules, whereas VBUC always use C# keywords and can therefore introduce subtle bugs.
|
|
Integer and Long VB6 variables
|
CRM
|
|
|
|
To reduce the amount of conversion code to be emitted, VBUC handles all VB6 Integer (16-bit) variables as if they were Long (32-bit) variables, but this approach can create subtle bugs, for example when writing to a file or when an On Error statement is expected to fire in case of overflow. By default, VBMP converts VB6 Integer type into C# short type, but can handle them as 32-bit values if so desired.
|
|
Bitwise vs. logical And/Or operators
|
RM
|
|
|
|
Both VBUC and VBMP correctly convert And/Or operators into the most appropriate C# keyword, depending on whether the operator is used for a bitwise (& and |) or logical (&& or ||) operation.
|
|
Option Compare Text directive
|
RM
|
|
|
|
Only VBMP accounts for the Option Compare Text directive and correctly generates string comparison code that works in case-insensitive way.
|
|
Math vs. string “+” operator between Variants
|
RM
|
|
|
|
Both VBUC and VBMP use heuristic rules to determine whether a “+” operation between Variant values is actually a sum or a string concatenation. However, only VBMP provides a pragma (CSharpOption AssumeConcatenation) that allows you to override the default behavior if necessary.
|
|
Math vs. string comparison between Variants
|
RM
|
|
|
|
Both VBUC and VBMP use heuristic rules to determine whether a comparison between Variant values is actually a numeric or string comparison. However, only VBMP provides a pragma (CSharpOption AssumeStringComparison) that allows you to override the default behavior if necessary.
|
|
Select Case
|
CRM
|
|
|
|
VBUC always converts a Select Case block into a if…elseif block. VBMP always attempts to generate a C# switch block if possible, because the C# compiler can optimize this code better; if it isn’t possible, then VBMP reverts to an if…elseif block.
|
|
Select Case with a test expression
|
RMO
|
|
|
|
When a Select Case block tests an expression, VBUC generates an if…elseif block that repeatedly re-evaluates the expression, and therefore the resulting code is inefficient and potentially prone to bugs (e.g. if the expression affects global variables). In these cases VBMP correctly evaluates the expression only once and stores the result in a temporary variable.
|
|
For Each variables passed to ref/out parameters
|
C
|
|
|
|
C# prevents passing the controlling variable of a foreach loop to a ref/out parameter in a method call. VBMP avoids this error by generating an alias to be used as the controlling variable. (In same circumstances, VBUC generates a compilation error.)
|
|
Exit For/Do/While in nested loops
|
R
|
|
|
|
VBUC always converts Exit For/Do/While statements into the C# break keyword, but this approach introduces bugs in some cases. In these cases, VBMP generates the correct C# code that properly exits the loop.
|
|
With… End With blocks
|
CRM
|
|
|
|
Both VBUC and VBMP convert With… End With blocks by generating – if necessary -a temporary variable that holds the With expression.
|
|
ByVal string parameters with byref semantics in Declare
|
R
|
|
|
|
Both VBUC and VBMP can correctly translate the most common Windows API methods that take a ByVal string value with by-reference semantics, e.g. GetWindowText. However, only VBMP allows you to extend this mechanism to any Declare statement.
|
|
Expressions in #If and #Const directives
|
CRM
|
|
|
|
C# doesn’t support expressions in #define and #undef directives, however both VBUC and VBMP correctly determine which portions of code are conditionally converted. However, only VBMP generates derivate #define directives that make the code more readable and maintainable.
|
|
Optimization of class field initialization
|
RMO
|
|
|
|
Only VBMP analyzes the code inside Class_Initialize and correctly initializes class-level fields.
|
|
Using native .NET methods
|
MO
|
|
|
|
Both VBUC and VBMP can optionally generate calls to native .NET methods rather than helper methods defined inside the support library. However, VBUC sometime generates code that isn’t functional equivalent to the original VB6 code, whereas VBMP only performs “safe” replacements (see UseNetMethods pragma).
|
|
Collection object
|
CRMO
|
|
|
|
VBUC converts references to the Collection object into .NET native classes (e.g. HashTable or List), which aren’t fully equivalent to the VB6 object. VBMP converts these references to the special Collection6 helper class, that guarantees functional equivalence.
|
|
Classes and Components
|
|
Resolution of default property in late-bound scenarios
|
R
|
|
|
|
UW can derive default property names (e.g. Text1 => Text1.Text) only for strongly-typed variables. VBMP can correctly resolve default properties even for Object variables in late-bound contexts (see DefaultMemberSupport pragma).
|
|
CreateObject method
|
R
|
|
|
|
VBMP uses a helper method that can instantiate both COM and .NET objects. UW uses the VB.NET CreateObject method, that only works with COM objects. (This feature is especially useful in staged migration scenarios.)
|
|
Correct release of COM objects
|
RMO
|
|
|
|
Both VBUC and VBMP use a Try-Finally block to correctly release references to COM objects (e.g. ADODB.Recordset objects).
|
|
Deterministic finalization for IDisposable objects
|
RMO
|
|
|
|
VBMP can generate the cleanup code
for all IDisposable objects – both those defined in current project or those defined
in an external library, e.g. database connections and file handles (see AutoDispose pragma). VBUC doesn’t correctly release objects referenced by class fields.
|
|
Property Get/Let/Set procedures
|
C
|
|
|
|
VBMP correctly handles a number of cases that UW leaves unresolved, for example properties with both Get/Let/Set blocks with different value type or different default values for Optional parameters.
(See also PreservePropertyAssignmentKind pragma.)
|
|
Classes with Class_Terminate method
|
RMO
|
|
|
|
VBMP creates a class that implements the IDisposable interface and generates the recommended Dispose-Finalize code pattern . UW generates only the Finalize method.
|
|
Class member description
|
M
|
|
|
|
When translating a class property or method, VBMP generates both the <Description> attribute and the XML remark for that member.
|
|
Advanced features in UserControl classes
|
CR
|
|
|
|
VBMP can handle most advanced UserControl features, such as KeyPreview property, Ambient and Extender objects, data-bound members, OLE_OPTEXCLUSIVE properties, properties that are readonly at design-time, properties with nonstandard serialization, and more.
|
|
Sub Main in DLL projects
|
R
|
|
|
|
Under VB6, the Sub Main method is guaranteed to run before any class in the DLL is instantiated. VBMP generates code that preserves functional equivalence in this case.
|
|
MTS/COM+ components
|
CR
|
|
|
|
VBMP is able to deal with advanced MTS/COM+ features, such as support for IObjectContext and IObjectConstruct interfaces and the SecurityProperty objects.
|
|
Multi-threaded components
|
RT
|
|
|
|
VBMP generates code that accounts for differences between the Single-Thread Apartment model used in VB6 and the .NET threding model,
which can cause subtle and random errors at runtime (see ThreadSafe pragma)
|
|
Persistable COM classes
|
C
|
|
|
|
VBMP generates classes marked with <Serializable> attribute, correctly converts InitProperties, ReadProperties, and WriteProperties event handlers, and supports the PropertyBag argument passed to this handlers.
|
|
ADO data-source and data consumer classes
|
C
|
|
|
|
VBMP correctly translates VB6 classes that work as ADO data source and data consumer classes; only simple binding is supported.
|
|
ADODB support
|
O
|
|
|
|
VBUC can convert DAO, RDO, and ADO
code into references to ADO.NET objects, but omits to support keysets/dynamic server-side
cursors. Most ADODB features are supported only partially. Code Architects’
ADOLibrary offers complete support for ADO.NET with nearly 100% coverage of ADODB
features, including support for server-side SQL Server cursors (read more here)
|
|
Additional COM type libraries converted to .NET objects
|
CR
|
|
|
|
VBMP converts the following COM objects into native .NET objects: StdDataFormat, BindingCollection, Dictionary, FileSystemObject, RegExp. Please contact Artinsoft for the complete list of COM components converted by VBUC.
|
|
Forms and Controls
|
|
Built-in VB6 controls
|
C
|
|
|
|
VBMP supports all the 60+ controls in the VB6 toolbox, except OLE Container and DataRepeater. VBUC also supports these controls, however it generates additional extender controls to better support command, listbox, combobox, listview and SSTab controls.
|
|
Microsoft ActiveX controls found in VB6 toolbox
|
CR
|
|
|
|
All the controls in VBMP support library inherit from a standard .NET control. Thanks to inheritance rule and the special NetObject property, it is always possible to access the full power of the underlying .NET control. (Read here for some examples.)
|
|
3rd-party ActiveX control support
|
CR
|
|
|
|
UW migrates commercial ActiveX controls but don’t convert them to .NET controls.
VBUC uses library extensibility to convert a subset of the features of a few 3rd-party controls by mapping them to intrinsic or commercial .NET controls, typically with 50 to 80% coverage of control features.
VBMP uses a separate tool (AxWrapperGen) to generate the wrapper class for a given ActiveX control; developers can then use the wrapper class as-is or edit it to map properties and members to an intrinsic or commercial .NET control.
|
|
Full access to all features of the .NET control
|
MO
|
|
|
|
All the controls in VBMP support library inherit from a standard .NET control. Thanks to inheritance rule and the special NetObject property, it is always possible to access the full power of the underlying .NET control. (Read here for some examples.)
|
|
Functional equivalence of controls’ properties, methods, events
|
CR
|
|
|
|
Only an extensive support library can guarantee that all properties, methods, and events behave exactly like the original VB6 code.
|
|
Late-bound references to controls’ members
|
R
|
|
|
|
Controls in VBMP’s support library expose properties and methods with same name as the original members, which ensures that code runs correctly even in late-bound scenarios.
|
|
Controls.Add method
|
CR
|
|
|
|
VBMP fully supports the Controls.Add method for dynamically creating controls at runtime; it works with both built-in controls and ActiveX controls and fully supports the VBControlExtender object for handling late-bound events.
|
|
DAO, RDO, ADO data-binding
|
CRT
|
|
|
|
VBMP supports virtually all forms of data-binding, including binding to DataEnvironments, ADO data source and consumer classes, UserControls that work as ADO data sources, StdDataFormat objects, and more.
|
|
“classic” (VB3-style) drag-and-drop
|
CRT
|
|
|
|
Starting with version 1.10.01, VBMP fully supports “classic” drag-and-drop (e.g. the DragMode property and the DragDrop event).
|
|
OLE Drag-and-drop
|
CRT
|
|
|
|
VBMP fully supports OLE Drag-and-drop, in both automatic and manual modes. All properties, methods, and events are correctly translated.
|
|
Drop-down menus
|
CR
|
|
|
|
VBMP fully supports arrays of menu items and the ability to transform a menu item into a separator (or vice versa) by assigning its Caption property.
|
|
Popup (context) menus
|
CR
|
|
|
|
VBMP supports context menus and the Popup method, including the ability to display the menu at current mouse position or at specified coordinates.
|
|
Graphic properties and methods
|
CRT
|
|
|
|
VBMP supports all VB6 graphic methods
and properties – Cls, Line, Circle, PSet, PaintPicture, DrawWidth, FillColor, FillStyle,
etc.- with the only exception of the DrawMode and ClipControls properties. VBUC
has a limited support only for Cls, Print, Line, Circle, and PaintPicture methods
(no boxed lines, no fill color, etc.)
|
|
AutoRedraw property
|
R
|
|
|
|
VBMP supports double buffering by means of AutoRedraw property; as in VB6, no Paint event fires if this property is True. The VB6 Image property is also supported.
|
|
User-defined scale coordinates
|
CRT
|
|
|
|
VBMP supports all VB6 coordinate systems, including user-defined ScaleMode settings and negative values for ScaleWidth/ScaleHeight properties. All scale-related properties can be assigned at runtime.
|
|
Font mapping customization
|
R
|
|
|
|
The FormFont, ReplaceFont, and ReplaceFontSize pragmas enable VBMP users to specify how original font and control fonts should be rendered in .NET.
|
|
Controls collection includes nested controls
|
R
|
|
|
|
VBMP forms expose a Controls collection
that also includes controls nested in other controls, as it happens in VB6 and unlike
what .NET does. VBUC uses a helper class to achieve this feature, but it doesn’t
work well in all cases.
|
|
Dynamic Data Exchange (DDE) properties, methods, and events
|
CR
|
|
|
|
VBMP supports DDE communications between two forms of the same application or two (or more) migrated .NET applications. It doesn’t support DDE communications with non-VB6 DDE servers (e.g. Microsoft Excel).
|
|
Help-related properties and methods
|
CR
|
|
|
|
VBMP supports all help-related properties and methods and can reuse existing help files in HLP and CHM format. VBUC only supports the CHM format.
|
|
TreeView, ListView, Toolbar, TabStrip, and StatusBar object models
|
CR
|
|
|
|
Controls in VBMP support library exactly replicate the object model of the original VB6 controls, which guarantees that functional equivalence is fully preserved.
VBUC doesn’t achieve 100% compatibility.
|
|
UpDown, Animation, FlatScrollBar controls translated to .NET native controls
|
RM
|
|
|
|
According to Artinsoft online docs, these controls aren't converted to native .NET controls and appear in converted .NET projects as ActiveX controls.
|
|
Microsoft Windowless control library (MSWLESS)
|
RM
|
|
|
|
According to VBUC online documentation, only the WLText, WLCombo, and WLCheck controls are converted into native .NET controls. Conversely, VBMP correctly converts all the controls in this library (WLText, WLCommand, WLOption, WLCheck, WLList, WLCombo, WLHScroll, WLVScroll, and WLFrame).
|
|
Label and Image controls used as hotspots
|
R
|
|
|
|
VBMP supports transparent “hot spots” for detecting mouse activity – i.e. Label and Image controls with transparent background that still receive mouse-related events. Hot spots are typically used to implement buttons with irregular shapes or image maps. VB.NET doesn’t natively support this feature.
|
|
|
O
|
|
|
|
Starting with v.1.34, VBMP supports a special .NET flag that dramatically reduces flickering when loading forms with hundreds of controls.
|
|
Support for window subclassing
|
CRMO
|
|
|
|
VBMP provides the special VB6WindowSubclasser helper class , which makes it easy to convert VB6 code that uses window subclassing.
|
|
ADODB support
|
|
Database-agnostic
|
CRM
|
|
|
|
VBUC provides support for multiple database types by means of ADO.NET interfaces and base classes
(e.g. DbConnection, DbDataReader) and selecting the right ADO.NET provider by means of a proper factory method.
VBMP reaches the same goal using concrete classes (e.g. ADOConnection, ADORecordset) which expose an enum property that specifies which ADO.NET data provider should be used.
|
|
Forward-only read-only cursors
|
RO
|
|
|
|
Both VBUC and VBMP convert these ADODB cursors into DataReader ADO.NET objects
|
|
Client-side static cursors with batch updates
|
RO
|
|
|
|
Both VBUC and VBMP convert these ADODB cursors into DataTable/DataSet ADO.NET objects
|
|
Server-side keyset and dynamic cursors
|
CRO
|
|
|
|
VBMP supports these cursors only for Microsoft SQL Server
|
|
Stand-alone client-side recordsets
|
CR
|
|
|
|
VBMP supports all the features of ADODB recordsets that aren’t linked to a database.
|
|
Parameterized commands
|
CRM
|
|
|
|
VBMP supports the standard ADODB syntax for parameterized commands, using either ? or @param for value placeholders.
|
|
Stored procedure calls with input, output, and return parameters
|
CRM
|
|
|
|
VBMP fully supports calls to SQL Server stored procedures, including special support for output parameters and return values.
|
|
Dynamic properties of Connection and Recordset objects
|
RM
|
|
|
|
Most dynamic properties of the Recordset objects are supported and honored, including Update Criteria, Unique Table, Resync Command, and Update Resync.
|
|
Connection and Recordset events
|
CRM
|
|
|
|
VBMP supports all the events of the Connection and Recordset objects, which fire in the same order and with same parameters as the ADODB library.
|
|
Asynchronous connections
|
RM
|
|
|
|
VBMP fully supports asynchronous connections, no need to manually fix the migrated source code.
|
|
Asynchronous commands
|
RM
|
|
|
|
VBMP fully supports asynchronous commands, no need to manually fix the migrated source code.
|
|
Optimistic batch updates
|
CRM
|
|
|
|
Both VBUC and VBMP aren’t able to support all the features of the UpdateBatch ADODB command, yet the list of VBMP limitations is considerably shorter. Please read ADOLibrary documentation for more details.
|
|
Custom batch update strategies
|
RM
|
|
|
|
VBMP honors the “Update Criteria” dynamic property of the Recordset object.
|
|
Full access to all ADO.NET features
|
OT
|
|
|
|
Both VBUC and VBMP allows you to use and manipulate “native” ADO.NET structures such as the DataTable or the DataReader.
|
|
Filter property
|
RM
|
|
|
|
VBMP includes a parser that “understands” the syntax used for the Recordset.Filter property.
|
|
Support for .NET bound controls
|
MO
|
|
|
|
Data-bound controls work correctly after the migration, however VBUC doesn’t fire all the usual events that are typically used in data-binding scenarios (eg. WillMove, MoveCompleted), therefore the migrated code doesn’t work like the original VB6 code.
|
|
Helper library
|
CRMO
|
|
|
|
Both VBUC and VBMP use a set of helper classes to offer support for ADODB-to-ADO.NET migration, the main difference being that VBMP’s library is patterned after the ADODB object model and is therefore easier to learn and use.
|
|
Code Analysis and Refactoring
|
|
Conversion of On Error into Try-Catch
|
MO
|
|
|
|
VBMP converts both On Error Goto and On Error Resume Next into Try-Catch blocks, if functional equivalence can be fully preserved
(see UseTryCatch pragma).
|
|
Nested IFs merging
|
M
|
|
|
|
VBMP can converted two or more nested IF blocks into a single IF that uses short-circuiting and the AndAlso operator (see MergeIfs pragma).
|
|
Type inference
|
RMO
|
|
|
|
VBMP infers the type of Variant fields, variables, and parameters so that a strong-type member can be generated and its default property can be correctly deducted (see InferType pragma).
|
|
Unreachable code and unused members detection
|
M
|
|
|
|
VBMP emits a warning for unreachable code – e.g. code that follows Goto or Exit Sub keywords – and unused fields, methods, Consts, and Declares. It is also possible to mark as “referenced” members that are accessed via late-binding or from an external project
(see MarkAsReferenced and MarkPublicAsReferenced pragmas), a feature that is missing in VBUC.
|
|
Unreachable code and unused members removal
|
M
|
|
|
|
VBMP can remove or remark out unreachable code or unused members (see RemoveUnreachableCode and RemoveUnusedMembers pragmas). VBUC’s apparently lacks the ability to specify which public classes and methods are used by other apps, a detail that makes this feature less useful in migrating ActiveX DLLs.
|
|
Renaming engine for guideline compliance
|
M
|
|
|
|
VBMP supports both declarative and imperative renaming rules. Declarative rules are described in an XML file that can be edited to match our own coding style; imperative rules can be written using VB.NET or C#
(see ApplyRenameRules pragma).
VBUC uses a set of rename rules which can be modified only by writing new rules in Artinsoft’s Kablok proprietary language.
|
|
Refactoring of Gosub into separate method
|
MO
|
|
|
|
VBMP can translate Gosubs into calls to separate private methods in most cases (see ConvertGosubs pragma).
|
|
Conversion of ByRef into ByVal
|
MO
|
|
|
|
VBMP detects parameters that are marked with implicit or explicit ByRef but aren’t assigned inside the method, and optionally converts them into ByVal parameters. This refactoring technique delivers faster VB.NET code and avoids a category of runtime errors (see UseByVal pragma).
VBUC doesn’t support this feature when converting to .NET.
|
|
Obsolete or dangerous Windows API calls
|
RM
|
|
|
|
VBMP automatically replaces a Windows API call with the most appropriate .NET native method in some cases. If the replacement isn’t possible, VBMP suggests which .NET object or method can effectively replace the call. (Over 300 API Declares are handled in this way.)
|
|
Unnecessary Class_Finalize event handlers
|
MO
|
|
|
|
If VBMP detects that a Class_Terminate handler contains only cleanup code for fields that would be disposed of anyway, then no Finalize method is generated, which in turn speeds up class instantiation and destruction.
|
|
Exit Function and Exit Property keywords
|
M
|
|
|
|
VBMP converts Exit Function and Exit Property into Return keywords, if possible.
|
|
Missing variable declarations
|
M
|
|
|
|
VBMP allows you to control whether it should generate Dim statements for all local variables that weren’t explicitly declared (see DeclareImplicitVariables pragma).
|
|
Variable and field initializers
|
M
|
|
|
|
VBMP can merge the declaration of a class field or a local variable with the first assignment to that field/variable, e.g. Dim x As Integer = 1 (see MergeInitialization pragma).
|
|
Compound assignment operators (e.g. x += 1)
|
MO
|
|
|
|
VBMP automatically generates compound assignment operators for math operations and string concatenations.
|
|
Generate Properties from fields
|
M
|
|
|
|
VBMP can replace fields with Property procedures and generate better structured .NET code (see AutoProperty pragma) .
|
|
If… Then… Else simplification
|
M
|
|
|
|
VBMP checks whether the Then and Else blocks of an IF statement contains the same code, in which case the IF block is dropped. (These IFs are often the result of the migration of similar Property Let/Set procedures.)
|
|
Optimized Boolean operations
|
MO
|
|
|
|
The PostProcess pragma allows you to optimize most common Boolean expressions, Read here for several examples of this technique.
|
|
Missing “As” keyword warning
|
M
|
|
|
|
VBMP emits a warning when translating a field, variable, function, or parameter that lacks the “As” keyword into a Variant member, thus giving the developer a chance to fix the problem in the original VB6 code or by means of a SetType pragma.
|
|
Conversion of TypeName into “Is” keyword inside tests
|
MO
|
|
|
|
VBUC can optionally convert a statement such as If TypeName(obj) = “Widget” into the more efficient If TypeOf obj Is Widget. VBMP can reach the same result by means of the PostProcess pragma and gives you other options, e.g. the ability to convert to the more precise If obj.GetType() Is GetType(Widget).
|
|
Auto-implemented properties (VB 2010)
|
MO
|
|
|
|
Thanks to the PostProcess pragma, VBMP users can refactor standard property procedures into auto-implemented properties. (Read here for more details.)
|
|
Unused type libraries
|
M
|
|
|
|
VBMP emits a warning if a VB6 project references one or more type libraries that are never actually used and suggests to remove the reference from the original code (or from the converted .NET code, using an appropriate PostProcess pragma).
|
|
Slow string concatenations
|
O
|
|
|
|
VBMP emits a warning when a string concatenation operation occurs inside a loop and suggests to replace the string with a super-efficient StringBuilder6 object.
A single SetType pragma is then sufficient to enable the replacement, no other manual code edits are required. This technique can speed up the .NET code by two or three orders of magnitudes
(as explained in this article).
|
|
String concatenations with Text property
|
O
|
|
|
|
VBMP automatically generates calls to AppendText methods in lieu of concatenations of Text property (e.g. Text1.Text = Text1.Text & “*”) in TextBox, ComboBox, and RichTextBox controls, a refactoring technique that speeds up the VB.NET code by a factor of 100x or more.
|
|
Inefficient collections
|
O
|
|
|
|
VBMP can replace the standard VB.NET Collection object and the Scripting.Dictionary object with faster VB6Collection and VB6Dictionary .NET objects, without losing functional equivalence. VBUC can convert a Collection into a .NET ArrayList or HashTable, but this replacement can’t be performed in all cases.
|
|
Long namespaces
|
M
|
|
|
|
VBMP automatically shortens objects namespace if a suitable project-level or file-level Imports statement has been enforced (see AddImports pragma).
|
|
Reporting
|
|
Pre-migration, multi-project assessment report
|
T
|
|
|
|
Use VB6 Bulk Analyzer tool to generate detailed metrics of your multi-project VB6
application, then send this report to Code Architects’ support team to receive a detailed pre-migration assessment report, with tips on using VBMP effectively, links to relevant docs and
KB articles, etc. (Similar to Code Advisor and
Assessment Tool,
except these tools only work on a single VB6 project or project group at the time.)
|
|
Post-migration warning report
|
T
|
|
|
|
VBMP generates a separate HTML document
that explains of all the warnings emitted in the converted project, tips to work
around most common issues, etc. At the end of the migration process VBUC doesn’t
provide direct links to specific pages in the documentation.
|
|
Code metrics
|
T
|
|
|
|
VBMP generates detailed code metrics for the code being converted, including code size, complexity (cyclomatic index), loop nest level, etc. Code metrics can be generated at the solution, project, and file level.
|
|
Multi-project reports in batch mode
|
T
|
|
|
|
VBMP can generate consolidated reports
when running in batch mode over a set of distinct projects, a feature which is crucial
when migrating large N-tier apps. The report can include code metrics and/or the
result of compilation. Being generated as an XML file, it can be easily processed
and transformed into other formats by means of XSLT.
|
|
Estimation of migration time/cost
|
T
|
|
|
|
VBMP can generate a detailed Microsoft Excel report that summarizes all migration issues and attempts to predict the time and cost required to obtain a working .NET application. The report accounts for different skills and expertise levels (e.g. junior and senior developers, testers, architects) and is fully customizable.
(Similar yet more flexible than Assessment Tool.)
|
|
Support
|
|
Full documentation available online
|
T
|
|
|
|
Prospecting customers can browse VBMP manual before purchasing the product.
In May 2009 Artinosft has launched a new website meant to offer full documentation for their VBUC tool,
however a lot of information is still not available.
|
|
Extensive Knowledge Base archives
|
T
|
|
|
|
VBMP users can rely on our Knowledge Base, updated almost daily with how-to articles and troubleshooting tips, and the most detailed list of differences between VB6 and VB.NET languages available on the Internet.
|
|
VB6 and .NET project samples
|
T
|
|
|
|
Developers can run and test open source VB6 projects and see how VBMP converts them, before they purchase our software.
Artinsoft doesn’t provide any complete example of a real-world VB6 project that is correctly converted by VBUC without any pre- or post-migration manual labor.
|
|
Subscription period and free upgrades
|
T
|
|
|
|
During the subscription period VBMP users can download new versions of the migration tool at no additional fee.
|
|
Free tech support via email
|
T
|
|
?
|
|
Tech support during the subscription period is included in VBMP end-user agreement, no additional fee is required. Read what users have to say about our tech support.
|
|
Royalty-free support library
|
T
|
|
|
|
Both VBUC and VBMP come with a royalty-free support library that is required by all converted .NET applications.
|
|
Lifetime free upgrades for the support library
|
T
|
|
|
|
Users of VBMP version 1.xx have a lifetime right to download any future versions of the 1.xx support library, including bug fixes, speed optimization, support for additional controls, and more.
|
|
Bug fixing in deployed .NET apps
|
T
|
|
|
|
If a bug in the .NET application depends on the support library, the VBMP team will promptly fix it and provide a new build of the library, which can then be deployed to existing users and customers. No remigration or recompilation is needed.
|
|
Support library source code
|
M
|
|
|
|
Please contact Code Architects for details on licensing VBMP library’s source code.
|
|
For the sake of objectivity...
|
|
Refactoring of API calls into a separate class
|
M
|
|
|
|
VBUC 4.0 can move all Declare statements to a separate class. More info here.
|
|
WebClasses
|
CR
|
|
|
|
Both UW and VBUC support WebClass components by means of a combination of generated .NET code and helper classes. VBMP doesn’t support WebClass apps because we strongly believe that they should be rewritten as ASP.NET for best performance and ease of maintenance.
|
|
Conversion from ASP to ASP.NET
|
M
|
|
|
|
VBUC supports conversion of a subset of ASP features to ASP.NET. For more details read here.
|
Another way to compare VB6 migration tools is to check the list of migration warnings that they emit.
We have carefully scrutinized all VBUC’s Errors, Warnings and Issues (EWIs), using
its online documentation. It’s worth noticing that,
seven years after VBUC inception, this documentation hasn’t been completed yet and many EWIs are
still not documented. You can find the result of our analysis in
this table.
Each EWI from VBUC contains the URL of a web page that explains the problem and how to fix it. (In theory at least, because a few URLs lead you to a blank page…). In addition to getting information on individual warnings, VBMP users can quickly obtain a report that recaps all the warnings in the generated code *and* the recommendations for each of them. It’s a minor detail that saves you precious minutes and immediately provides an overview of the overall effort and expertise that are necessary to successfully complete the migration.
VBMP was created with just one goal in mind: converting VB6 projects into VB.NET as easily and accurately as possible, and was later extended to generate optimized C# code. The conversione engine is written in highly optimized, object-oriented VB.NET and can be extended using any .NET language. Thanks to these features, VBMP runs about 5 times faster than UW and delivers VB.NET code with 10-15x fewer compilation and runtime errors.
UW and VBUC share the same language-agnostic conversion engine (codenamed Freedom™) used in other Artinsoft's conversion tools for Java and C#. A few VBUC features can be customized only by means of conversion rules written in a proprietary programming language named Kablok.
Code Architects is committed to produce a VB conversion software. Even if we do
offer migration services, most of our revenues come from product sales. Tech support
for VB Migration Partner is free (subject to the conditions of its EULA), customers have to bear no additional or unplanned
costs. The fact that we don’t make money from support means that we put all
our efforts into a software that requires a very limited degree of tech support.
Our competitors have a mixed approach to migration: they offer both a tool and migration
services and consulting. Interestingly, available case studies show that on-site consulting and mentoring
is nearly always necessary to complete most migration projects above a few hundred
thousand lines of code (LOCs).
By comparison, our customers routinely port VB6 applications several millions lines
of code, just using the retail VBMP edition and standard tech support from Code
Architects.
The entire documentation is searchable. Developers involved in the migration project can often solve their doubts in few seconds and without contacting Code Architects support.
If they really need assistance, however, our tech support team is just one email away.
The people who reply to your enquires are often the same guys who authored the software and our customers can attest that you won’t wait long for the solution to your enquiry.
All VB6 conversions software available on the market somewhat rely on a support library to reduce the number of compilation and runtime errors. VBMP library is undoubtedly the most extensive of the group, an important detail to ensure that functional equivalence with the original VB6 code is preserved and to dramatically minimize overall migration time and cost.
Also, consider that the library supports VB6 features that would be very
difficult to implement in the .NET application using a conventional migration
tool. For example, VB Migration Partner supports both “classic” and
OLE drag-and-drop and eliminates the need to manually convert any D&D-related
code to .NET. Same consideration applies to graphic methods and the “double-buffering”
feature offered by the AutoRedraw property. VB Migration Partner even supports DDE-related
properties, methods, and events, which means that you don’t have to redesign
your application to implement a proprietary form of inter-process communication
– perhaps based on .NET remoting or Windows Communication Fundation. These
features alone can save you a huge amount of time and can keep the total cost of
migration as low as possible.
Interestingly, our competitors are improving their support library at each new version,
a clear evidence that the support library is the best approach you can use in migration
scenarios. Regardless of their change of attitude, however, only VBMP provides a
support library that can really take care of all the VB6 features that don’t have
a direct .NET counterpart.
VBMP is the only VB conversion software on the market with support for the innovative convert-test-fix methodology.
In a nutshell, you fix any conversion problem by inserting migration pragmas in the VB6 code rather than editing the converted VB.NET code.
This technique allows you to keep the VB6 and .NET versions in synch until the migration to .NET is complete, regardless of whether the migration takes days, weeks, or months.
Convert-test-fix is an essential feature for companies and ISVs that need to frequently update or improve the VB6 code in the meantime.
By comparison, all other migration tools on the market work on a “snapshot” of the VB6 code base.
If the VB6 code has to be modified afterwards, the edits have to be manually propagated to the .NET code. Such a manual procedure takes time and is error prone,
a problem that VB Migration Partner customers can safely ignore.
In an implicit recognition of the importance of this feature, 7 years after the first release of their VBUC flagship product, Artinsoft introduced a new mechanism named “continuous migration”, which attempts to address this need (in a very partial way).
Selecting the right migration software for your VB6 application isn’t a simple task. A feature comparison table is a good starting point, yet you should consider how important a given feature is important in your specific scenario.
Also, you should always keep in mind that the total cost of a migration initiative includes many items, that might not be immediately apparent.
For example, a support library can dramatically reduce the time and cost for the debug, test, and QA phases.
And the ability to supported incremental (staged) migrations and the convert-test-fix methodology can be indispensable to deliver your .NET software earlier while keeping it always in sync with the original VB6 application.
For more information on how VB Migration Partner can help you convert your VB6 code to .NET faster, just contact us.