A simple classic VB code counter made in C#

I made this simple application a while back when I needed to quote a project where I was tasked with converting a sizeable amount of classic Visual Basic code into the .NET Framework. This application I wrote allowed me to start my estimation so that I could tie a dollar amount to the work. There is a lot more I could have done to the project, but when you are doing contracted work on a per project basis, it’s important to be efficient. While I did some browsing through the projects that was equally important, this code counter did make a difference in my estimations thereby allowing for a properly researched quote. Now that I’m basically done with the project, I felt that I was relatively close to my estimation.

Here is the code for my VB code counter on my GitHub.

https://www.youtube.com/watch?v=V86mzyvdSA8

Here is the important code for my counter tool:

public IEnumerable<string> FilterFiles(string path, params string[] exts)
{
    return exts.Select(x => "*." + x)
               .SelectMany(x => Directory.EnumerateFiles(path, x));
}

private void button1_Click(object sender, EventArgs e)
{
    // Only parse VB6 frm, cls, and bas files
    var validExtensions = new[] { "frm", "cls", "bas" };

    txtResult.Text = "";
    txtLineCount.Text = "";

    if (folderSelector.ShowDialog() == DialogResult.OK)
    {
        // Only parse files that end in our desired extensions
        IEnumerable<string> foundFiles = FilterFiles(folderSelector.SelectedPath, validExtensions);

        // Loop through all of the files to count lines of code per project folder
        foreach (string filePath in foundFiles)
        {
            string currentFile = File.ReadAllText(filePath);

            // Clear out any lines that are entirely comments
            currentFile = Regex.Replace(currentFile, @"'(.*)", "", RegexOptions.Multiline);

            // Clear out any lines that are blank
            currentFile = Regex.Replace(currentFile, @"^\s+$[\r\n]*", "", RegexOptions.Multiline);

            // Remove any blocks of empty spaces so that there are only single spaces
            while (currentFile.Contains("  "))
            {
                currentFile = currentFile.Replace("  ", " ");
            }

            // Confirm there are no empty lines
            while (currentFile.Contains("\n\n"))
            {
                currentFile = currentFile.Replace("\n\n", "\n");
            }

            // Append the parsed code file text
            txtResult.Text += currentFile;
        }

        // Count the project's entire lines of code
        txtLineCount.Text = (txtResult.Lines.Count() - 1).ToString();
    }
}

The application allows you to select a directory where a given VB project’s files are located. It searches the directory for frm, cls, and bas files, which were the key project files for classic Visual Basic. It pulls all of the text in for each file, removing lines that are comments and also clearing out all empty lines. Improvements to the code might be in somehow excluding the form control property sections (though still an important thing you would need to decipher when converting classic VB, especially if you don’t have the VB6 IDE) and counting up instances of special functions or logic that were unique to classic VB.

I’ll likely be writing an article about some of the classic VB functions I had converted to C# to be part of my general code library that I was able to utilize in some of my contract work mentioned before. If I ever get around to converting some of my personal VB code I have from the 90’s, they will be helpful for sure in that. I’m not a fan of using the “using Microsoft.VisualBasic” option, because I don’t trust that Visual Basic will be around for the long term.