For over six years, developers wishing to migrate their VB6 to VB.NET could only choose between two tools:

1. Microsoft Upgrade Wizard (free, included in Visual Studio)
2. Artinsoft VB Upgrade Companion

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:

3. VB Migration Partner

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.

Feature Comparison Table

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.

The Benefits column explains why a given feature can be important in migration scenarios:

C: the feature reduces or avoids compilation errors.
R: the feature avoids runtime errors and preserves functional equivalence.
M: the feature generates code that is more readable and concise, abides by .NET programming guidelines, and makes maintenance easier.
O: the feature generates optimized and faster VB.NET code.
T: the feature can reduce overall migration time and cost, for example it eliminates the need to prepare the VB6 app for the migration. Features that reduce learning and support costs also fall in this category.

NOTES
Fully supported features are marked with , features that are only partially supported with P. The e symbol is used for features that are available only in VBMP Enterprise Edition or only in VB Upgrade Companion Enterprise Edition (as opposed to VBUC Developer Edition).

We used the documentation available on Artinsoft Web at this time (January 2009) to decide whether VBUC supports a given feature, and we used a question mark (?) if we couldn’t find enough details on a specific feature. We will update this document as new information is made publicly available and will promptly revise the items that our competitors or readers deem to be incorrect or misleading. If a given feature is essential for your migration purposes, we recommend that you contact Artinsoft directly for additional details.

UPDATE (May 18, 2009): This week Artinsoft released VBUC 3.0 and launched a new web site with improved documentation. As promised, we have updated this document accordingly and were able to drop several question marks from the original table.

Feature	Benefits	UW	VBUC	VBMP	Notes
General
Conversion of VB6 project groups	CT		P		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		e	e	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		P		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		P		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		e		VBMP can use regular expressions to pre-process VB6 code or post-process the generated VB.NET 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 VB.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 3.0 introduces a new merge mechanism named continuous migration that should permit to preserve portions of VB.NET 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			e	VBMP generates .NET 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			e	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		e		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).
Language
Arrays with nonzero lower bound	CR		P		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	P			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	P	P		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 where 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	P	P		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	P	P		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				VB.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.
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).
VarPtr, StrPtr, ObjPtr undocumented functions	C			P	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			P	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.
VB6 language objects (e.g. App, Screen)	CR	P			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	P	P		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.
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 VB.NET applications 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 VB.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.
Classes and Components
Resolution of default property in late-bound scenarios	R		e		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	P	P		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.)
Deterministic finalization for IDisposable objects	RMO		P		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 added this feature in version 3.1, but it offers no way to indicate that an external object (e.g. a COM object) is disposable and requires this special coding pattern.
Property Get/Let/Set procedures	C	P	P		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	P	P		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		P		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 virtually all 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	P	e		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			e	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.
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.
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	P	P	P	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		P		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	P	P		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	P	P		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.
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 VB.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 VB.NET does.
Dynamic Data Exchange (DDE) properties, methods, and events	CR			P	VBMP supports DDE communications between two forms of the same application or two (or more) migrated VB.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.
100%-compatible 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 3.0 improves the support for this controls, but it is far from achieving 100% compatibility.
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.
Stub members for unsupported features in control library	C		?	P	To quickly reach the zero-compilation error stage, VBMP provides do-nothing properties, methods, and events to avoid compilation errors when migrating unsupported features. (No runtime support for these features is provided.)
Support for window subclassing	CRMO				VBMP provides the special VB6WindowSubclasser helper class , which makes it easy to convert VB6 code that uses window subclassing.
Code Analysis and Refactoring
Conversion of On Error into Try-Catch	MO		e	e	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			e	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		e	e	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		e		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		e	e	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		e	e	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			e	VBMP can translate Gosubs into calls to separate private methods in most cases (see ConvertGosubs pragma).
Conversion of ByRef into ByVal	MO		e	e	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 VB.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			e	VBMP can replace fields with Property procedures and generate better structured VB.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.)
IsNot operator	O		?		VBMP automatically refactors expressions such as “Not x Is Nothing” using the IsNot operator.
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.
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 VB.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 VB.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		P		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		P		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.
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.
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 VB.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		P		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 VB.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				VBMP users can download new versions of the migration tool at no additional fee, during the subscription period.
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 VB.NET apps	T				If a bug in the VB.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			e	Please contact Code Architects for details on licensing VBMP library’s source code.
ADO.NET support	O		Pe	e	According to VBUC brochure, it can convert DAO, RDO, and ADO code into references to ADO.NET objects; it isn’t clear whether keysets/dynamic server-side cursors are converted and the exact degree of support for the countless ADODB features. Code Architects’ ADOLibrary offers complete support for ADO.NET with nearly 100% coverage of ADODB features.
For the sake of objectivity...
WebClasses	CR	P	P		Both UW and VBUC support WebClass components by means of a combination of generated VB.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 VB6 to C#	M				VBUC supports conversion to C#. Because of the huge gap between VB6 and C#, a certain amount of manual edits before or after the migration is required.
Conversion from ASP to ASP.NET	M		Pe		VBUC supports conversion of a subset of ASP features to ASP.NET. For more details read here.

Migration warnings and issues

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 (as of mid-October 2009). You can find the result of our analysis in this table.

Here’s a quick recap of our findings:

• VBUC can emit 57 different EWI messages, related to VB6 features that it fails to migrate correctly.
• In 8 cases, the EWI message is associated with a blank page, leaving users without a clue about how to fix the problem.
• VBMP supports a much wider range of VB6 features, and in fact emits only 4 messages related to unsupported features, plus 3 messages related to features that are supported only partially

VBMP generates 10-12x fewer warnings than VBUC on the average, thus you can expect a proportional increase in productivity in real-world migration projects (and a proportional decrease of migration costs).

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.

What the feature table doesn’t tell

1. Designed specifically for VB6-to-VB.NET conversions

VBMP was created with just one goal in mind: converting VB6 projects into VB.NET as easily and accurately as possible. It 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.

2. Product-oriented vs. service-based approach

Code Architects is committed to produce a VB conversion software. With very few exceptions, we don’t directly offer migration services to customers and make our revenues exclusively 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.

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).

As an example of how the software flexibility can affect the duration and overall cost of migration, consider that one of our customers is currently porting a “monster” VB6 application of 15 million LOCs and 1500 projects to VB.NET, by far the largest VB migration project ever performed by means of an automatic conversion software - and more than 3x larger than the largest VB migration project documented on our competitors’ web site – just using the retail VBMP Enterprise Edition and standard tech support from Code Architects. (A case study will be available as soon as we have the permission to disclose details about our customer and the application in question.)

Code Architect’s approach keeps total migration cost and time as low as possible and makes VB6-to-VB.NET migrations affordable to companies of any size and for projects of any complexity. The very fact that our tech support is included in purchase price guarantees that our main concern is to relentlessly improve our product and making it as easy-to-use, powerful, and robust as possible. No need to hire external .NET experts or consulting companies.

3. Easy troubleshooting, reactive tech support decreases overall costs

VBMP manual and the entire Knowledge Base is available online. Developers can learn about features and limitations of our product before they purchase it. No pre-sale hype, no post-sale apologies, just mere facts.

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.

4. Extensive support library provides functional equivalence

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 VB.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.

VBMP library has many other important advantages, including a few non-obvious ones. Read about them in our 17 Reasons for using a support library in migration scenarios white paper.

5. Support for evolving VB6 applications

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 VB.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 VB.NET already migrated. 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).

Also, VBMP is the only VB migration software that fully supports staged migrations of large N-tier apps, i.e. the ability to convert an individual VB6 component without breaking the binary compatibility or having to recompile existing COM clients. This important feature allows you to focus on the portions of the applications that urgently require a rewrite to .NET and postpone the conversion of less critical components. The ability to use existing UI clients to test the converted .NET DLLs dramatically simplifies the debug and QA phases.

6. A reliable team – and Microsoft acknowledges it

VBMP is the joined effort of a group of internationally well-known industry experts, including three authors of top-selling VB books and two Microsoft Regional Directors. (Microsoft Corp. has designated only about 140 RDs world-wide, chosen among the most authoritative independent .NET experts)

Both Code Architects and Artinsoft are recognized Microsoft Visual Studio Partners and take part to the VSIP program.

As of this writing, Code Architects is the only Microsoft ISV NXT world-wide partner who specializes on migration of VB6 legacy applications.

Conclusions

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 VB.NET faster, just contact us.