ArtinSoft's Blogs

Software Migration Experts
Welcome to ArtinSoft's Blogs Sign in | Join | Help
in Search

Mauricio Rojas Blog

August 2008 - Posts

  • Late Binding migration to C#

    VB6 was not a strong typed language like C#. If you were to write a routine in C#,
    you will probably avoid using variables defined as object.
    Thats the whole idea behind work like Generic Collections.

    So let's see an interesting example of Late Binding migrations.

     

    Sub ChangeValue(x As Object, newValue As Object)
     x.Value = newValue
     x.Refresh
    End Sub
    
    Sub Main()
      ChangeValue Me.Command1, False
    End Sub
     
    And the migrated code with the VB Companion tool is:
    
    
    using System;
    using System.Windows.Forms;
    
    namespace Project1
    {
            internal partial class Form1
                    : System.Windows.Forms.Form
                    {
    
                            public void  ChangeValue( Button x,  bool newValue)
                            {
                                            x.PerformClick();
                                            x.Refresh();
                            }
    
                            public void  Main_Renamed()
                            {
                                            ChangeValue(this.Command1, false);
                            }
                            [STAThread]
                             static void  Main()
                            {
                                            Application.Run(new Form1());
                            }
                    }
    }
    
    
  • Scripting your applications in .NET

    In VB6 it was very simple to add scripting capabilities to your application.
    Just by using the Microsoft Script Control Library
    You can still use this library in .NET just as Roy Osherove' Bloc show in
    http://weblogs.asp.net/rosherove/articles/dotnetscripting.aspx

    However there are some minor details that must be taken care of:

    * Objects must be exposed thru COM (Add the [ComVisible(true)] attribute to the class
    * Add the ComVisible(true) attribute to the AssemblyInfo file
    * Make these objects public
    * Recommended (put your calls to Eval or ExecuteStatement inside try-catch blocks).

    And here's an example:

    using System;
    using System.Windows.Forms;
     
    namespace ScriptingDotNetTest
    {
        [System.Runtime.InteropServices.ComVisible(true)]
        public partial class frmTestVBScript  : Form
        {
            public int MyBackColor
            {
                get { return System.Drawing.ColorTranslator.ToOle(this.BackColor); }
                set { this.BackColor = System.Drawing.ColorTranslator.FromOle(value); }
            }
     
            MSScriptControl.ScriptControl sc = new MSScriptControl.ScriptControl();
            private void RunScript(Object eventSender, EventArgs eventArgs)
            {
                try
                {
                    sc.Language = "VbScript";
                    sc.Reset();
                    sc.AddObject("myform", this, true);
                    sc.ExecuteStatement("myform.MyBackColor = vbRed");
                }
                catch 
                {
                    MSScriptControl.IScriptControl iscriptControl = sc as MSScriptControl.IScriptControl;
                    lblError.Text = "ERROR" + iscriptControl.Error.Description + " | Line of error: " + iscriptControl.Error.Line + " | Code error: " + iscriptControl.Error.Text;
                }
            }
     
            [STAThread]
            static void Main()
            {
                Application.Run(new frmTestVBScript());
            }
        }
    }


    TIP: If you don find the reference in the COM tab, just browse to c:\windows\system32\msscript.ocx

     

  • Vb Migration (not for the weak of mind) Post 2

    When people decide to migrate their VB6 applications they eventually end up questioning where they should go. Is VB.NET or C# a good choice?

    I have my personal preference, but my emphasis is in developing the technology to take where YOU want to go.

    VB.NET is a VB dialect very similar to VB6. It supports several constructs and it makes the changes easier.
    C# has several differences from VB6, but it has it a growing language with lots of enthusiasts in its community.
    Obviously migrating VB6 to VB dialect is a task far more easier than migrating to a different language.
    However we are a research company with years of work in this area and challenges is just what we love.

    Let's use a methaphor here.

    My beautiful wife, was born in Moscow, Russia. Like her, I really enjoy reading a good book. Some of my favorite authors are
    russian authors like Dostoievsky, Tolstoi and Chejov. However I still do not speak russian. I have tried, and I will keep trying but
    I still don't know russian. I have read only translations of their books, and I really enjoy them.
    As a native speaker my wife always tells me, that it is not the same to read those books in another language besides russian.
    And they are phrases (specially in Chejov books that I might not completely understand) but I really got the author
    message and enjoyed it.
    Translating a book from russian to a more similar language like Ucranian is easier than translating it to English or Spanish.
    But I think everybody agrees that is a task than can be done.

    You can use terrible works case scenarios, but these scenarios must be analized.
    Let see (I took these example from the link in that Francesco put in my previous post http://blogs.artinsoft.net/mrojas/archive/2008/08/07/vb-migration-not-for-the-weak-of-mind.aspx)

    If you have code like this:

    Sub CopyFiles(ByVal throwIfError As Boolean)
        If Not throwIfError Then On Error Resume Next
        Dim fso As New FileSystemObject
        fso.CopyFile "sourcefile1", "destfile1"
        fso.CopyFile "sourcefile2", "destfile2"
        fso.CopyFile "sourcefile3", "destfile3"
        ' seven more CopyFile method calls …
    End Sub


    and you translate it to:

    void CopyFiles(bool throwIfError)
    {
        Scripting.FileSystemObject fso = new Scripting.FileSystemObjectClass();
        try
        {
            fso.CopyFile("sourcefile1", "destfile1", true);
        }
        catch
        {
            if (throwIfError)
            {
                throw;
            }
        }
        try
        {
            fso.CopyFile("sourcefile1", "destfile1", true);
        }
        catch
        {
            if (throwIfError)
            {
                throw;
            }
        }
        try
        {
            fso.CopyFile("sourcefile1", "destfile1", true);
        }
        catch
        {
            if (throwIfError)
            {
                throw;
            }
        }
        // seven more try-catch blocks
    }

    I think that the russian is really keep in this translation.

    First of all. When you do a translation, you should try to make it as native as possible. So why will you keep using a COM function when there is an
    equivalent in .NET. So why not use System.IO.File.CopyFile("sourcefile1", "destfile1", true); instead?

    Second of all. The On Error Resume Next, I agree is a not a natural statement in C#. I really think that using it could provide results that are less predictable.
    Why? Becuase after executing it, are you sure that all the CopyFile occurred successfully? I would prefer wrapping the whole code inside a try-catch instead of trying
    to provide an implementation that is not natural in C#, will Aspect Oriented programming provide a clean solution for this cases. Maybe?

    RPG and COBOL to Object Oriented Programming, PowerBuilder to C#, Hierarquical Databases to Relational Databases are just the kind of challenges we have faced in our research project.
    Not everything is easy, and we might not be able to automate all the tasks (commonly due to the cost of implementing the automation not becuase of feasability).

    But at the end Could you understand the whole novel?, even if you didn't understand the joke in the one of the paragraphs in the page?

    My years of reading make be belive that you can.


     

  • C# Console Applications and Ctrl-C

    Console applications are still very useful for me.
    I write like 125 console applications in the morning and like 4 or 5 in the afternoon.
    In one of these applications that was running a long process I just started wandering:
    what will happen with Lost? Will ABC ever finish this series?
    And If someone presses Ctrl-C will I be able to catch it?
    And indeed, the greate C# provides a very easi way to do it:

     static void Main(string[] args)
            {
                Console.CancelKeyPress += 
                delegate(object sender, ConsoleCancelEventArgs e)
                {
                    Artinsoft.VBUMKernel.Implementations.UpgradeCommand.StopAllUpgradeProcess(true);
                    Console.WriteLine("Process aborted by user!");
                };
                //Long running process
            }
  • VB Migration (not for the weak of mind)

    Motivation: 

    I hate to be disappointed. Specially if it is by a person you had respect for. And that's exactly what Francisco Balena from VB Migration Partner, has done. I have respected him for his books and all his VB6 experience. In terms of legacy VB6 code he is a monster. He is the man.

    But in terms of code migration...

    I'm not saying this because I work on code migration or maybe I'm biased a little by the fact that I work almost 10 years with a company that has done source code migration research on a big number of legacy languages such as COBOL, RPG, PL\1, Algol, Progress, PowerBuilder and also VB6.

    I can tell the difference between a "compiler" and a system that rewrites a expression to the closest equivalent in the target language. We are aware of limitations. We are aware of paradigm differences and functional equivalence, but we talk from experience. We talk about our results. And we have proven those things we talk about.

     Let's says you create a Cobol Library with a "MOVE" function, and a COBOLPicture Type and add minus, divide, and add operators. And I write something like:

    CobolPicture x = new CobolPicture("XXXX");

    x.move(10);

    x.add(10);

    We have things like that, and it works. It's feasible and maybe there are cases where that is a solution. But we are also proud of have researchers that have been able to detect pattern to rewrite something like that like:

    int x = 0;

    x = 10;

    x+=10;

    And saying, that something is not possible just because you can't or you dont like it, just seem uneducated to me.

     All of this has motivated me to start a series of chapters I for a small blog book I will call VB Migration (not for the weak of mind).

    For those of you, who really are tecnology savvy and are in the process of a VB Migration, this is YOUR book.

Powered by Community Server (Non-Commercial Edition), by Telligent Systems