ActiveX Server Migration to .NET

 In VB6 ActiveX-EXEs or ActiveX OLE Server where used for several reasons. Sometimes it was performance (because it allowed you to run your code in another process) and sometimes as way to share resources between several applications, like connection information, database connections, mainframe info, etc.

During migration some of this ActiveX-Exes can be migrated as simple Assembly DLLs, but other require more attention. Specially if they have global variables that hold state shared by several programs.

In that is your case what are your options then?

1. Convert those ActiveX-Exes to Windows Services.

This option is simple. You modify your migrated assembly to work as a Windows Service. The easier way to do that is:

a) Start Microsoft Visual Studio 2005\2008

b) Go to File\New…\Project… and Select Windows Service

That will generated code like:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.Linq;
using System.ServiceProcess;
using System.Text;
namespace WindowsService1
{
   public partial class Service1 : ServiceBase
   {
      public Service1()  {   InitializeComponent();    }
      protected override void OnStart(string[] args)    {   }
      protected override void OnStop()    {   }
   }
}

c) Add a reference to the Remoting Assemblies: System.Runtime.Remoting;

d) Modify the previous code:

Add two using statements like:

using System.Runtime.Remoting.Channels.Http;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting;

Add a simple event log for tracing:

private static EventLog evt = new EventLog(“Application”);
private static string SVC_NAME = “ActiveX Server Example Svc”;

 And modify the OnStart and OnStop methods to look like:

  protected override void OnStart(string[] args)
{
    HttpChannel chnl = new HttpChannel(1234);
    ChannelServices.RegisterChannel(chnl,true );
    RemotingConfiguration.RegisterWellKnownServiceType(typeof(MyClass), “MyClass.soap”, WellKnownObjectMode.Singleton);
   evt.WriteEntry(SVC_NAME + ” Started”);
}

protected override void OnStop() { evt.WriteEntry(SVC_NAME +” Stoppped”); }

Also make sure that MyClass extends MarshalByRefClass

2. Convert those ActiveX-Exes using the Artinsoft ActiveX migration helpers.

 Sometimes, you need your migrated application to replicate some of the original ActiveX EXE \OLE DLL VB6 characteristics. For example you need your ActiveX-EXE to start just when the first instance is created and to resemble the VB6 logic for Process creation\destruction.

For that purpose Artinsoft has created some helpers that our migration tool is able to automatically use in the generated code if it detects that this functionality is needed.

The code will then be changed from:

Dim myInstance As New MyProject.MyClass

To the following Helper method:

myInstance = MyProjectFactory.Create< MyProject.MyClass>(myInstance);

 And destroy calls can be changed to the following Helper method:

 myInstance= MyProjectFactory.Dispose<MyProject.MyClass >( myInstance); 

The migration tool will modify your ActiveX-EXEs or OLE Servers to be Windows EXE and the helper will then locate the assembly that contains the desired Class, create an instance and initilize a Remoting channel to the desired classes. Settings as SingleUse and MultiUse are also taken care by the helpers.

3. Other possible alternatives are using WFC and COM+ that I will comment in another post.

Return argument has an invalid type

When you develop applications with remoting, or in some COM + Remoting scenarios, you could start founding very interesting exceptions.

We had a very unconfortable one. We had an ActiveX that is used in an intranet Web Page, that uses remoting to instanciate some classes in the local network.

When we runned outside of the IE, everything seem to work, but running in IE it produced an exception like:

Error : Return argument has an invalid type.
Type  : System.InvalidCastException
Source: mscorlib
Source: at System.Runtime.Remoting.Proxies.RealProxy.ValidateReturnArg(Object arg, Type paramType)
at System.Runtime.Remoting.Proxies.RealProxy.PropagateOutParameters(IMessage msg, Object[] outArgs, Object returnValue)
at System.Runtime.Remoting.Proxies.RealProxy.HandleReturnMessage(IMessage reqMsg, IMessage retMsg)
at System.Runtime.Remoting.Proxies.RealProxy.PrivateInvoke(MessageData& msgData, Int32 type)

Why??? Well what happens is simple, it is having an assembly resolution problem, it is not being able to resolve the type.

We solve the problem adding something like:

1. Find a place in your code to add an event like this (it could be in the Main of your program for example):

static System.Reflection.Assembly CurrentDomain_AssemblyResolve(object sender, ResolveEventArgs args)
{
   System.Reflection.Assembly assembly = null; 
   try
   {
         assembly = System.Reflection.Assembly.Load(new System.Reflection.AssemblyName(args.Name));
   }
   catch (Exception ex)
   { 
       System.Diagnostics.Trace.WriteLine(
            string.Format(“Problem with resolution of {0} : {1} {2}”, args.Name, ex.Message, ex.StackTrace));
   }
   return assembly;
}

Well, this worked for us, and I hope that helps you out.

Visual Basic 6 and Windows 7: Alternatives for Application Compatibility Webcast Recording Available

A quick post to let you all know that the recording of last week’s webcast I did on compatibility options for Windows 7 is now online. In this webcast I briefly covered different compatibility options available for Windows 7, mentioning things like virtualization (such as XP Mode) and Remediation, and the focusing on the benefits of using automated migration tools to get the application off VB6.0 and into .NET so it can take advantage of the new APIs available in Windows 7 (Taskbar API, touch API, etc).

See the recording here

5 myth-busting reasons for choosing an automatic migration against a manual rewrite

There are still many myths out there surrounding software migrations. Through all the years we have found not only that many people still ignore that there are automatic migration tools available, but some believe that automation is just more trouble than it’s worth, and that, besides, it is just plain better to start from scratch. To concur with this idea is, for starters, to simply devalue all of the effort and thought that was put into developing the application, therefore willing to risk years of business knowledge embedded in these systems.

In any case, the truth is that a rewrite from scratch implies a much more difficult task, but due to these misconceptions, valuable resources are wasted in projects that sometimes just never get to see a successful ending. There’s no doubt that any software renewal project isn’t a simple, overnight task, but a well-planned automated migration can make the process comparatively painless. So once you learn about the availability of advanced migration technologies that allow generating code of a superior quality, with a much lower project cost, time and risk, you will definitely agree that using automated migration tools as part of an overall software renewal initiative is the most viable way to leverage the current investment in legacy applications and move them to the latest platforms.

With that in mind I just wrote a white paper highlighting the main myth-debunking reasons why an automatic migration is a far better software modernization approach than a manual rewrite, based not only on ArtinSoft’s own experience in migration projects but on all the customer and industry analyst feedback and evidence gathered over the years.

So click on the link and read or download for free the “5 myth-busting reasons for choosing an automatic migration vs. a manual rewrite” white paper.

Code compiles but System.IO.FileNotFound Exception is thrown

We have seen a situation that can be a little annoying.
I usually find that situation in ASP.NET projects, but it can also happen in Winforms.

The issue is like this:

• You have a VStudio Solution
• You have added all the needed references
• All your code compiles

BUT

When you run the application it terminates at a certain point with a
FileNotFound exception indicating that the assembly blablabla  or one of its
dependencies could not be loaded.

Whats hapenning!!!

Do this:

1) Look at the bin\debug or bin\release and make sure that the assembly is in those directories.

2) If the assembly is not there, then go to the project references in the solution explorer, right click and select properties and set the Copy Local Setting

Mapping VBRUN.RasterOpConstants

System.Drawing.CopyPixelOperation.DestinationInvert

System.Drawing.CopyPixelOperation.MergeCopy

System.Drawing.CopyPixelOperation.MergePaint

System.Drawing.CopyPixelOperation.NotSourceCopy

System.Drawing.CopyPixelOperation.NotSourceErase

System.Drawing.CopyPixelOperation.PatCopy

System.Drawing.CopyPixelOperation.PatInvert

System.Drawing.CopyPixelOperation.PatPaint

System.Drawing.CopyPixelOperation.SourceAnd

System.Drawing.CopyPixelOperation.SourceCopy

System.Drawing.CopyPixelOperation.SourceErase

System.Drawing.CopyPixelOperation.SourceInvert

System.Drawing.CopyPixelOperation.SourcePaint

IE Explorer and Favorites folder or Special Folders in general

I found this email in my inbox today:

“Hi Mauricio,I came across a reference to your blog at :http://stackoverflow.com/questions/1286746/c-open-link-in-new-tab-webbrowser-control

I have been studying your writings on extending the WebBrowser control, and verified that the extended web code you wrote for C# compiles and works fine in VS 2010 beta, against FrameWork 4.0.

Many thanks for the valuble code and writing !

I am "stuck" on how to read the contents of an IE browser page when the page is displaying a local file, like the contents of the Favorites folder.

All my attempts to get at the Document or DomDocument by casting it to the usual mshtml.dll interfaces fail.

I am NOT asking you to answer my question, or respond, but if you ever get interested in blogging about this aspect of use of IE, I think many people would be interested.

I have done a lot of research on the net, and posted my own question on StackOverFlow : so far not one real pointer, and, possibly, this is not "doable" (?) : maybe what you are seeing when IE shows a file contents is a kind of "virtual explorer" view that is not parseable.

best, Bill xxxxxx”

And I decided to take at look at it to see if I could be of any help and I found out that it is easy and doable.

So I find an useful link by Andreas M. if you want to look at it.

In general My Favorites, Desktop, etc are special folder. So they need a trick to be able to access them.

Take the code from my ExtendedWebBrowser sample published in http://blogs.artinsoft.net/mrojas/archive/2009/05/01/opening-popup-in-a-newwindow.aspx

and http://blogs.artinsoft.net/mrojas/archive/2009/08/07/newwindow3.aspx and

1. Add a reference to %windir%\system32\shell32.dll

2. Add a new property to the ExtendedWebBrowser like:

    /// <summary>
    /// Returns the shell folderview object displayed in the webbrowser control.
    /// </summary>
    public Shell32.IShellFolderViewDual2 FolderView
    {
        get
        {
            return ((SHDocVw.WebBrowser)base.ActiveXInstance).Document
                     as Shell32.IShellFolderViewDual2;
        }
    }

And now you can access the special folder from your code. As Bill mentioned, that “page” or “special page” is not real HTML and not parseable but you can examine its contents for example you can do something like:

        /// <summary>
        /// Button 1_ click
        /// </summary>
        private void button1_Click(object sender, EventArgs e)
        {
            Shell32.IShellFolderViewDual2 specialFolder = this.extendedWebBrowser1.FolderView;
            string folderName = specialFolder.Folder.Title;
            string parentFolder = specialFolder.Folder.ParentFolder.Title;
            foreach (Shell32.ShellFolderItem f in specialFolder.Folder.Items())
            {
                if (f.IsFolder)
                    System.Diagnostics.Debug.WriteLine("Folder:" + f.Name);
                else
                    System.Diagnostics.Debug.WriteLine("File:" + f.Name);
            } // foreach
        } // button1_Click(sender, e)

Using Custom Maps in the VBUC to change class names

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: http://www.vbtonet.com/ewis/ewi2080.aspx
    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)]
[Guid("6d5140c1-7436-11ce-8034-00aa006009fa")]
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 = 
                   (SHDocVw.IWebBrowser2) 
                   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 = 
                  (SHDocVw.DWebBrowserEvents2_Event)myWebBrowser2;

            //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();
            wnd.Show();
            //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

Prerequisites:

• You need to install the Team System Client for Visual Studio 2005.
  For details on how to install the Team System Client…
• You need a Team System Project.
  For details creating a new Team System Project for this example…

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

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:

    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 

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

Continuous Migration VBUC-MS Team System 2005:Upload an initial version of your VB6 code

Now all we need to do is setup the VB6 code that we will use for migration. To do that follow these steps:

1. On the Source Code Explorer toolback click on the Add Files button:

2. Click the Add Folder button and select the folder with your VB6 files

3. After you select the folder, a list of files found will be shown. Just remove any unneccesary files. For example files like MSSCCPRJ.SCC should be removed. And press OK

Now you have to commit your code the Source Code Repository

4. On the Source code Explorer Right click on Source Control Folder (for this example is MergeExample) and select Check In Pending Changes..

5. Write an apropiate comment and press Check In

Creating a new Team System Project in Visual Studio 2005

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

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

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

Well, this is actually quite easy.

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

grid.CurrentCell.ContentBounds.Location

or for the selected cell use:

grid.SelectedCells[0].ContentBounds.Location

And to convert that to screen coordinates do:

grid.PointToScreen(grid.CurrentCell.ContentBounds.Location)

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

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

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??

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

and

[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

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

Tools?

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