Convert Visual Studio 2003 forms to Visual Studio 2005/2008 forms using partial classes and Designer files

Question

After migrating my Visual Studio 2003 projects to VS2005 (or VS2008) my forms would still be inside a single file.

New forms on VS2005 and VS2008 are created using partial classes where all code generated by the editor is kept in the Designer.cs file.

Since the VS2005 form creates is a much better way of dealing with forms, I would like to know if there is a way of converting all my old single-file forms to the VS2005 partial class method.

I've done some by hand but this is very tricky and can lead to some serious errors.

Any suggestions? PS: I'm using Microsoft Visual C# 2008 Express Edition.

Answer 1

This seem to be what you want.

Converting Visual Studio 2003 WinForms to Visual Studio 2005/2008 partial classes :

NET 2.0 introduced partial classes which enables “.designer” files in Visual Studio 2005 and later. That is, all of the visual designer-generated code (control declarations, the InitializeComponent method, etc) can be kept in a file separate from your regular code. When you open up a .NET 1.x Visual Studio 2003 WinForms project up in Visual Studio 2005/2008 it will upgrade your project to .NET 2.0 just fine, but unfortunately it doesn’t migrate your WinForms classes over to the new “.designer” project structure.

Initially I thought this would be a job for a DXCore plug-in (the free framework upon which CodeRush is built) as it provides plug-ins with an object model of the code which could be used to grab all the right members and move them over into a designer file. Before I looked into this though I checked what the options were for simply implementing it as a Visual Studio Macro. I was fully expecting to have to use a regular expression to grep the code file to perform the task, but was pleasantly surprised to find that the Visual Studio extensibility API in available to macros provides a code model (based on the .NET CodeDom I presume) which you can traverse to inspect and manipulate the underlying code. So, here’s what the resulting “ExtractWinFormsDesignerFile” macro does:

• Locates the first class in the selected project item (DTE.SelectedItems.Item(1).ProjectItem) by traversing the ProjectItem.FileCodeModel.CodeElements
• Extracts the InitializeComponent and Dispose methods from the class by traversing CodeClass.Members
• Extracts all control fields: that is, all fields whose type derives from System.Windows.Forms.Control or System.ComponentModel.Container or whose type name starts with System.Windows.Forms
• Puts all the extracted code into a new “FormName.Designer.cs” file.

This is currently C# only – it could easily be converted to generated VB.NET code or adapted use the FileCodeModel properly and perhaps create the code in an language-agnostic way when generating the designer file. I took a shortcut in just generating the designer file as a string and writing it directly to a file.

To “install”: download the macro text :

    ' -------------------------------------------------------------------------
    ' Extract WinForms Designer File Visual Studio 2005/2008 Macro
    ' -------------------------------------------------------------------------
    ' Extracts the InitializeComponent() and Dispose() methods and control
    ' field delarations from a .NET 1.x VS 2003 project into a VS 2005/8 
    ' style .NET 2.0 partial class in a *.Designer.cs file. (Currently C# 
    ' only)
    ' 
    ' To use: 
    '  * Copy the methods below into a Visual Studio Macro Module (use 
    '    ALT+F11 to show the Macro editor)
    '  * Select a Windows Form in the Solution Explorer
    '  * Run the macro by showing the Macro Explorer (ALT+F8) and double
    '    clicking the 'ExtractWinFormsDesignerFile' macro.
    '  * You will then be prompted to manually make the Form class partial: 
    '    i.e. change "public class MyForm : Form"
    '          to
    '             "public partial class MyForm : Form"
    '
    ' Duncan Smart, InfoBasis, 2007
    ' -------------------------------------------------------------------------

    Sub ExtractWinFormsDesignerFile()
        Dim item As ProjectItem = DTE.SelectedItems.Item(1).ProjectItem
        Dim fileName As String = item.FileNames(1)
        Dim dir As String = System.IO.Path.GetDirectoryName(fileName)
        Dim bareName As String = System.IO.Path.GetFileNameWithoutExtension(fileName)
        Dim newItemPath As String = dir & "\" & bareName & ".Designer.cs"

        Dim codeClass As CodeClass = findClass(item.FileCodeModel.CodeElements)
        Dim namespaceName As String = codeClass.Namespace.FullName

        On Error Resume Next ' Forgive me :-)
        Dim initComponentText As String = extractMember(codeClass.Members.Item("InitializeComponent"))
        Dim disposeText As String = extractMember(codeClass.Members.Item("Dispose"))
        Dim fieldDecls As String = extractWinFormsFields(codeClass)
        On Error GoTo 0

        System.IO.File.WriteAllText(newItemPath, "" _
          & "using System;" & vbCrLf _
          & "using System.Windows.Forms;" & vbCrLf _
          & "using System.Drawing;" & vbCrLf _
          & "using System.ComponentModel;" & vbCrLf _
          & "using System.Collections;" & vbCrLf _
          & "" & vbCrLf _
          & "namespace " & namespaceName & vbCrLf _
          & "{" & vbCrLf _
          & "   public partial class " & codeClass.Name & vbCrLf _
          & "   {" & vbCrLf _
          & "       #region Windows Form Designer generated code" & vbCrLf _
          & "       " & fieldDecls & vbCrLf _
          & "       " & initComponentText & vbCrLf _
          & "       #endregion" & vbCrLf & vbCrLf _
          & "       " & disposeText & vbCrLf _
          & "   }" & vbCrLf _
          & "}" & vbCrLf _
          )
        Dim newProjItem As ProjectItem = item.ProjectItems.AddFromFile(newItemPath)
        On Error Resume Next
        newProjItem.Open()
        DTE.ExecuteCommand("Edit.FormatDocument")
        On Error GoTo 0

        MsgBox("TODO: change your class from:" + vbCrLf + _
               "  ""public class " + codeClass.FullName + " : Form""" + vbCrLf + _
               "to:" + _
               "  ""public partial class " + codeClass.FullName + " : Form""")
    End Sub

    Function findClass(ByVal items As System.Collections.IEnumerable) As CodeClass
        For Each codeEl As CodeElement In items
            If codeEl.Kind = vsCMElement.vsCMElementClass Then
                Return codeEl
            ElseIf codeEl.Children.Count > 0 Then
                Dim cls As CodeClass = findClass(codeEl.Children)
                If cls IsNot Nothing Then
                    Return findClass(codeEl.Children)
                End If
            End If
        Next
        Return Nothing
    End Function

    Function extractWinFormsFields(ByVal codeClass As CodeClass) As String

        Dim fieldsCode As New System.Text.StringBuilder

        For Each member As CodeElement In codeClass.Members
            If member.Kind = vsCMElement.vsCMElementVariable Then
                Dim field As CodeVariable = member
                If field.Type.TypeKind <> vsCMTypeRef.vsCMTypeRefArray Then
                    Dim fieldType As CodeType = field.Type.CodeType
                    Dim isControl As Boolean = fieldType.Namespace.FullName.StartsWith("System.Windows.Forms") _
                       OrElse fieldType.IsDerivedFrom("System.Windows.Forms.Control") _
                       OrElse fieldType.IsDerivedFrom("System.ComponentModel.Container")
                    If isControl Then
                        fieldsCode.AppendLine(extractMember(field))
                    End If
                End If
            End If
        Next
        Return fieldsCode.ToString()
    End Function

    Function extractMember(ByVal memberElement As CodeElement) As String
        Dim memberStart As EditPoint = memberElement.GetStartPoint().CreateEditPoint()
        Dim memberText As String = String.Empty
        memberText += memberStart.GetText(memberElement.GetEndPoint())
        memberStart.Delete(memberElement.GetEndPoint())
        Return memberText
    End Function

and copy the methods into a Visual Studio Macro Module (use ALT+F11 to show the Macro editor).
To use:

• Select a Windows Form in the Solution Explorer
• Run the macro by showing the Macro Explorer (ALT+F8) and double-clicking the ‘ExtractWinFormsDesignerFile’ macro. (Obviously you can hook the macro up to a toolbar button if you like.)
• You will then be prompted to manually make the Form class partial (another bit I was too lazy to work out how to get the macro to do): i.e. change public class MyForm : Form to public partial class MyForm : Form

Answer 2

As you're probably aware, all the Express editions do not support third party extensions. Unfortunately I know of no stand alone tools that can do what you are asking.

I've experimented with splitting a Winform class into partials classes. As you discovered, it is not a trivial undertaking. This question has been asked before. Unlike Martin's attempt, I went the other direction. Instead of creating a designer file, I renamed the existing file to MyForm.Designer.cs and created a new MyForm.cs file. I then proceeded in a similar manner, moving the "code behind" instead of the designer code into my new class.

The one sticking point with either of these techniques is that future changes to the form still don't generate in the correct class file. This is because the project file still doesn't recognize the two files to be linked together. Your only option is to manually edit the project file in a text editor. Look for the following:

<Compile Include="MyForm.Designer.cs">
  <SubType>Form</SubType>
</Compile>

Replace the <SubType>...</SubType> with <DependentUpon>MyForm.cs</DependentUpon> so the end result looks like:

<Compile Include="MyForm.Designer.cs">
  <DependentUpon>MyForm.cs</DependentUpon>
</Compile>

Another solution I experimented with was simply creating an new form and dragging the controls from the old form to it. This actually worked to an extent. All the controls migrated along with all their properties. What didn't migrate was event handlers. These you would have to cut and paste from the old form, then go through each control and reselect the appropriate handler from the form designer. Depending on the complexity of the form this might be a reasonable alternative.

From my own personal experiences supporting multiple UIs the best approach is to keep form design simple and separate the business logic from the UI completely. The MVP Passive view works pretty well for this. By delegating as much of the responsibility to a presenter class it becomes trivial to implement the form in a different UI framework. WinForms, WebForms, WPF, etc, it makes little difference to the presenter class. All it sees in an interface exposing a list of properties it manipulates. Of course all the shoulda coulda wouldas in the world won't help when the problem you are facing is here and now.