Shell from excel vba

The VBA Shell function runs a command in the operating system shell.

The shell refers to the interface, typically where you type commands, to run programs. This is called a command line interface or CLI.

In Windows, the shell is commonly known as the Command Prompt. To access it, click on the Windows button and type cmd (Windows 10). Windows finds the program for you, so click on it to start it.

In other versions of Windows the process for starting the Command Prompt is similar. Just search for cmd.

Once you are in the command prompt you can type commands like dir to list the folder contents:

Or you can start programs, like Notepad:

Commands like dir, copy, del etc are known as internal commands because they are built into the shell — they are part of the code that forms the shell, not separate programs.

Programs like Excel, Notepad etc are known as external commands because they are programs in their own right, but can be called or executed from the shell.

The method for calling internal and external programs using the VBA Shell function is different.

You can also use the Shell to run scripts like batch files, PowerShell scripts, PERL, Python etc.

VBA Shell Syntax

The syntax for calling Shell is

Shell (Program,WindowStyle)

Program can be the name of an internal or external command or a script. It can contain any arguments or switches required by the program, as well as the drive and path to the program itself

WindowStyle determines how the window of the called program behaves. WindowStyle is optional but if it is omitted, the program starts minimized with focus. You can specify the WindowStyle using a constant or the actual numeric value, as shown here:

Focus is where keyboard input is sent to. If focus is on Excel and you type, the characters appear in Excel. If focus is on Notepad, the characters appear in Notepad.

When you use Shell it returns a Variant (Double) data type that contains the process ID of the program you called. You can use this PID to terminate the program later.

If your attempt to run a program with Shell was unsuccessful, it returns 0.

Examples of Using Shell

External Commands

After we declare a Variant variable called PID, we call Shell to start Notepad like this:

PID = Shell("notepad", vbNormalFocus)

Using vbNormalFocus starts Notepad with its most recent size and position, and changes focus to it.

To close the same instance of Notepad:

PID = Shell ("TaskKill /F /PID " & PID, vbHide)

If you wanted to open Notepad with a specific file then supply the filename, and path if needed:

PID = Shell("notepad c:MyFilesTextFile.txt", vbNormalFocus)

If you are using a shell that doesn’t understand spaces in file names or paths, then you need to wrap the file name/path in two sets of double quotes, inside the double quotes that delimit the Program string:

I’m using Windows 10 and don’t have that issue though.

But if you had wanted to open a file

c:My FilesText File.txt

and your shell required that this be wrapped in «», then you’d write the string like this

PID = Shell("notepad ""c:My FilesText File.txt""", vbNormalFocus)

The same goes for any path you need to specify for the actual command/script name. In this example I’m calling a batch file (Text Parser.bat) to process the text file (Text File.txt):

PID = Shell("""c:My ScriptsText Parser.bat"" ""c:My FilesText File.txt""", vbNormalFocus)

All of those «»» look a bit strange but let me explain. The first and last « mark the beginning and end of the string that specifies the program being called, including any parameters, switches and file(s) it will use:

"""c:My ScriptsText Parser.bat"" ""c:My FilesText File.txt"""

If we remove those « we are left with the Program string itself, which is composed of two separate strings, one for the pathbatch file (red), and the other for the pathfile the batch file will use (blue).

""c:My ScriptsText Parser.bat"" ""c:My FilesText File.txt""

When this is passed to the Shell one of the double « is removed so what is actually seen in the Shell is

"c:My ScriptsText Parser.bat" "c:My FilesText File.txt"

Which looks like two normally delimited strings.

Internal Commands

To call an internal command like dir, you must start an instance of the actual shell, which in Windows is cmd.exe. You then say that you want to use the dir command. The /k switch specifies that cmd should not terminate after dir has finished. You can terminate cmd later.

PID = Shell("cmd /k dir", vbNormalNoFocus)

Asynchronous Execution

Calls to the Shell are executed asynchronously, VBA will make the call and then continue without waiting for whatever program you called to finish whatever job you asked it to do.

This probably isn’t an issue if you are just trying to open a text file in Notepad. But if you are say, trying to list files in a directory and then you want to import the resultant CSV into Excel, you need to make sure that the CSV file is complete before you do that import.

One way to do this would be to make your VBA sleep or pause.

Error handling

Make sure that you use error handling when making Shell calls. Just in case the program or file you want isn’t in the location you expect, or is missing altogether.

Download Sample Workbook

The sample workbook I’ve prepared contains several examples of VBA Shell calls including the use of error handling and terminating programs you have started.

This tutorial will demonstrate how to use the VBA Shell function.

We can use the VBA Shell function to call a separate, executable program from inside a VBA program. For example, if we need to open Notepad from Excel, we can use the VBA Shell function to do so.  If the Shell call succeeds, it returns the Windows TaskID value of the program it called. If the Shell call fails, it returns zero.

Shell has two input parameters: a required pathname for the program to call, and an optional windowstyle value controlling the style of the window where the program will run. The pathname value can include the program path / directory and arguments.

Call Shell

This code can form part of a macro to run Notepad by using the VBA Call command to call the Shell function.

Call Shell("notepad", vbNormalFocus)

For example:

Shell Wait

We can use the VBA Wait command to delay calling the Shell command for a specific period of time.

    Application.Wait (Now + TimeValue("00:00:05"))
    Call Shell("notepad", vbNormalFocus)

Therefore 5 second will pass before the Shell command is called.

Returning an Error from the Shell Function

If we have an error in our code when calling the Shell function, and error will be returned and our code will go into debug mode.

For example, in this macro, we have spelt “note pad” incorrectly.

  Call Shell("note pad", vbNormalFocus)

The result of running this macro will be:

Open an Existing File With Shell

If we have a specific file that we wish to open with the Shell command, we can include the file name in our code.

Call Shell("Notepad.exe C:demoshell_test.txt", vbNormalFocus)

If we spell the file name incorrectly, the file will not be found and a message box will appear asking us if we wish to create a new file.

Parameters used by the Shell function

The Shell function has 2 parameters – the name of the program to call, and the windows style that the program is going to use.  We have been using the vbNormalFocus in the examples above which means that when the program (in this case Notepad) is opened, it has the focus and it opens in the default position and size on the PC.

The Shell offers five other options:

vbHide                                 Hides the window and sets focus on that window

vbMinimizedFocus         Displays the window as an icon with focus

vbMaximizedFocus        Opens the program in a maximized window with focus

vbNormalNoFocus          Restores the window at its most recent position and size

vbMinimizedNoFocus   Displays the window as an icon and the currently active window stays active

Returning a Process ID from the Shell Command

When we run the Shell Command, it returns a Process or Task ID.  We can store the Process ID in a variable, and use that Process ID in running another command – for example, the TaskKill command to close the Notepad file.

Sub TestPID
   Dim ProcessID as integer
   processID = Shell("notepad", vbNormalFocus)
   Call Shell("Taskkill /F /PID " + CStr(processID))
   MsgBox ("Notepad ProcessID = " + CStr(processID))
End Sub

In the first line, NotePad is opened and the Process ID is assigned a value by Windows.  We store this value in the ProcessID variable.  We then use TaskKill to force Notepad to close the instance of NotePad that we have just opened.   The /F switch forces Notepad to end, and the /PID switch tells TaskKill to look for the Notepad Process ID value. The CStr function converts ProcessID to the string format that Shell, and MsgBox on the next line, both need.

Calling Other Programs With  Shell

Shell will open any other Windows program. For example, this code calls Excel, and opens Excel file ‘example_workbook.xlsx’:

Call Shell("Excel ""C:DEMOexample_workbook.xlsx""", vbNormalFocus)

This shows the opened file:

ShellExecute and ShellExecuteEx vs the Shell Command

The Windows programming space offers ShellExecute and ShellExecuteEx functions that call external programs from software code. Compared to the VBA Shell function, these Windows functions offer more flexibility, but VBA does not support them and therefore this article does not cover them.

An introduction to the shell

A shell is an interface in the Windows that runs commands and helps you use programs. Hence it is also called the “Command Line Interface” (CLI). In Windows, we also call it the command prompt.

You can also open the command prompt by typing “cmd” in the Run dialog after clicking on the Windows button on your keyboard.

In Windows 10, we can directly type it intp the search box next to the windows button.

Some sample commands

Below are some commands and output that may interest you. If you’re already quite familiar with the shell commands that you have at your disposal, feel free to skip to the next section to learn how to call the shell from VBA.

Internal commands

The above commands are already a part of the shell, so they are called internal commands.

Dir

This command lists the contents of a folder.

Ipconfig

This command provides network information.

Systeminfo

Provides all information related to the hardware of the system.

Ping

This command helps to check a the server is reachable.

Tasklist

This command lists out all the tasks in the system that are currently running.

External Commands

There are several programs in the Windows system which may or may not come with the operating system. For example, Notepad, MS Word, MS Excel and any other software that we explicitly install after setting up the operating system.

All these can be invoked using external commands.

notepad

mspaint

Changing the directory and opening a specific document from that directory

Run other scripts using Shell

Below are some of the other scripting languages that can be run using the Windows shell or command prompt.

1. Powershell
2. Batch files with the extension “.bat”
3. PERL
4. Python
5. Javascript

And so on…

The VBA Shell function

VBA offers a built-in function named “Shell” to use the Windows shell and run or execute any program with ease.

Syntax

Pid=Shell ( <Program name>, [ <Window Style> ] )

Where

1. Program name is the name of any internal or external command or a script.
2. Window Style describes the behavior of the subsequent display window. It is an optional argument and can be any one of values in the table below (which are constants).
3. Pid is the variable that holds the Process id of the program that is initiated by the shell function. This is a value of double data type that is returned by the Shell function. It can be used later to terminate the program.

Note: If the execution of the function is not successful i.e. if not program is initiated, a 0 value is returned and it gets stored in the Pid variable.

Wherever we send keyboard input, the focus remains there and whatever keys are pressed or sent, gets typed in the window with focus. For example, if Notepad is in focus, whatever is typed using the keyboard or sendkeys, gets typed in that Notepad window.

Examples

1. Opening a Notepad window using normal focus and closes it using its program ID.

Sub shell_demo()

'declare a variable to hold the process id that is returned
Dim Pr_id As Double

'Use shell function to open a notepad using normal focus
Pr_id = Shell("notepad", vbNormalFocus)

'Kill or close the notepad using the same process id that was returned.
Pr_id = Shell("TaskKill /F /PID " & Pr_id, vbHide)

End Sub

2. The code below opens a Notepad file which already contains some data. So the file path should also be supplied in the parameters. The Notepad application opens with the focus maximized, as specified.

Sub shell_demo2()

'declare a variable to hold the process id that is returned
Dim Pr_id As Double

'Use shell function to open a notepad using maximized focus
Pr_id = Shell("notepad C:UsersLAKSHMI RAMAKRISHNANOneDriveDocumentssai invite.txt", vbMaximizedFocus)

'Kill or close the notepad using the same process id that was returned.
Pr_id = Shell("TaskKill /F /PID " & Pr_id, vbHide)

End Sub

In some cases, Windows does not understand spaces between the file names or file paths. In this event, we need to use double double quotes for the <Program name> parameter.

Pr_id = Shell("notepad ""C:UsersLAKSHMI RAMAKRISHNANOneDriveDocumentssai invite.txt""", vbMaximizedFocus)

This is typically not an issue with Windows 10.

3. Calling programs with different extensions

Sub shell_demo3()

'declare the required variables to hold the process ids that are returned
Dim Pr_id_not, Pr_id_word, Pr_id_acc, Pr_id1, Pr_id2 As Double

'Open a simple notepad using Shell function
Pr_id_not = Shell("Notepad", vbMaximizedFocus)

'Open a simple notepad using Shell function
Pr_id_word = Shell("winword", vbMaximizedFocus)

'Open a simple notepad using Shell function
Pr_id_acc = Shell("MsAccess", vbMaximizedFocus)

'Use shell function to open a folder using maximized focus
Pr_id1 = Shell("Explorer.exe C:UsersLAKSHMI RAMAKRISHNANOneDriveDocumentsTraining", vbMaximizedFocus)

'Use shell function to open a non- Excel file using normal focus
Pr_id2 = Shell("Explorer.exe C:UsersLAKSHMI RAMAKRISHNANOneDriveDocuments5.png", vbNormalFocus)

Debug.Print Pr_id_not
Debug.Print Pr_id_word
Debug.Print Pr_id_acc
Debug.Print Pr_id1
Debug.Print Pr_id2

End Sub	

4. Calling a batch file to run a text file using the Shell function.

Sub shell_demo3()

'declare a variable to hold the process id that is returned
Dim Pr_id_new As Double

'Use shell function to open a notepad using normal focus
Pr_id_new = Shell("""C:Lakshmiprocessme.bat"" ""C:Lakshmitextfile_run.bat""", vbMaximizedFocus)

'Kill or close the notepad using the same process id that was returned.
Pr_id_new = Shell("TaskKill /F /PID " & Pr_id_new, vbHide)

End Sub

Yes, that’s a lot of quotes in the Shell function’s <Program Name> parameter. Let me explain.

• One double quote each at the two ends “, mark the beginning and end of the string that refers to the name or path of the program to be run.

(““”C:Lakshmiprocessme.bat”” “”C:Lakshmitextfile_run.bat””“)

• The rest of the parameter (with one double quote in front and one at the end) consists of 2 strings. One is the path of the batch file to be run and the other is the path of the text file to be run. As you might know, a double quote needs to be used twice consecutively within a string to have one double quote there (to escape a quote).

(““”C:Lakshmiprocessme.bat“” “”C:Lakshmitextfile_run.bat“”“)

The final string that is passed in the shell is:

“C:Lakshmiprocessme.bat” “C:Lakshmitextfile_run.bat”

Asynchronous Execution

VBA code keeps executing without waiting to see if execution of the command is complete. So if we need to check for the completion of a command’s run before the next command executes, we need to use the VBA sleep or pause statements.

For example, to type something into a Notepad document, we can just open and type using the Shell function. But if we need to list out the files in a directory, we definitely need to verify that the run is complete, then export the list to Excel or CSV afterwards. In this case, we can use a sleep or wait statement to ensure the command is executed fully.

Here is a sample program that explains how to wait.

Sub shell_demo_4()

'Declaration of objects and variables
Dim sh_obj As Object
Dim counter As Integer

'Assign all values
Set ie_pr_id = Nothing
counter = 0
Set sh_obj = CreateObject("shell.application")
counter = sh_obj.Windows.Count
ie = Shell("C:Program FilesInternet Exploreriexplore.exe -nosessionmerging , -noframemerging", vbNormalFocus)

'wait till the window opens
Do Until sh_obj.Windows.Count = counter + 1
Loop

'set the new process id
Set ie_pr_id = sh_obj.Windows(sh_obj.Windows.Count - 1)

'Print the new process id
Debug.Print ie_pr_id

End Sub

Output of the program in the immediate window:

Internet Explorer

Conclusion

The built-in VBA Shell function to execute commands just like how you’d execute commands from the Windows command prompt. You can use it to open any kind of window during the execution of VBA macros, such as automation, web scraping, or file comparison.