Using Custom Maps in the VBUC to change class names

28. September 2009 10:28 by Mrojas in General  //  Tags:   //   Comments (0)

The VBUC has a now a nice feature called CustomMaps.This feature allow the users to perform basic customizations in the way the target code is generated.

During migration the VBUC can perform some name changes due to the Keyword restrictions in .NET.

For example  VB.NET the some of the following keywords that cannot be used as class or variable names:

Interface, Alias, And, Class, Error, Friend, Loop, MyBase, MyClass, Shared, Property

See here for a list of all VB.Net keywords.

1. Open the Artinsoft VBUC


2.  Go to the Tools Menu\Custom Maps Editor


The Custom Maps Editor dialog will show up.


3.  In the Custom Maps Editor select New...



4.  Type a name and description for your custom map.


5. Create some Custom Maps lines.

Follow these steps:

a. First type a new SourceName. The source name is used by the VBUC to identify the element that you want to map.
NOTE: If you are migrating just one Project, you just enter one custom maps line with the the source name of the class you want to rename. If your are migrating several project you must enter an additional line like <ProjectName>.<ClassName> for example Project1.Interface that is because for other projects that have Project1 as a Reference they see that class as Project1.Interface and not just Interface.



b. Set the Map Type. For classes we call it a Type Map. For Functions, Subs or Properties we call it a member map.



c. We now change the New Reference Name. For a class we call a “Reference Name” to every time a the class is used to define a variable. For example each Dim x as Class1, or every appearance as a parameter, like Sub Foo(x as Class1).


d. We set the Reference Action to Modify.



e. And we set the NewDeclarationName to InterfaceClass and the DeclarationAction to Modify



f.  To make sure that Keyword renamed declarations are mapped with your custom maps configuration, you have to add a line just the same as the one you had just entered but type Interface_Renamed in the SourceName



6. Now you have to activate it in your profile. Click on the Edit button for profiles in the main VBUC window



7. If you don’t have a Profile now, In the Profile Maintenance Dialog click New, and type a name for your Profile.



8. In your profile Select the custom maps configuration you just created:


9. Now Upgrade all your code.

VB6 Declarations like:


will be migrated as:

Option Strict Off
Option Explicit On
Imports System
Friend Partial Class Form1
    Inherits System.Windows.Forms.Form
    'UPGRADE_WARNING: (2080) Form_Load event was upgraded to Form_Load event and has a new behavior. More Information:
    Private Sub Form1_Load(ByVal eventSender As Object, ByVal eventArgs As EventArgs) Handles MyBase.Load
        Dim y As InterfaceClass
    End Sub
    Sub Foo(ByRef x As InterfaceClass) 

    End Sub
End Class

And the class definition to:

Option Strict Off 
Option Explicit On 
Imports System 
Friend Class InterfaceClass 
End Class

Extended WebBrowser Control Series: WPF WebBrowser and the NewWindow2

To be able to catch popup windows and open them in your own window you
have to manage WebBrowser events like NewWindow2.

But how do you do that in WPF?

Well it isn’t really that difficult. These are the steps that you have to follow:

1. Add a COM reference to a reference to %windir%\system32\shdocvw.dll

2. Add a new CodeFile to your project. Lets say CodeFile1.cs And put this code:

using System;
using System.Runtime.InteropServices;
[ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
internal interface IServiceProvider

[return: MarshalAs(UnmanagedType.IUnknown)] 

object QueryService(ref Guid guidService, ref Guid riid);


3. To make an easy example. Lets assume we have a very simple window like:


And in that form we need some code like this:

        private void button1_Click(object sender, RoutedEventArgs e)
            Guid SID_SWebBrowserApp = 
new Guid("0002DF05-0000-0000-C000-000000000046"); IServiceProvider serviceProvider =
(IServiceProvider)myWebBrowser.Document; //<—It seams that you need to
// navigate first to initialize this Guid serviceGuid = SID_SWebBrowserApp; Guid iid = typeof(SHDocVw.IWebBrowser2).GUID; //Here we will get a reference to the IWebBrowser2 interface SHDocVw.IWebBrowser2 myWebBrowser2 =
serviceProvider.QueryService(ref serviceGuid, ref iid);
            //To hook events we just need to do these casts
            SHDocVw.DWebBrowserEvents_Event wbEvents = 
(SHDocVw.DWebBrowserEvents_Event)myWebBrowser2; SHDocVw.DWebBrowserEvents2_Event wbEvents2 =
            //Adding event handlers is now very simple
            wbEvents.NewWindow += 
new SHDocVw.DWebBrowserEvents_NewWindowEventHandler(wbEvents_NewWindow);
            wbEvents2.NewWindow2 += 
new SHDocVw.DWebBrowserEvents2_NewWindow2EventHandler(wbEvents2_NewWindow2); } void wbEvents2_NewWindow2(ref object ppDisp, ref bool Cancel) { //If you want make popup windows to open in your own window
// you need to assign the ppDisp to the .Application of
// the WebBrowser in your window
            Window1 wnd = new Window1();
//Just navigate to make sure .Document is initilialized wnd.myWebBrowser.Navigate(new Uri("about:blank"));
Guid SID_SWebBrowserApp = new Guid("0002DF05-0000-0000-C000-000000000046"); IServiceProvider serviceProvider = (IServiceProvider)wnd.myWebBrowser.Document; Guid serviceGuid = SID_SWebBrowserApp; Guid iid = typeof(SHDocVw.IWebBrowser2).GUID; SHDocVw.IWebBrowser2 myWebBrowser2 = (SHDocVw.IWebBrowser2)serviceProvider.QueryService(ref serviceGuid, ref iid); ppDisp = myWebBrowser2.Application; } void wbEvents_NewWindow(string URL, int Flags, string TargetFrameName, ref object PostData, string Headers, ref bool Processed) { MessageBox.Show(URL); } private void button2_Click(object sender, RoutedEventArgs e) { myWebBrowser.Navigate(new Uri("file://D:/MyProjects/ExtendedBrowserExample_v2/test0.htm")); }

Now you can manage your popupwindows:


You can download the test application from HERE

Continuous Migration with VBUC and MS Team System 2005

22. September 2009 09:59 by Mrojas in General  //  Tags:   //   Comments (0)



Performing Continuous Migration with the Artinsoft VBUC and MS Team System 2005 is simple.

The 4 main tasks are:

1. Configure The Microsoft Visual Studio 2005 to use your desired Team System Project.
          For details…

2. Upload an initial version of your VB6 code to the Source Control system. For details…

          Perform an initial migration an establish a baseline. For details…

3. After that you are all set and you can start doing incremental migration.
          For details and an example of continuos migration…

Continuous Migration VBUC-MS Team System 2005: Start up

22. September 2009 09:45 by Mrojas in General  //  Tags:   //   Comments (0)

Make an initial migration of the VB6 source code

1. Open the VBUC


2. Create a Migration Solution for your code (for example C:\MergeExample\Sample1)


3.  Upgrade your code

4. Open the Explorer and navigate to the location of your VB6 code (For example C:\MergeExample\Sample1)

5. Under the directory where your code is located, create a new directory called GreenCode (For our example this directory will be C:\MergeExample\Sample1\GreenCode )

6. Copy your migrated code to GreenCode (for our example it means copying the contents of C:\MergeExample\Sample1\VB6_UpgradedCode to the C:\MergeExample\Sample1\GreenCode).
All this is important to helps us stablish a base line for comparison and merge

7. Open Microsoft Visual Studio 2005

8. On the Team Explorer locate your project (for example MergeExample) and double click on SourceControl

9. On the Source Control Explorer toolbar click the Add Files button


10. Click the Add Folder… button and select the GreenCode folder we had just created


11. Check in the GreenCode. IMPORTANT. Add a descriptive Comment. We recommed at least setting this information:

  • Green Code Date
  • VB6 Source Code Date/ version
  • VBUC version used to generate the Green Code


    12. Create a brach of the Green Code


    Create a Branch of the GreenCode directory and call it MigratedCode.
    For example in the target field type: $/MergeExample/Sample1/MigratedCode


    After branching you will node a MigratedCode folder under Sample1 in the Source Control Explorer


    >Performing Manual Changes in your migrated code







    Now you are ready to perform manual changes in your branch.

  • Check out for Edit the MigratedCode folder

  • Modify code

        Private Sub Command1_Click(ByVal eventSender As Object, ByVal eventArgs As EventArgs) Handles Command1.Click
            MessageBox.Show("Command1 was clicked", Application.ProductName)
        End Sub 


        Private Sub Command1_Click(ByVal eventSender As Object, ByVal eventArgs As EventArgs) Handles Command1.Click
            //mrojas simple change for message box
            MessageBox.Show("Command1 was clicked", Application.ProductName,MessageBoxButtons.YesNo)
        End Sub 



    Check In of your changes

    Changing the VB6 Source Code

    If you have changes in your VB6 source code and you want to feed those changes to the ongoing migration, follow these steps.

    1. Check out the VB6 source code


    2. Overwrite your all sources with the new VB6 source code, or your modify the current version.

    For these example we will modify the current version, by adding a new button


    and adding some comments to our previous code. So now the VB6 code will be:

    Private Sub Command1_Click()
        'This is a sample comment for command1 code
        MsgBox "Command1 was clicked"
    End Sub
    Private Sub Command2_Click()
        'This is a sample comment for command1 code
        MsgBox "Command2 was clicked"
    End Sub
    Private Sub Command3_Click()
        MsgBox "The newly added Command3 was clicked"
    End Sub

    And after the changes we check in it back.


    Adding a new comment to identify this version



    Performing the Continuous Migration Process

    1. Check out the green code


    2. Open the VBUC and migrated again the VB6 Code. In our example the code is in C:\MergeExample\Sample1\VB6

    3. Copy the new contents of the Upgraded folder and overwrite the contents of folder GreenCode (in this case copy contents from C:\MergeExample\Sample1\VB6_UpgradedCode\Upgraded to C:\MergeExample\Sample1\GreenCode).

    4. Check in the Green Code


  • Add a descriptive comment like:
    Green Code 22-09-2009 12:34pm
    VB6 Source Code 22-09-2009 12:00pm / version 2
    VBUC version 3.0

    Now merge with current manual changes

    After migrating the modified VB6 source code and checked in it in the Source Control we now have to merge the changes between the new GreenCode and our MigratedCode.

    1. Right click on the GreenCode folder and select merge. Put attention to chech that you want to merge the “Selected ChangeSets” and that the target branch is the MigratedCode


    Click Next

    2. Select the Change sets that you will apply. The comment you use provide a guide to identify which changeset you need.


    Click Next

    3. Click Finish to perform the Merge


    4. During merge conflict might arrise. A resolve conflicts dialog will appear. Clicking the resolve conflicts button will provide different options…


    5. In our example we know that we modified the Form1.vb file so we select the “Merge changes in merge tool” option

    TIP: Typically you will just keep changes in target branch because you have already worked on those files. Specially for resource files, project files, bitmaps, etc you will leave the file in the target branch.


    6. The merge tool will appear showing the different changes and providing you a simple way to select what version to take or to manually edit the result


    7. When you are done with the Merge tool click close a dialog indicating that all conflicts have been solved will appear. Click Yes


    8. Click close in the Resolve Conflict dialog and if asked to accept the merge result click yes


    The Source Control Explorer might show marks in the modified files.


    9. Right click on the migrated code and select check in changes


    10. Type an appropiate comment indicating which versions where merged and press Check In



    And that’s all



  • Creating a new Team System Project in Visual Studio 2005

    22. September 2009 09:31 by Mrojas in General  //  Tags: , , , , , ,   //   Comments (0)


    To create a new Team System Project in Visual Studio 2005, follow these steps:

    1. Go to the File Menu. Select New…, and in the New… submenu select Team Project… to start a wizard.


    2. The “Specify the Team Project Settings” of the New Team Project wizard appears. Type the Team Project name. For example type MergeExample and click Next


    3. In the following page, select the Process Template for the Team Project. We recommend using the Artinsoft Migration Methodology – v0.8 or later. Click Next.


    4.  In the following page, type the Title for the Team Project Portal. Type MergeExample. The Team Project Portal provides useful information about your project. Click Next


    5. In the following page you select your source control settings.
    Select the first option “Create an empty source control folder”. Click Next


    6. In the following page a summary of your Team Project settings is presented. Click Finish


    7. In the following page the a process bar appears while the project is created. Just wait until the process is done. It normally takes between 3 and 5 minutes.


    Continuous Migration VBUC-MS Team System 2005: Configure MS Visual Studio 2005 to use Team System

    22. September 2009 08:57 by Mrojas in General  //  Tags: , , , , , , ,   //   Comments (0)

    This post will show you the necessary steps to configure Microsoft Visual Studio 2005 to use a Team System Project. In this example we will use a Team Project created to illustrate Continuous Migration with VBUC and MS Team System 2005, called MergeExample.

    1. Start Microsoft Visual Studio 2005

    2.  Go to the File Menu\Open\Team Project…


    3. Dialog is presented, where you can choose your Team Foundation Server, and the Team Project to use. For these Continuous Migration example we’ll assume a project called MergeExample.


    4. The Team Explorer is shown, with your selected project.
    Expand the elements for the Team Project you previously selected.


    5.  We now have to map our local directories to bind them to the
    source control system. On the expanded tree, double click on the
    Source Control Node


    6. The Source Code Explorer is shown:


    7.  Go to the Workspaces dropdown box and select Workspaces…


    8.  The Manage workspace dialog is shown.
    Select the appropiate workspace and click Edit…


    9. On the Edit Workspace dialog type a description for your source control and select the source control Folder we had created (for this example it is $/MergeExample) and the directory for your code (for this example it is C:\MergeExample).







    NOTE: if a message box about a pending update is shown, just click ok.


    Now you have successfully mapped your directories, and you can start setting up your VB6 code for continuous migration

    Upcoming Webcast on VB 6 and Windows 7 Compatibility Alternatives

    21. September 2009 10:23 by enassar in General  //  Tags:   //   Comments (0)

    Last month we delivered a webcast around the different options to get applications originally developed in Microsoft Visual Basic 6.0 running on the Windows 7 operating system. It also covered some of the business reasons for getting applications to work with Windows 7 and the benefits provided by that operating system and the .NET Framework. We did this with Microsoft Latinamerica, so it was in Spanish, but many people asked for an English version of the presentation. Hence, we partnered again with Microsoft to develop a similar webcast entitled “Visual Basic 6 and Windows 7: Alternatives for Application Compatibility”, scheduled for Thursday, October 15, 2009 1:00 PM Pacific Time. This live event is part of Microsoft’s “Momentum” initiative, which is designed for growing and mid-sized organizations and provides expert advice, tips, and techniques to align IT with your strategy and drive your business forward.

    Register for this free VB6 / Windows 7 compatibility webcast

    Getting the Screen Coordinates of a Cell in a DataGridView

    16. September 2009 05:23 by Mrojas in General  //  Tags:   //   Comments (0)

    Well, this is actually quite easy.

    To get the X and Y of a Cell you just need to do something like:


    or for the selected cell use:



    And to convert that to screen coordinates do:



    mmm Well I found that

    grid.GetCellDisplayRectangle(columnIndex, rowIndex, false) is a better alternative, because it will give you the Rectangle for the whole Cell

    Leading ISV for the Insurance sector saves time and money and ensures high quality, 100% .NET code by licensing the VBUC

    8. September 2009 06:33 by enassar in General  //  Tags:   //   Comments (0)

    Recently, one of customers in the UK, an Independent Software Vendor with headquarters in Bristol, told us that they managed to save about 14 man/months by using ArtinSoft’s VB to .NET tool to migrate their flagship application, comprised by 59 VB6 projects and a total of more than 550,000 lines of code.


    We are talking about a critical, comprehensive processing platform used by insurers, managing agents, third party administrators and business process outsourcers, with installations in the UK, Ireland, USA, Middle East, Far East, China and Africa, and Activus really needed to ensure compliance for these customers in the international health insurance sector.


    There were definitely some time constraints, plus the value and complexity of the business logic embedded in the application didn’t favor a manual rewrite. So they licensed the Visual Basic Upgrade Companion and performed the migration in-house, and managed to maintain the current application’s architecture while moving the visual controls to .NET native controls. Additionally, coding patterns were consolidated, and data access models (ADO) were upgraded to ADO.NET.


    In the end, Activus not only was able to cut down the migration time substantially, but the benefits of the Visual Basic Upgrade Companion went beyond time and cost reductions: the resulting code was far superior from the one generated by other migration tools. As Chris Routleff-Jones, Solution Architect at Activus puts it:  “We found the Visual Basic Upgrade Companion to be a very powerful, easy to use migration product. Not only did it speed up the conversion process, allowing us to save time and money, but we ended up with high quality, 100% native .NET code. In fact, we were particularly impressed by the VBUC’s ability to analyze the code and detect patterns that are upgraded to .NET-like, native structures, making the output fully readable and maintainable”.


    Read the complete Activus VB to .NET migration case study


    Where is my DXCore

    19. August 2009 05:06 by Mrojas in General  //  Tags: , , , ,   //   Comments (0)

    I’m an enthusiastic user of DXCore and I have been working on some extensions of my own. But I could not find the DXCore or DevExpress menu.

    Well there is a hack for that.

    Please invoke the Registry editor, add the "HideMenu" DWORD value to the following Registry key, and set its Value to 0:
    HKEY_LOCAL_MACHINE\SOFTWARE\Developer Express\CodeRush for VS\9.1
    This should make the "DevExpress" menu visible.

    Look at the post for more details and keep enjoying DXCore.

    C# PInvoke out or ref??

    17. August 2009 09:40 by Mrojas in General  //  Tags: , , , ,   //   Comments (0)

    If I have a PInvoke call like the following:

    [DllImport("Advapi32.dll", CharSet=CharSet.Auto)]
    static extern Boolean FileEncryptionStatus(String filename, 
       out UInt32 status);

    What is the difference between


    [DllImport("Advapi32.dll", CharSet=CharSet.Auto)] static extern Boolean FileEncryptionStatus(String filename, out UInt32 status);


    [DllImport("Advapi32.dll", CharSet=CharSet.Auto)] static extern Boolean FileEncryptionStatus(String filename, ref UInt32 status);

    Well, as long as I have tested it, they exactly the same. From the MSDN you can even read

    “I could have selected the ref keyword here as well, and in fact both result in the same machine code at run time. The out keyword is simply a specialization of a by-ref parameter that indicates to the C# compiler that the data being passed is only being passed out of the called function. In contrast, with the ref keyword the compiler assumes that data may flow both in and out of the called function.”

    “When marshaling pointers through P/Invoke, ref and out are only used with value types in managed code. You can tell a parameter is a value type when its CLR type is defined using the struct keyword. Out and ref are used to marshal pointers to these data types”

    So what should you use? Well using the out keyword for PInvoke will just add some information or documentation to your method, but because these functions are implemented in C or C++ they might treat an out parameter as an IN parameter so I really prefere to use ref when I’m calling functions with PInvoke.

    Migration from .NET Framework 1.1

    13. August 2009 18:07 by Mrojas in General  //  Tags: , , , , , ,   //   Comments (0)

    .NET has been around for quite a while. According Wikipedia it has been around since on 3 April 2003
    So now there exist applications developed for .NET Framework 1.0 or 1.1 and people
    need to migrate them to Framework 2.0 or Framework 3.5.

    It is the general impression that there is not a direct path to 3.5.
    As Zain Naboulsi explains in his blog you can go from 1.1 to 2.0 then from 2.0 to 3.5.
    And From 2.0 to 3.5 the migration is a no-brainer because, both, 3.0 and 3.5 are based on 2.0.

    A good reference also is the post of Peter Laudati on migration from 1.1 to 2.0.
    Note: Peter’s post seem to have a broken link to the microsoft document about breaking changes in 2.0.
    The correct link is this.

    A more recent post by The Moth provides more links to breaking changes documents:

    - Design time Breaking Changes in .NET Framework 2.0
    - Runtime Breaking Changes in .NET Framework 2.0
    - Microsoft .NET Framework 1.1 and 2.0 Compatibility
    - Compatibility Testing Scenarios

    Going from 1.1 to 2.0 or 3.5 can be just as simple as opening the solution in VS and compile
    or it can take a lot of effort. Web Projects then to be more difficult due to several changes in ASP.NET.

    So good luck.


    Well there a lot of static analyisis tools we have used
    (some internal, some from Third Parties. I particulary like Understand and NDepend)

    No more System.Data.OracleClient

    7. August 2009 06:15 by Mrojas in General  //  Tags: , , , , ,   //   Comments (0)

     Microsoft announced that they won’t support the System.Data.OracleClient anymore :(


    The message says that it will still be available in .NET 4.0 but “deprecated” and that it wont impact existing applicatoions.


    So what are my options?

    Well you have to go to a third party. Not now but eventually.


    Oracle Data Provider for .NET (ODP.NET) (Oracle states that ODP.NET is Free)

    DataDirect ADO.NET Provider for Oracle

    dotConnect for Oracle


    Migration to ODP.NET


    Microsoft OracleClient to ODP.NET Application Migration: Code Migration

    Oracle provide general instructions. In summary you need to:

    1. Add the references to Oracle.DataAccess
    2. Change namespaces: System.Data.OracleClient by  Oracle.DataAccess.Client; and maybe add “using Oracle.DataAccess.Types”
    3. Update the connection String (most attributes are the same). Change Integrated Security by  "User Id=/", change “Server” attribute to “Data Source” and remove Unicode
    4. The following is anoying but you have to add after all OracleCommands something like OracleCommand1.BindByName = true;


    • Oracle Universal Installer (either in normal installation or Silent Install)
    • XCopy (I like this :) ) just remember to download the ODAC xcopy version

    Extended WebBrowser Control Series: NewWindow3

    Recently an user of the ExtendedBrowser v2 commented that he needed access to the NewWindow3 event.

    The NewWindow3 event is raised when a new window is to be created. It extends NewWindow2 with additional information about the new window. 


    Private Sub object_NewWindow3( _
    	ByRef ppDisp As Object, _
    	ByRef Cancel As Boolean, _
    	ByVal dwFlags As Long, _
    	ByVal bstrUrlContext As String, _
    	ByVal bstrUrl As String)


    object Object expression that resolves to the objects in the Applies To list. ppDisp Object expression that, optionally, receives a new, hidden WebBrowser or InternetExplorer object with no URL loaded. Cancel A Boolean value that determines whether the current navigation should be canceled. true Cancel the navigation. false Do not cancel the navigation. dwFlags The flags from the NWMFenumeration that pertain to the new window.

    typedef enum NWMF 
        NWMF_UNLOADING = 0x00000001,
         NWMF_USERINITED = 0x00000002,
         NWMF_FIRST = 0x00000004,
         NWMF_OVERRIDEKEY = 0x00000008,
         NWMF_SHOWHELP = 0x00000010,
         NWMF_HTMLDIALOG = 0x00000020,
        NWMF_FROMDIALOGCHILD = 0x00000040,
         NWMF_USERREQUESTED = 0x00000080,
         NWMF_USERALLOWED = 0x00000100,
         NWMF_FORCEWINDOW = 0x00010000,
         NWMF_FORCETAB = 0x00020000,
         NWMF_SUGGESTWINDOW = 0x00040000,
         NWMF_SUGGESTTAB = 0x00080000,
         NWMF_INACTIVETAB = 0x00100000
    } NWMF;

    bstrUrlContext The URL of the page that is opening the new window. bstrUrlThe URL that is opened in the new window.

    Please notice:

    Note   The NewWindow3 event is only fired when a new instance of Internet Explorer is about to be created. Calling showModalDialog or showModelessDialog does not trigger an event because they are not new instances of Internet Explorer. They are implemented as MSHTML host windows, which allows them to render and display HTML content but not hyperlinks between documents.

    You can download from here

    DOWNLOAD CODE HERE v3_1 (92.56 kb)

    Upcoming Webinar: “Actualiza tus apliaciones y consigue el logo de Windows 7”

    6. August 2009 06:57 by Jaguilar in General  //  Tags: , , , ,   //   Comments (0)

    Next Monday, August 17, I will be presenting a Webinar along with Microsoft for the Latin America region on how you can use several options to get your VB6.0 applications to run on Windows 7 AND get the Windows 7 logo. The webinar will be in Spanish, and covers the business reasons for the migration, the benefits of using in the .NET Framework, alternatives, and information (+demo) of the VBUC.

    Here’s the link so you can register for the Webinar:

    Actualiza tus apliaciones y consigue el logo de Windows 7
    Fecha: 17 de agosto 05:00 p.m. Ciudad de México
    Register for the Webinar

    Follow us on Twitter

    5. August 2009 09:28 by Jaguilar in General  //  Tags: ,   //   Comments (0)

    A quick post to let everybody know that you can now follow us on twitter. To do so, you just need to follow @artinsoft, or add “artinsoft” in your favorite Twitter client. In this account we are posting news and articles related to software migrations, and you can also use it to communicate directly with us in case you have any question or want to give us any feedback.

    ArtinSoft Twitter page

    New Case Study: Wolters Kluwer successfully migrates 3 million LOC using the Visual Basic Upgrade Companion

    5. August 2009 09:05 by Jaguilar in General  //  Tags: , ,   //   Comments (0)

    We just posted a new case study about how an Italian company, Wolters Kluwer Italia, managed to successfully migrate its flagship Accounting and Financial services product from VB6.0 to Visual Basic .NET, using a customized version of the Visual Basic Upgrade Companion.

    This Wolters Kluwer is a case where the VBUC customizations performed by ArtinSoft helped them achieve two very important goals: first, to radically speed up the overall migration project, by having the VBUC do particular transformations that otherwise would have required manual changes, and second, to meet very specific requirements for the migration, such as using having the VBUC generate .NET code that used their own controls, do additional refactoring to the code, and other architectural customizations made possible by the VBUC engine.

    Read the case study: Wolters Kluwer licenses the Visual Basic Upgrade Companion to quickly and cost-effectively modernize its flagship Accounting/Fiscal software product

    Italian ISV licenses the VBUC to quickly and cost-effectively migrate their flagship software suite

    5. August 2009 08:35 by enassar in General  //  Tags:   //   Comments (0)

    Using ArtinSoft’s powerful VB to .NET migration tool to convert their 3,000,000 lines of code Sistema Professionista to VB.NET, Wolters Kluwer Italia saved 2 years of work, while increasing developer productivity and ensuring continued application evolution.


    Based in Milan, Italy, IPSOA is part of Wolters Kluwer, a leading global information services and publishing company. Their Accounting/Fiscal client/server system was a suite of applications developed in Microsoft Visual Basic 6.0 that required deployment on a per-customer basis, using an installer for each workstation. IPSOA required a more sophisticated deployment approach for its thousands of clients, plus ensuring continued support from Microsoft and application evolution while maintaining the current architecture, so they licensed ArtinSoft’s Visual Basic Upgrade Companion to migrate the flagship application to VB.NET. ArtinSoft’s VB to .NET migration product was able to comply with very explicit requirements, like using COM Interoperability to interact with the libraries and controls used in the original system, mapping of the Datafield property of some controls to a new generated class, precise solutions for the conversion of the Recordset Source Property, While statement, Redim and Control Arrays, and implementing support for additional third-party controls


    Through a phased upgrade approach recommended by ArtinSoft, the customer was able to reduce even further the risk and amount of allocated resources on the migration project, while keeping in parallel the development and maintenance of the VB 6.0 code. Overall, the migration to the .NET platform will strengthen the technological advantage over competing products and will open the possibilities for quick application enhancement, with highly increased developer productivity.


    As Roberto Fusè, lead resource at IPSOA for the VB migration project said, ArtinSoft is a qualified company that has made of the intelligent automation one of its prerogatives of core business. By using the Visual Basic Upgrade Companion, IPSOA was able to save 2 years of work, receiving from ArtinSoft’s the support necessary to customize the tool, which allowed the evolution of the product using the features of Microsoft’s .NET Framework and the new development tools”.


    Read the complete Wolters Kluwer Italia VB to .NET migration case study.

    Counting Duplicate and Shared Lines of Code

    4. August 2009 09:48 by Jaguilar in General  //  Tags: ,   //   Comments (0)

    One question commonly asked by our customers is how both duplicate (same file copied in several projects) and shared files (one copy of the file referenced from multiple projects) are counted. If you create a migration solution using the VBUC, it counts the lines of code in a project (Lines column):

    This number displayed in the VBUC includes all the lines of code from files referenced in the *.vbp project. This means that it counts shared files and duplicate files each time they appear. This may increase the final amount of lines of code of the total solution. If you do need to find out the number of lines of code counting these files once, we offer you two options:

    The first one is to download and run our new Visual Basic 6.0 and ASP Assessment Tool. This brand-new assessment tool considers both Shared and Duplicate files and counts both accordingly in separate columns.  As shown in the screenshot below, the Assessment Tool identifies “Potential Duplicates”, which are files that have the same name and the same amount of effective (code + design) lines of code. In practice, they are normally the same file copied over several projects. You should note, however, that there may be small changes that keep the same amount of code (assignments, calls to different functions, etc), so there is no guarantee they are exactly the same. FYI, this was done to speed up the analysis process. In the future we will add additional heuristics to eliminate the possibility of false positives.

    The second option is to use the same VBUC, but run a detailed analysis using the “Assessment” option. This can be executed from the main menu by selecting Upgrade->Assessment:

    This is a more exhaustive assessment than the one executed by the VB6.0/ASP Assessment Tool, and takes much longer to execute. This assessment will not create an HTML report (like the VB6.0/ASP Assessment Tool), but you can open the detailed line count report produced (Assessment_LOC_Report.xml) using MS Excel 2003 or higher.

    Webcast: Reasons to Migrate Visual Basic 6 to .NET and Migration Options

    24. July 2009 06:11 by enassar in General  //  Tags:   //   Comments (0)

    We have partnered with Microsoft to deliver another VB6 to .NET migration webcast next Tuesday, August 04, 2009 at 11:00 AM Pacific Time (US & Canada). Presented by Esteban Brenes, Migration Specialist at ArtinSoft, this 1-hour live presentation addresses concerns about the termination of all development support for Visual Basic 6 and other business and technical drivers, providing a detailed explanation on how to move ahead while preserving the capital invested in applications in the most cost-effective way.

    Register now for this free VB migration webcast