Perfunction stacktrace or gtfo

Remove unused local variables in VB.NET

I work with a very large ASP.NET solution that has its roots in an old VB6 Access database application so not only is the code a mess, but it is written in VB. I've been searching for a good clean-up addon for VS for a while now but all of the good functionality is always reserved for C#. Last night I finally got tired of seeing all the unused variable warnings and realized that I could pull off a quick and dirty solution.

Locating the variables

Obviously the first thing I had to figure out was how to track down all these unused variables. This is where the quick/dirty part comes in that greatly reduced the amount of work on my plate. I have an automated build script that I had used in the past and this script dumps the build log to a text file. I realized that I could take that text file and parse it for warnings and the whole thing would just be simple file I/O.

The build.bat file:

@echo off
C:\WINDOWS\Microsoft.NET\Framework64\v3.5\msbuild.exe c:\code\cleanup\build1.msbuild > c:\code\cleanup\result.txt

1. The first part of the path is the location of msbuild on your system.
2. The second part of the path is the location of a file that tells msbuild what to do exactly.
3. The final part of the path is where we want to write the output log to.

My msbuild file:

<Project DefaultTargets="Main" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup>
 <WebsiteName>mysite</WebsiteName>
 <PrecompiledAssembliesPath>c:\temp\mysite\</PrecompiledAssembliesPath>
  <BuildDirectory>C:\inetpub\wwwroot\mysite</BuildDirectory>
  </PropertyGroup>
  <Target Name="Main">
 <AspNetCompiler
         VirtualPath="/$(WebsiteName)"
     PhysicalPath="$(BuildDirectory)"
     TargetPath="$(PrecompiledAssembliesPath)"
     Force="true"
     Debug="true"
     Updateable="true"
 />
  </Target>
</Project>

Removing the variables

The code for the application to actually remove the variables from the source files is pretty basic and should be straightforward enough. I chose to replace the unused variables with an empty line but you could just as easily comment out the lines by making a couple small tweaks to my code.

using System;
using System.IO;

namespace cleanup
{
    class Program
    {
        static void Main(string[] args)
        {
            string openfile = "";
            string[] openlines = null;

            using (StreamReader r = File.OpenText("result.txt"))
            {
                string line = "";

                while (true) {
                    line = r.ReadLine();

                    if (line == null)
                        break;

                    // look for unused variables
                    if (line.Contains("BC42024"))
                    {
                        int pos = line.IndexOf('(');
                        string file = line.Substring(0, pos);
                        pos++;
                        string linenum = line.Substring(pos, line.IndexOf(')') - pos);

                        if (openfile != file)
                        {
                            if (openlines != null)
                            {
                                SaveFile(openfile, openlines);
                            }

                            openlines = OpenFile(file);
                            openfile = file;
                        }

                        int index = int.Parse(linenum) - 1;
                        openlines[index] = "~";
                    }
                }
            }
        }

        static void SaveFile(string file, string[] lines)
        {
            File.WriteAllText(file, string.Empty);
            using (StreamWriter w = new StreamWriter(File.Open(file, FileMode.Open, FileAccess.Write)))
            {
                for (int i = 0; i < lines.Length; i++)
                {
                    if (lines[i] != "~")
                    {
                        w.WriteLine(lines[i]);
                    }
                    else
                    {
                        w.WriteLine();
                    }
                }
            }
        }

        static string[] OpenFile(string file)
        {
            using (StreamReader r = File.OpenText(file))
            {
                string lines = r.ReadToEnd();
                return lines.Split(new string[] { "\r\n", "\n" }, StringSplitOptions.None);
            }
        }
    }
}

And that is all there is to it! It's sloppy but I'm happy with the results I got for the amount of effort put in. I may be extending this code at some point to address some of our other warnings that are very common. I would LOVE to track down all the unreferenced functions, classes, and members in our code.