A group blog from members of the VB team
I was once temporarily taken off the VB team to get an unrelated project back on track, just a mere handful of weeks before it was due to ship. I won’t go into the gory details; suffice it to say that we had reason to believe that the product would have to ship without delay, and that any major failure in the deliverable could create some seriously undesirable problems for both us and our customers.
In the interest of expediting the development of the product, a external team knowledgeable in the underlying issue had been hired to do the actual work. When our testers were analyzing the results of their labors, they found wildly unacceptable performance in what had been produced. So, besides shepherding the work on the forty or so functional issues remaining in the product, I had to address the performance issues as well. This was bread and butter to me at the time; I’d recently come off a stint as the VB Performance Lead, and had a good grasp of the tools of the trade. So, I set about to investigate the cause of the problems.
Without getting too deeply into the details of the project, the upshot was that each file on the operating system having a certain extension would be opened and analyzed so see if it contained any of a particular set of keywords. The extension was not an uncommon one; thus, a *lot* of files would have to be opened from the file system and examined. This, of course, was where I suspected the problems would be, but what I discovered in the code left me absolutely astonished.
The natural thing to do for this sort of program was to recursively iterate the directory, find the relevant files, open them , search for the data, and then add the file to a list if the data was found. What they did instead was this: once the relevant file was found, they had created a thread whose sole purpose was to launch an application that they had on hand which generated a log report on the file. The thread would listen for that application to terminate, and then open the log report and scan *it* for yes/no results. Yes, that’s right – imagine dozens of threads being opened at one, each of them launching a copy of this app, with four disk hits (find file, find & launch app, open file, create log file) for each. Yeah, that might just cause a little slowness on a Pentium II Win98 machine!
After I calmed down (about an hour later), I asked them why they were doing it this way. “Well, we don’t actually know the criteria that would cause a ‘yes’ answer for a given file, since we don’t actually have the source code for the app that does know it,” they replied.
Well, good grief!
Five minutes’ search on MSDN gave me the format of the file being scanned, and in another thirty minutes I’d ripped out all of the threading, shell code, and log-parsing code, replacing it with ten lines of code designed to open the file and scan for the appropriate data. The ultimate savings? A total scan of a typical machine shrunk from two hours to ten minutes. All in all, a most satisfactory day’s work.
My point in bringing up that story is to note the incredible damage that can be done by misusing shell calls. Shell calls are expensive and, worse, they create results that may not easily understandable by the calling program (beyond a simple succeed/fail). If you think that you need to “shell out” to another program, remember this simple word : don’t.
Of course, it’s very tempting to shell out when an existing application already exists. For example, if you want to get a listing of all subdirectories in a parent directory, and you want if formatted in a manner similar to that to which you are accustomed, then it’s very tempting to make a call to dir /a:d > out.txt and to parse the results. The alternative, after all, is to overcome inertia and learn how to navigate the file system from code, right? Sounds great, but the best advice here is don’t do that. That’s what snippets are for, after all.
Still here? OK, shell commands aren’t actually evil – they’re just misunderstood. They can be powerful tools if used right. And the best usage of a shell command is a “fire and forget” situation, where you really want the user to be interacting with a bona fide version of the application. In most cases, if the executable is producing output AND you care about it, it’s best to in-line the functionality if at all possible.
In Visual Basic, you can “shell out” to an application in two easy ways, both of which either leverage or wrap the System.Diagnostics.Process class. These are detailed below.
This is rather easy to do, and there’s actually a snippet that helps you when you forget the actual code. To find it, put your cursor in a method, launch the snippet picker by typing “?” and pressing “Tab,” then choose “Windows System – Logging, Process, Registry, Services,” “Windows – Processes,” and “Start an Application” in that order. (That’s for VS2008 – it’s slightly different in VS2005.) You’ll get the following line:
And you can replace “notepad.exe” with the name of whatever executable that you want to run. There are several overloads of this function, but you need to be careful with them, since a few of them allow you to specify a username and password to do a “Run As,” and that’s information that you definitely don’t want to hardcode or persist in human-readable form. There’s a simple overload that allows you to pass command-line arguments in a string, which can be very useful for certain apps, and you’d use it like this (for example):
Dim proc As Process = _
The first argument to Process.Start can also be a document which will be launched with the application that’s registered to it, and this link shows an example of that usage.
As I imply in the second example above, Process.Start returns an instance of the Process class which points to the process of the application you just created, and you can call all sorts of neat methods using that return value, including one that kills the process. I mention this because you might otherwise be tempted to kill the process you just created using “Stop an Application” snippet:
Dim processList() As Process
processList = Process.GetProcessesByName("notepad")
For Each proc As Process In processList
If MsgBox("Terminate " & proc.ProcessName & "?", _
MsgBoxStyle.YesNo, "Terminate?") = MsgBoxResult.Yes Then
This snippet iterates over all processes having the name “notepad” and asks you for each one if you want to terminate it. But since you already have a valid Process object, you don’t need to use this snippet – just call Kill() on the return value of Start() directly.
This involves using the Microsoft.VisualBasic.Interaction.Shell command, which gives you a few “frequently used” options for controlling applications that you launch. Here’s a contrived example :
Dim retval As Integer
retval = Shell("C:\windows\system32\notepad.exe", AppWinStyle.NormalFocus, True, 20000)
I’ve specified the path to the application in the first second. The second argument allows me to control whether the new application is minimized, maximized, etc – in the above example, I’ve chosen for notepad to come up “normal.” The third argument specifies if I want to wait for the new application to complete and, given that I’ve chosen “True” for that above, the fourth and final argument specifies how many milliseconds I want to wait for that to happen, with -1 indicating an infinite wait. (I’ve coded for 20 seconds above.)
If the application shuts down before the time limit is reached, a zero will be returned from the Shell command. If, on the other hand, the time limit is reached and the application is still running, the program will stop blocking and return the process ID of the application – note that this will not affect the instance of the application that I launched, though. You can then use the process ID to take whatever action you need to do – for example:
If retval <> 0 Then
Dim proc As Process = Process.GetProcessById(retval)
' (Call interesting methods on proc here.)
creates a Process object based on the process ID returned from the above code, and you can act on it in the same way that you used the return value from Start() in the first example.
If you can, I’d try to avoid shelling out to other applications. It’s much more performant to implement the functionality in-line or, better yet, leverage an assembly that’s common to all of the applications in question. Still, you will occasionally come across situations where you want to launch the “one true” application programmatically. The methods I’ve listed above are easiest and will get you going quickly.
‘Til next time…
Once in a while, it's still just necessary. For instance, when automating MODI, sometimes it just refuses to release its files (despite using all the "correct" automation commands). The only way to reliably release it was to wrap it in a process and call into it. Horrible, I know, but that's what it came to.
Loading an application for each and every filename match and parsing its output is poor programming. Overloading the number of threads and not reusing threads are key performance issues.
This example reminds me of the windows explorer which does not keyword search inside of files that it does not have a registered extension for. This makes it lots of fun to search mixed language source code or application produced output files for keywords. This cost me a number of hours when working on a mixed language batching application (C++, perl, python, php, etc.) since windows explorer did not search inside of files it did not know the registered application of (e.g., perl).
Regarding shell based appliations, I've developed many applications that use a number of shell based command line tools in production systems. Generally, you a) have to know what you want to do, b) know what tool/command line application to use, c) know how to optimize the set of tools used (e.g., use them properly), d) test and e) produce decent diagnostic message log files.
Many of the solutions I've seen by vb developers that do not know vb script or shell utility applications are generally of low quality since the developer spends most of the time re-inventing the wheel for functionality that is well proven (e.g., string matching in findstring/grep) and already debugged.
I had the task to combine many thousands of single page tiff image files into many multi-page tiff files based on file name. The previous developer tried to use .NET's tiff functions to do this and failed miserably with memory and performance problems (the .NET BCL needs better image file handling functionality). I used tiffcp from libtiff with a simple batch script to combine the files.
for %a in (*.tif) do tiffcp "%~niIa"