Excel vba workbook open method

VBA Workbook Open

Excel VBA Workbook Open

The most common operations in day to day life is to open an excel Workbooks when you are working with Excel. You cannot work in Excel without opening the Excel Workbooks or Excel file. So in this article, we are going to cover how we can open an Excel Workbooks with the help of VBA.

Methods to Open Exel Workbooks in VBA

There are two methods to open excel Workbooks in VBA and we are going to cover both methods in this article.

You can download this VBA Workbook Open Excel Template here – VBA Workbook Open Excel Template

Method #1 – Excel VBA Workbooks.open Method

The first method in the VBA is to use the inbuilt function Workbooks.open. There are 15 optional arguments in the “Workbooks.open” function and to cover all the 15 arguments will take a lot of time. So we will just try to understand some basics of Workbooks.open and see how we can use this function in VBA to open the Workbooks.

So the first step in this method is you should know the file name of the Excel Workbooks. Below is the statement to open the Workbooks.”Workbooks.open “File_Name”

Or

Workbooks.Open Filename: =”File_Name”

The “File_Name” is the name of the Workbooks that you want to open. But you need to be careful here because you need to provide the full path where the file is saved and name of the file with the extension of the files (.XLS, .XLSX, .xlsm, etc). We can take the example of below macro to understand this function.

Example

Suppose you want to open an excel file with the name “Test File” which is saved in the D Drive of the computer. Create a Macro in an Excel macro-enabled workbook. Follow the below steps to use Excel VBA Workbooks.open method.

Step 1: Click on File.

VBA Workbook Open Example 1-1

Step 2: Click on Options.

Click on Options

Step 3: Click on Customize Ribbon.

Customize Ribbon

Step 4: Make sure the Developer field is marked as below and click ok.

VBA Workbook Open Example 1-4

Step 5: Once you have the developer tab, click on Visual basic as shown in the below screenshot.

VBA Workbook Open Example 1-5

After you click on the Visual Basics, you need to start coding for your macro.

Step 6: Enter the below code in the VBA Module.

Code:

Sub Open_workbook()

End Sub

VBA Workbook Open Example 1-6

This code provides the name for your workbook.

Step 7: Enter the code which can open the workbook saved in the D drive of the computer.

Code:

Sub Open_workbook()

Workbooks.Open Filename:="D:Test File.xlsx"

End Sub

VBA Workbook Open Example 1-7

Step 8: Run the code by pressing the F5 key or by clicking on Play Button. After running the macro, you will find the excel file is automatically opened. As you can see in the above code, the macro will open the Excel file with the name “Test File.xlsx” which is saved in the D drive of the computer. The path mentioned above is quite simple because there are no folders and subfolders to get the Workbooks.

This becomes challenging because many people don’t remember the path and if the Path of the file where it is saved changes a bit, the macro will not work. The macro will not work even if the Name of the file changes by a single letter. So if the Path/Name of the file changes you need to change the VBA code of the Macro. This makes the Job tedious and it is not error-free as well. So to make sure your macro runs perfectly without giving you an error, we will use the second method which is easy to handle and will not give you an error even when you don’t remember the pathname or even when the name of the file changes.

Method #2 – Get Open Filename

As you know the challenges we face in the First method of the change in path and the File name, this method avoids both of the challenges. This method gives the option to browse in your computer to the location where your file is saved and opens that particular Workbooks which you want to open.

This method actually works in two parts.

The first part of this method is Application.GetOpenFileName. This Part allows you to browse through your computer and select the path where your file is saved. The first part does not open the file which you want to open.

The second part is to open the file for which you still need to be dependent on the First Method (VBA Workbooks.open Method). There are 5 arguments in the Application.GetOpenFileName but will only look at the basics like we did it in the first method. Now let us try to understand this method with the help of an example.

Example

Suppose you want to open the “Test File” saved in the D drive of the computer then you just need to follow the below steps.

Step 1: Follow step 1 mentioned in the first example for opening the Visual Basic Editor or Open Visual Basic Editor from Developer Tab.

VBA Workbooks Open Example 1-1

Step 2: Enter the below code which provides the name for your macro.

Code:

Sub Open_workbook_example2()

End Sub

VBA Workbooks Open Example 1-2

Step 3: Enter the below code. This statement declares the Filename as Variable because here we are not specifying any path or file name because it can change from time to time.

Code:

Sub Open_workbook_example2()

Dim Myfile_Name As Variant

End Sub

Declares Filename as Variable Example 1-3

Step 4: Enter the below code. This statement opens the below dialog box and you can browse the folders to go to the path where the file is saved. Also, it will show the Excel file while browsing because we have put a filter for the Excel files.

Code:

Sub Open_workbook_example2()

Dim Myfile_Name As Variant
Myfile_Name = Application.GetOpenFilename(FileFilter:="Excel Files(*.xl*),*.xl*)")

End Sub

VBA Workbooks Open Example 1-4

Step 5: Enter the below code. This statement is If Then statement which is used when the file .Name is not equal to false then open the selected Excel file.

Code:

Sub Open_workbook_example2()

Dim Myfile_Name As Variant
Myfile_Name = Application.GetOpenFilename(FileFilter:="Excel Files(*.xl*),*.xl*)")

If Myfile_Name <> False Then
  Workbooks.Open Filename:=Myfile_Name

End Sub

If Then statement Example 1-5

Step 6: Enter the below code. This statement closes the If then condition in the Macro.

Code:

Sub Open_workbook_example2()

Dim Myfile_Name As Variant
Myfile_Name = Application.GetOpenFilename(FileFilter:="Excel Files(*.xl*),*.xl*)")

If Myfile_Name <> False Then
  Workbooks.Open Filename:=Myfile_Name
End If

End Sub

VBA Workbooks Open Example 1-6

Step 7: Now run the code by pressing the F5 key or by clicking on the Play Button. You will see the dialog box to browse the file will open. Browse to the desktop where your file is saved. Now you will be able to see the file in the D Drive. Select the file and click open.

VBA Workbooks Open Example 1-7

Now as we just saw in our example, we don’t need to worry about the file name and the path name where the file is saved. We can easily navigate to the folder where our file is saved and select the file which we want to open. So we can easily conclude that this method is much more efficient compared to the first method.

Things to Remember

  • Make sure the pathname & the file name is correct while using the first method. The macro will not work when there is a change by letter or space in path or File Name.
  • Make sure the filters mentioned in the code in the 2nd method is correct. There are many formats of Excel which may not be visible because of a filter.
  • Make sure the declaration and the code used in the VBA are right to avoid errors.

Recommended Articles

This is a guide to VBA Workbook Open. Here we discuss two different methods to open workbook using Excel VBA code along with practical examples and downloadable excel template. You may also look at the following articles to learn more –

  1. VBA Workbook
  2. VBA Get Cell Value
  3. VBA FileDialog
  4. VBA Save Workbook

This Excel VBA tutorial explains how to use Workbooks.Open Method to open another workbook.

Workbooks.Open Method is useful when you try to open another Workbook using VBA. For example, you can open a workbook > format the spreadsheet > close the workbook automatically. There are a lot of rarely used arguments for Workbooks.Open Method. As most of them are self explanatory, I will demonstrate some common uses of the Method.

Syntax of Workbooks.Open Method

expression .Open(FileName, UpdateLinks, ReadOnly, Format, Password, WriteResPassword, IgnoreReadOnlyRecommended, Origin, Delimiter, Editable, Notify, Converter, AddToMru, Local, CorruptLoad)
Name Required/Optional Data Type Description
FileName Optional Variant String. The file name of the workbook to be opened.
UpdateLinks Optional Variant Specifies the way external references (links) in the file, such as the reference to a range in the Budget.xls workbook in the following formula =SUM([Budget.xls]Annual!C10:C25), are updated. If this argument is omitted, the user is prompted to specify how links will be updated. For more information about the values used by this parameter, see the Remarks section. If Microsoft Excel is opening a file in the WKS, WK1, or WK3 format and the UpdateLinks argument is 0, no charts are created; otherwise Microsoft Excel generates charts from the graphs attached to the file.
ReadOnly Optional Variant True to open the workbook in read-only mode.
Format Optional Variant If Microsoft Excel opens a text file, this argument specifies the delimiter character. If this argument is omitted, the current delimiter is used. For more information about the values used by this parameter, see the Remarks section.
Password Optional Variant A string that contains the password required to open a protected workbook. If this argument is omitted and the workbook requires a password, the user is prompted for the password.
WriteResPassword Optional Variant A string that contains the password required to write to a write-reserved workbook. If this argument is omitted and the workbook requires a password, the user will be prompted for the password.
IgnoreReadOnlyRecommended Optional Variant True to have Microsoft Excel not display the read-only recommended message (if the workbook was saved with the Read-Only Recommended option).
Origin Optional Variant If the file is a text file, this argument indicates where it originated, so that code pages and Carriage Return/Line Feed (CR/LF) can be mapped correctly. Can be one of the following XlPlatform constants: xlMacintosh, xlWindows, or xlMSDOS. If this argument is omitted, the current operating system is used.
Delimiter Optional Variant If the file is a text file and the Format argument is 6, this argument is a string that specifies the character to be used as the delimiter. For example, use Chr(9) for tabs, use “,” for commas, use “;” for semicolons, or use a custom character. Only the first character of the string is used.
Editable Optional Variant If the file is a Microsoft Excel 4.0 add-in, this argument is True to open the add-in so that it is a visible window. If this argument is False or omitted, the add-in is opened as hidden, and it cannot be unhidden. This option does not apply to add-ins created in Microsoft Excel 5.0 or later. If the file is an Excel template, True to open the specified template for editing. False to open a new workbook based on the specified template. The default value is False.
Notify Optional Variant If the file cannot be opened in read/write mode, this argument is True to add the file to the file notification list. Microsoft Excel will open the file as read-only, poll the file notification list, and then notify the user when the file becomes available. If this argument is False or omitted, no notification is requested, and any attempts to open an unavailable file will fail.
Converter Optional Variant The index of the first file converter to try when opening the file. The specified file converter is tried first; if this converter does not recognize the file, all other converters are tried. The converter index consists of the row numbers of the converters returned by the FileConverters property.
AddToMru Optional Variant True to add this workbook to the list of recently used files. The default value is False.
Local Optional Variant True saves files against the language of Microsoft Excel (including control panel settings). False (default) saves files against the language of Visual Basic for Applications (VBA) (which is typically United States English unless the VBA project where Workbooks.Open is run from is an old internationalized XL5/95 VBA project).
CorruptLoad Optional XlCorruptLoad Can be one of the following constants: xlNormalLoad, xlRepairFile and xlExtractData. The default behavior if no value is specified is xlNormalLoad and does not attempt recovery when initiated through the OM.

Example 1 – Open a workbook

The below code opens workbook 1.xls and set the workbook as “wb” so that you can use wb to access other workbook Methods.

Public Sub openWB()
    Set wb = Workbooks.Open("C:UsersWYMANDesktopexcelfolder1.xls")
End Sub

Example 2 – Open a workbook with password

There are two kinds of password protection – password to open the workbook, and password to modify the workbook.

Excel VBA Workbooks.Open Method 01

In either case, if a workbook is password protected, opening the file will pop up a password box.

You can add the password argument to open the file with password automatically. If you open a non-password protected workbook but you add the password argument, you can still open the workbook.

Lets say you have a workbook 3.xlsx which is non-password protected, using the below code will still be able to open the workbook.

Public Sub openWBpw()
    Set wb = Workbooks.Open(Filename:="C:UsersWYMANDesktopexcelfolder3.xlsx", Password:="yourpassword")
End Sub

Example 3 – Open a workbook without alert

There are many kinds of alerts that may pop up when you open a workbook, preventing you from running the subsequent procedures. Turn off all alerts ensures you to run all the procedures successfully.

Public Sub openWB2()
    With Application
        .DisplayAlerts = False
        .ScreenUpdating = False
        .EnableEvents = False
        .AskToUpdateLinks = False
    End With
    Set wb = Workbooks.Open(Filename:="C:UsersWYMANDesktopexcelfolder3.xlsx", Password:="yourpassword")
    With Application
        .DisplayAlerts = True
        .ScreenUpdating = True
        .EnableEvents = True
        .AskToUpdateLinks = True
    End With
End Sub

Other examples

Add password to all Excel workbook in folder

Excel VBA refresh closed workbook

Use Excel Workbooks Open Method to check if workbook open

Outbound References

https://msdn.microsoft.com/en-us/library/office/ff194819.aspx

title keywords f1_keywords ms.prod api_name ms.assetid ms.date ms.localizationpriority

Workbooks.Open method (Excel)

vbaxl10.chm203082

vbaxl10.chm203082

excel

Excel.Workbooks.Open

1d1c3fca-ae1a-0a91-65a2-6f3f0fb308a0

08/14/2019

medium

Workbooks.Open method (Excel)

Opens a workbook.

[!includeAdd-ins note]

Syntax

expression.Open (FileName, UpdateLinks, ReadOnly, Format, Password, WriteResPassword, IgnoreReadOnlyRecommended, Origin, Delimiter, Editable, Notify, Converter, AddToMru, Local, CorruptLoad)

expression A variable that represents a Workbooks object.

Parameters

Name Required/Optional Data type Description
FileName Optional Variant String. The file name of the workbook to be opened.
UpdateLinks Optional Variant Specifies the way external references (links) in the file, such as the reference to a range in the Budget.xls workbook in the following formula =SUM([Budget.xls]Annual!C10:C25), are updated. If this argument is omitted, the user is prompted to specify how links will be updated. For more information about the values used by this parameter, see the Remarks section.

If Microsoft Excel is opening a file in the WKS, WK1, or WK3 format and the UpdateLinks argument is 0, no charts are created; otherwise, Microsoft Excel generates charts from the graphs attached to the file.

ReadOnly Optional Variant True to open the workbook in read-only mode.
Format Optional Variant If Microsoft Excel opens a text file, this argument specifies the delimiter character. If this argument is omitted, the current delimiter is used. For more information about the values used by this parameter, see the Remarks section.
Password Optional Variant A string that contains the password required to open a protected workbook. If this argument is omitted and the workbook requires a password, the user is prompted for the password.
WriteResPassword Optional Variant A string that contains the password required to write to a write-reserved workbook. If this argument is omitted and the workbook requires a password, the user will be prompted for the password.
IgnoreReadOnlyRecommended Optional Variant True to have Microsoft Excel not display the read-only recommended message (if the workbook was saved with the Read-Only Recommended option).
Origin Optional Variant If the file is a text file, this argument indicates where it originated, so that code pages and Carriage Return/Line Feed (CR/LF) can be mapped correctly. Can be one of the following XlPlatform constants: xlMacintosh, xlWindows, or xlMSDOS. If this argument is omitted, the current operating system is used.
Delimiter Optional Variant If the file is a text file and the Format argument is 6, this argument is a string that specifies the character to be used as the delimiter. For example, use Chr(9) for tabs, use «,» for commas, use «;» for semicolons, or use a custom character. Only the first character of the string is used.
Editable Optional Variant If the file is a Microsoft Excel 4.0 add-in, this argument is True to open the add-in so that it is a visible window. If this argument is False or omitted, the add-in is opened as hidden, and it cannot be unhidden. This option does not apply to add-ins created in Microsoft Excel 5.0 or later.

If the file is an Excel template, True to open the specified template for editing. False to open a new workbook based on the specified template. The default value is False.

Notify Optional Variant If the file cannot be opened in read/write mode, this argument is True to add the file to the file notification list. Microsoft Excel will open the file as read-only, poll the file notification list, and then notify the user when the file becomes available. If this argument is False or omitted, no notification is requested, and any attempts to open an unavailable file will fail.
Converter Optional Variant The index of the first file converter to try when opening the file. The specified file converter is tried first; if this converter does not recognize the file, all other converters are tried. The converter index consists of the row numbers of the converters returned by the FileConverters property.
AddToMru Optional Variant True to add this workbook to the list of recently used files. The default value is False.
Local Optional Variant True saves files against the language of Microsoft Excel (including control panel settings). False (default) saves files against the language of Visual Basic for Applications (VBA) (which is typically United States English unless the VBA project where Workbooks.Open is run from is an old internationalized XL5/95 VBA project).
CorruptLoad Optional XlCorruptLoad Can be one of the following constants: xlNormalLoad, xlRepairFile and xlExtractData. The default behavior if no value is specified is xlNormalLoad, and does not attempt recovery when initiated through the OM.

Return value

A Workbook object that represents the opened workbook.

Remarks

By default, macros are enabled when opening files programmatically. Use the AutomationSecurity property to set the macro security mode used when opening files programmatically.

You can specify one of the following values in the UpdateLinks parameter to determine whether external references (links) are updated when the workbook is opened.

Value Description
0 External references (links) will not be updated when the workbook is opened.
3 External references (links) will be updated when the workbook is opened.

You can specify one of the following values in the Format parameter to determine the delimiter character for the file.

Value Delimiter
1 Tabs
2 Commas
3 Spaces
4 Semicolons
5 Nothing
6 Custom character (see the Delimiter argument)

Example

The following code example opens the workbook Analysis.xls and then runs its Auto_Open macro.

Workbooks.Open "ANALYSIS.XLS" 
ActiveWorkbook.RunAutoMacros xlAutoOpen

The following code example imports a sheet from another workbook onto a new sheet in the current workbook. Sheet1 in the current workbook must contain the path name of the workbook to import in cell D3, the file name in cell D4, and the worksheet name in cell D5. The imported worksheet is inserted after Sheet1 in the current workbook.

Sub ImportWorksheet() 
    ' This macro will import a file into this workbook 
    Sheets("Sheet1").Select 
    PathName = Range("D3").Value 
    Filename = Range("D4").Value 
    TabName = Range("D5").Value 
    ControlFile = ActiveWorkbook.Name 
    Workbooks.Open Filename:=PathName & Filename 
    ActiveSheet.Name = TabName 
    Sheets(TabName).Copy After:=Workbooks(ControlFile).Sheets(1) 
    Windows(Filename).Activate 
    ActiveWorkbook.Close SaveChanges:=False 
    Windows(ControlFile).Activate 
End Sub

[!includeSupport and feedback]

Excel VBA Workbooks.Open Method

VBA Workbooks.Open method one may use to open an Excel workbook from another workbook.

As far as VBA is concerned, we hope you have seen the magic and wonders VBA can do at your workplace. An important thing about VBA is that it does not limit its work to the same workbook. Rather, we can access the workbook which is already not opened. One such technique can open another workbook from a different workbook. This special article will show you how to open an Excel workbook using the Workbooks.Open method in detail.

Table of contents
  • Excel VBA Workbooks.Open Method
    • Open a Workbook from Current Workbook
      • Syntax
    • Examples
      • Example #1
      • Example #2
    • Things to Remember
    • Recommended Articles

VBA-Workbook-Open

Open a Workbook from Current Workbook

Just imagine a situation where you are working with two already opened workbooks. The workbook you are working on is named “Book 1,” and another open but not active workbook is named “Book 2.”

Since we are working on “Book 1” to activate another workbook, “Book 2,” we need to specify the workbook name with its file extension using the WORKBOOKS object.

Excel VBA Workbook.Open Example 0

Inside this, we need to enter the workbook name and its extension.

Excel VBA Workbook.Open Example 0.1

Then, we must insist on what we need to do with this workbook. Since we need to activate this workbook, select the “Activate” method.

Excel VBA Workbook.Open Example 0.2

So, this code will activate the workbook “Book 2.xlsx” if it is open.

What if the workbook “Book 2.xlsx” is not open? How do you open it or activate it?

It is where our Workbooks.Open method comes into the picture.

Syntax

Excel VBA workbooks.open method

  • File Name: The first argument in this method is to specify the workbook name we are trying to open. Workbook name alone cannot do the job here because Excel doesn’t know in which folder your workbook is saved. So, we need to supply a full folder path followed by an exact file name with its saved extension.
  • Update Links: When we try to open the workbook, it may contain some external links from other workbooks. We can supply yes or no here.
  • Read Mode: How do you want to open the workbook? If you want only to read the file, then TRUE is the argument.
  • Password: If the targeted or opening workbook contains any password, then in this argument, we need to specify the password used while protecting the workbook.

These four arguments are good enough in this method. Do not break your head to understand every argument because the need for those remaining arguments may never arise.

Examples

You can download this VBA Workbook Open Excel Template here – VBA Workbook Open Excel Template

Example #1

Imagine opening the file named “File 1.xlsx” on your computer. The file gets saved in so many folders and subfolders. To open it through VBA codingVBA code refers to a set of instructions written by the user in the Visual Basic Applications programming language on a Visual Basic Editor (VBE) to perform a specific task.read more, follow the below steps.

Step 1: Start the subprocedure.

Code:

Sub Workbook_Example1()

End Sub

Excel VBA Workbook.Open Example 1.1

Step 2: Inside the VBA subprocedureSUB in VBA is a procedure which contains all the code which automatically gives the statement of end sub and the middle portion is used for coding. Sub statement can be both public and private and the name of the subprocedure is mandatory in VBA.read more, start Workbooks.Open method.

Excel VBA Workbook.Open Example 1.2

Step 3: The first thing we need to mention is to file a name with its folder path and file extension.

For this, first, we need to open the exact file location.

Excel VBA Workbook.Open Example 1.3

Now, what you have to do is you need to copy the file path by using the folder path.

Workbook.Open Example 1.4

Step 4: Copy the link and paste it into the coding.

Code:

Sub Workbook_Example1()

Workbooks.Open Filename:="D:Excel FilesVBAFile1.xlsx"

End SubM

Workbook.Open Example 1.5

So, now we have copied and pasted the file path where it is stored. This mentioned file path may contain many files. So after this, enter the backward slash first and then enter the file name with a file extension.

Code:

Sub Workbook_Example1()

Workbooks.Open Filename:="D:Excel FilesVBAFile1.xlsx"

End Sub

Workbook.Open Example 1.6

Now, ignore all the other arguments.

Step 5: Run the code. It will open up the workbook named “File 1.xlsx.”

So, our code has just opened the mentioned workbook in the folder path.

Example #2

The best and most efficient way of using VBA coding involves using variables while coding. Because, as part of a large VBA project, we may need to open other files between the coding, using variables will play an important role in such a situation.

It can open the same file by using variables as well. For this, declare two variables as a String data type.

Code:

Sub Workbook_Example2()

    Dim File_Location As String
    Dim File_Name As String

End Sub

Example 2.1

For the File_Location variable, assign the folder path where the file is stored.

Code:

Sub Workbook_Example2()

    Dim File_Location As String
    Dim File_Name As String

    File_Location = "D:Excel FilesVBA"

End Sub

Example 2.2

Note: One extra thing we need to do is after pasting the link, we need to put a backward slash.

Now for the File_Name variable, we need to mention the file name with its excel extensionExcel extensions represent the file format. It helps the user to save different types of excel files in various formats. For instance, .xlsx is used for simple data, and XLSM is used to store the VBA code.read more.

Code:

Sub Workbook_Example2()

    Dim File_Location As String
    Dim File_Name As String

    File_Location = "D:Excel FilesVBA"
    File_Name = "File1.xlsx"

End Sub

Example 2.3

Now, these two variables combine to create a full folder path.

Now, open the Workbooks.Open method again in Excel VBA.

Example 2.4

Supply two variable names with an ampersand (&) sign for the first argument.

Code:

Sub Workbook_Example2()

    Dim File_Location As String
    Dim File_Name As String

    File_Location = "D:Excel FilesVBA"
    File_Name = "File1.xlsx"

    Workbooks.Open File_Location & File_Name

End Sub

Example 2.6

So now, we can change the folder path and file name whenever we want to for just variables. So wherever we use variables, it will reflect the changes instantly.

Things to Remember

  • Never enter the file location manually because 99% of the time, we make mistakes while typing the location, so copy from the location only.
  • We must manually enter a backward slash () to separate the location and file.
  • If a password protects the file, use the PASSWORD argument under Workbooks.Open method.

Recommended Articles

This article is a guide to the VBA WorkBook Open Method. Here, we discuss how to open an Excel workbook from another workbook using the VBA Workbooks.Open method. You can learn more from the following VBA articles: –

  • VBA DoEvents
  • VBA ThisWorkbook
  • VBA Worksheets Object
  • VBA Worksheet Function

Excel VBA Tutorial about how to open workbooks and filesOne of the most basic and common operations in Excel is opening a workbook. Regardless of their level (beginner or advanced), virtually every single Excel user has to constantly open workbooks. In fact:

You’ve probably opened a countless amount of Excel workbooks yourself.

If you’re working with VBA, it’s only a matter of time before you need to start creating macros to open Excel workbooks. This Excel tutorial focuses on this basic and common Excel operation:

How to open a workbook using VBA.

I cover this topic by explaining 2 of the most basic macros you can use to open an Excel workbook.

This Excel VBA Open Workbook Tutorial is accompanied by an Excel workbook containing the data and basic structure macros I use below. You can get immediate free access to this example workbook by clicking the button below.

Get immediate free access to the Excel VBA Open Workbook Tutorial workbook example

Both of these macros rely on 1 or both of the following methods:

  • The Workbooks.Open method.
  • The Application.GetOpenFilename method.

Therefore, the second part of this tutorial analyzes both of these methods and goes through each of their parameters. The purpose of this section is to help you get some basic awareness of some of the things you can do when using these methods in your macros.

In addition to help you open workbooks using VBA, the Application.GetOpenFilename method allows you to specify the paths and names of particular Excel workbooks. You’ll likely encounter situations where knowing this (how to allow the user to specify a path and filename) can come in handy.

So let’s take a look at the exact topics that I explain in this blog post:

And let’s start by taking a look at what is, perhaps, the simplest case of opening an Excel workbook using VBA:

How To Open A Workbook Using VBA: The Basic Case

Within Visual Basic for Applications, the method that opens an Excel workbook is the Workbooks.Open method.

The Workbooks.Open method has 15 optional arguments. Each of these 15 optional arguments allows you determine a different aspect of how the Open method opens an Excel workbook.

Since taking a look at 15 arguments at once can get a little overwhelming, let’s start by taking a look at the most basic case: opening an Excel workbook whose name you know. You specify which workbook you want to open by using the Filename argument.

More specifically, the basic VBA statement syntax to open a particular workbook is:

Workbooks.Open Filename:="File_Name"

Or

Workbooks.Open "File_Name"

Where “File_Name” is the file name of the workbook that you want to open with VBA. As shown in the example below, when specifying the workbook’s file name, you must provide the full path and name of the file. I explain how to make this easier below.

The first sample statement above uses named arguments (Filename:=”File_Name”). For the reasons that I explain here, this is my preferred syntax. However, you can also use the second syntax (simply “File_Name”.

Let’s take a look at the Workbooks.Open method in practice:

The following macro (named Open_Workbook_Basic), opens the Excel workbook whose name is “Example – VBA open workbook”. This workbook is saved in the D drive.

vba code open workbook

As mentioned above, notice that when specifying the filename, you must provide the whole file path, name and extension.

open excel workbook path vba

The sample file path above is relatively simple. In particular, there’s no need to go through several sub-folders in order to get to the sample workbook. However…

Probably not many people are able to remember the exact file paths, names and extensions for the files in their laptop. And even then, few would want to type the whole thing every time a new Excel workbook is to be opened. In other words: Having the user type the filename (without browsing) is both:

  • Tedious; and
  • Prone to errors/mistakes.

Since you want to ensure that your macro receives the correct file name (including the whole path and its extension), you’ll usually use slightly more complicated macros than the sample Open_Workbook_Basic Sub procedure displayed above.

Let’s take a look at the simplest way to do this: replicating the way Excel usually works when you browse the computer drive in order to find the particular file you want to open.

How To Open A Workbook Using VBA: Get The File Path With The GetOpenFilename Method

You’re probably quite familiar with the following dialog box:

excel open file dialog

This is the Open dialog box. Excel displays this dialog whenever you browse for purposes of finding and selecting a file to open.

Usually, whenever Excel displays the Open dialog box, you simply need to:

  1. Navigate to the folder containing the Excel workbook you want to open.
  2. Select the file to be opened and click on the Open button in the lower-right corner of the Open dialog.

The following screenshot shows how the Open dialog looks like if you were to open the workbook named “Example – VBA open workbook” that the Open_Workbook_Basic macro above opens.

excel open dialog example 1

You’ll probably agree with me that using this method of choosing the particular Excel workbook that you want to open is much easier than remembering the full file path.

Fortunately, you can replicate this way of operating with VBA. More precisely, you do this by using the Application.GetOpenFilename method.

Excel’s Application.GetOpenFilename method does 2 things:

  1. Displays a customizable Open dialog box; and
  2. Returns the full path/name/extension of the file chosen by the user.

The Application.GetOpenFilename method doesn’t open the file chosen by the user. You still need to rely on the Workbooks.Open method explained above for purposes of actually opening the chosen file. GetOpenFilename simply gives you a mechanism/tool to ask the user for the name(s) of the file(s) that the procedure works with.

The fact that GetOpenFilename doesn’t actually open the file makes this a very versatile method. The reason is that this allows you to use this precise same method in cases in which you need to get the path/name/extension of an Excel workbook for purposes other than opening it.

Therefore, in order to open an Excel workbook through the Open dialog box while using VBA, you need to use both of the following methods:

  • Item #1: The Application.GetOpenFilename method returns the name of the workbook to be opened.
  • Item #2: The Workbooks.Open method actually opens the workbook whose path/name/extension is provided by the Application.GetOpenFilename method.

The Application.GetOpenFilename method has 5 variables. However, just as we did with the Workbooks.Open method, let’s take a look at a very basic piece of VBA code that allows you to:

  1. Browse the available drives for purposes of finding and selecting the Excel workbook you want to open; and
  2. Actually open the selected file.

In such a case, the syntax of the basic VBA statements that you need is as follows:

Dim my_FileName As Variant
my_FileName = Application.GetOpenFilename(FileFilter:="Excel Files,*.xl*;*.xm*")
If my_FileName <> False Then
    Workbooks.Open FileName:=my_FileName
End If

The following screenshot shows the full VBA code of a sample macro called “Open_Workbook_Dialog”.

vba open workbook getopenfilename 1

This Excel VBA Open Workbook Tutorial is accompanied by an Excel workbook containing the data and basic structure macros I use (including the Open_Workbook_Dialog macro). You can get immediate free access to this example workbook by clicking the button below.

Get immediate free access to the Excel VBA Open Workbook Tutorial workbook example

Let’s take a look at each of the statements that makes part of the Open_Workbook_Dialog macro to understand how it proceeds:

Statement #1: Dim my_FileName As Variant

This particular statement is a variable declaration statement. The purpose of declaring a variable in this macro is to store the file name chosen by the user.

This variable declaration statement can be divided in the following 3 items:

vba variable open workbook

Item #1: Dim Statement

As I explain in this macro tutorial, the Dim statement is the most common way to declare a VBA variable.

Item #2: Variable Name

In this particular case, the name of the variable being declared is “my_FileName”.

Item #3: Data Type

my_FileName is declared as being of the Variant data type. This variable is declared as a Variant because the Application.GetOpenFilename method can return different types of data.

Statement #2: my_FileName = Application.GetOpenFilename(FileFilter:=”Excel Files,*.xl*;*.xm*”)

This VBA statement is characterized by the following 2 aspects:

  1. Makes an assignment to the VBA variable my_FileName; and
  2. Uses the GetOpenFilename method that I introduce above.

For purposes of carrying out a closer examination of this statement, I divide it in the following 3 items:

getopenfilename method vba code

Let’s take a look at each of them separately:

Item #1: my_FileName =

The first part of the statement follows the general rule in which a value or expression is assigned to a VBA variable, by using the equal sign (=).

In these cases, the equal sign (=) is an assignment operator. Therefore, it doesn’t represent an equality.

In the case of the Open_Workbook_Dialog macro, the equal sign (=) is assigning:

  • The result of the expression that appears to its right (which I explain in the next section below); to
  • The VBA variable that is on the left side (my_FileName).

Let’s take a look at the items on the right side of the equal sign:

Item #2: Application.GetOpenFilename

This item is the reference to the Application.GetOpenFilename method. As explained above, this particular method:

  1. Displays a customizable Open dialog box; and
  2. Returns the file name chosen by the user (without actually opening it).
    1. If the user selects multiple files (you can determine this by using the MultiSelect argument I explain below, GetOpenFilename returns an array of the file names chosen by the user. This is the case even if the user only selects 1 file.
    2. If the user cancels the Open dialog box (for example, presses the Cancel button), GetOpenFilename returns False.

This leads us to the last item of the statement:

Item #3: (FileFilter:=”Excel Files,*.xl*;*.xm*”)

FileFilter is one of the different parameters of the GetOpenFilename method. As implied by its name, this argument allows you to specify criteria for file-filtering.

It’s an optional argument. However, I include it for purposes of specifying file filtering criteria.

If you omit the FileFilter argument when using the GetOpenFilename method, it defaults to all files (*.*).

In the sample VBA code that appears above (and throughout the rest of this Excel tutorial), I use named arguments. However, that’s not mandatory. If you don’t want to use named arguments, you can use the following statement syntax:

my_FileName = Application.GetOpenFilename("Excel Files,*.xl*;*.xm*")

Let’s take a look at the characteristics of the FileFilter argument:

Characteristic #1: What Does The FileFilter Argument Do.

As explained above, FileFilter determines what are the criteria used for filtering files when the Open dialog box is displayed.

In more practical terms, the FileFilter argument determines what appears in the Files of type drop-down list box on the lower-right corner of the Open dialog box. As shown in the image below, in the case of the Open_Workbook_Dialog macro there’s only one item in the Files of type drop-down list box (Excel Files):

vba filefilter argument example

Characteristic #2: Syntax Of The FileFilter Argument.

The appropriate syntax of the FileFilter Argument is determined by the following rules:

  • Rule #1: Each individual filter is specified by pairing 2 strings as follows:
    • Part #1: A descriptive string. You can omit this part, although I wouldn’t recommend it. In the case of the sample Open_Workbook_Dialog macro, this is “Excel Files”. Notice (in the image above) how this is the text that actually appears in the Files of the type drop-down list of the Open dialog box.
    • Part #2: A comma (,) separating part #1 above and part #2 below.
    • Part #3: The MS-DOS wildcard file-type filter specification. In other words, this part determines how the files are filtered, depending on their type. In the Open_Workbook_Dialog macro, this part is *.xl*;*.xm*.
  • Rule #2: The structure of the file types that you use in the filter specification (part #3 above) is generally (i) an asterisk (*), (ii) a dot (.), and (iii) an indication of the file extension using an asterisk (as wildcard, if necessary) and (if necessary) letters. At the most basic level, the way to specify all files is asterisk dot asterisk (*.*). For example, the Open_Workbook_Dialog macro uses the following 2 file type specifications: *.xl* and *.xm*. Notice how, in both cases: (i) there is an asterisk (*) followed by (ii) a dot (.) and (iii) the first 2 letters of the file extension (xl and xm) followed by an asterisk (*) used as wildcard. Due to the wildcard asterisk, these 2 specifications cover any file extension beginning with .xl (such as .xlsx, .xlsm, .xlsb, .xltx, .xltm, .xls, .xlt, .xlam, .xla and .xlw) or .xm (.xml).
  • Rule #3: As shown by the fact that the Open_Workbook_Dialog macro uses 2 file type specifications, you can include 1 or several file types in a particular filter. When including more than 1 file type in a particular filter, you must separate them with a semi-colon (;). Notice how this is the case in the macro under analysis. More precisely, .xl* and *.xm* are separated by a semi-colon (;) (*.xl*;*.xm*).
  • Rule #4: In addition to the possibility of using multiple file-types, you can create more than 1 actual filter. In such a case, you separate the filters using commas (,). The sample Open_Workbook_Dialog macro above only has one filter. This is determined by the string pairing “Excel Files,*.xl*;*.xm*”. You can, however, separate this single filter into 2 filters (displaying “xl Files” for *.xl* and “xm Files” for *.xm*) as follows:
    vba open workbook filtersThe way to get these 2 filters is to replace the single string pairing “Excel Files,*.xl*;*.xm*” with the following: “xl Files,*.xl*,xm Files,*.xm*”.

Summary Of Statement #2

The final effect of the whole statement explained above is as follows:

  • #1: The Open dialog box is displayed to allow the user to select a file.
  • #2: If the user selects a file, its file name is assigned to the variable called my_FileName.

This leads us to the last statement of the Open_Workbook_Dialog macro, which uses the value of the my_FileName variable.

Statement #3: If my_FileName <> False Then Workbooks.Open FileName:=my_FileName
End If

This is an If… Then… Else statement. These type of statements proceed as follows:

  • Step #1: Carry out a test to determine whether a particular condition is met.
  • Step #2: If the condition is met, a certain group of statements are executed. If the condition isn’t met, the statements aren’t executed.

In the case of the Open_Workbook_Dialog macro, the If… Then… Else statement proceeds as follows:

Step #1: Determine Whether The User Has Select a Workbook

Statement #2 (explained above) assigns the file selected by the user to the variable my_FileName. If the user fails to select a file (by, for example, cancelling the operation), my_FileName returns False.

The test carried out by the If… Then… Else statement under analysis checks whether the my_FileName variable has been assigned a particular file path/name/extension by testing the condition “my_FileName <> False”.

In other words, the condition “my_FileName <> False” is met only when the user has chosen a particular workbook in the Open dialog box displayed by the Application.GetOpenFilename method.

If the condition is met, the If…Then… Else statement proceeds to:

Step #2: Open Excel Workbook

The second part of the If… Then… Else statement we’re looking at is “Workbooks.Open FileName:=my_FileName”.

You already know what this statement does. It’s the Workbooks.Open method described above.

The purpose of the Workbooks.Open method is to open an Excel workbook. In this case, the workbook that is opened is that whose file name has been assigned to the variable my_FileName.

In other words, if the user selects a file when the Open dialog box is displayed, the If… Then… Else statement opens that file.

The Workbooks.Open Method: A Closer Look

As explained at the beginning of this Excel tutorial, Workbooks.Open is the method that you’ll generally use to open Excel workbooks using VBA.

We have already seen the basics of the Workbooks.Open method and its most basic use above. However, in that particular case, I mentioned that this method has 15 different parameters. So far, we’ve only checked one: FileName.

I assume that, if you’re reading this, you want to learn about some more advanced cases of opening Excel workbooks using VBA. In order to do this, let’s take a closer look at the Workbooks.Open method and its different parameters.

The Workbooks.Open Method: Full Syntax

The full syntax of the Workbooks.Open method in Visual Basic for Applications is as follows:

expression.Open(FileName, UpdateLinks, ReadOnly, Format, Password, WriteResPassword, IgnoreReadOnlyRecommended, Origin, Delimiter,Editable, Notify, Converter, AddToMru, Local, CorruptLoad)

In this case, “expression” stands for a variable representing a Workbook object. In most cases, however, you can simply rely on the syntax used in the sample Open_Workbook_Basic and Open_Workbook_Dialog macros.

In other words, you’ll generally replace “expression” with the Workbooks object itself:

Workbooks.Open

All of the parameters of the Workbooks.Open method, which appear within parentheses above, are optional. Let’s take a look at them!

Parameters Of The Workbooks.Open Method

The following table introduces the 15 optional parameters of the Workbooks.Open method.

Position Name Description
1 FileName Name of workbook to be opened.
2 UpdateLinks Way in which external references/links in the file are updated.
3 ReadOnly Determines whether workbook opens in read-only mode.
4 Format Applies when opening a text file. 

Determines the delimiter character.

5 Password Password required to open protected workbook.
6 WriteResPassword Password required to write in a write-reserved workbook.
7 IgnoreReadOnlyRecommended Applies when a workbook is saved with Read-Only Recommended option enabled. 

Determines whether the read-only recommended message is displayed.

8 Origin Applies when opening a text file. 

Indicates where the file originated.

9 Delimiter Applied when opening a text file and the Format parameter above (No. 4) is a custom character. 

Specifies what is the custom character to be used as delimiter.

10 Editable Applies to: (i) old Excel add-ins (created in Excel 4.0) and (ii) templates. 

When applied to an Excel 4.0 add-in, determines whether add-in is opened as hidden or visible.

If applied to a template, determines whether template is opened for editing, or if a new workbook (based on the template) is created.

11 Notify Applies when a file can’t be opened in read/write mode. 

Determines whether file is added to file notification list (or no notification is requested).

12 Converter Determines what file converter to try upon opening the file.
13 AddToMru Determines whether file is added to list of recent files.
14 Local Determines whether file is saved against language of Excel (usually local) or VBA (usually US-English).
15 CorruptLoad Determines the processing of the file when opened

I provide a more detailed description of the parameters in the sections below. The only exception is the FileName argument, which I explain above.

However, let’s take a closer look at the other parameters:

Argument #2: UpdateLinks

The UpdateLinks argument is the one you can use if you’re interested in determining whether the external references or links within the opened Excel workbook are or aren’t updated.

In other words, UpdateLinks determines how those external references or links are updated. The UpdateLinks parameter can take the following 2 values:

  • 0: In this case, external references/links aren’t updated when the Excel workbook is opened.
  • 3: When using this value, the external references/links are updated when the workbook opens.

The following screenshot shows the VBA code of the sample Open_Workbook_Basic macro where the UpdateLinks parameter has been added and is set to 3.

vba open workbook updatelinks

Since the UpdateLinks parameter isn’t required, you can omit it. In that case, Excel generally defaults to asking the user how links are updated.

Argument #3: ReadOnly

If you set the ReadOnly argument to True, the Excel workbook is opened in read-only mode.

When this argument is added to the sample Open_Workbook_Basic macro, the VBA code looks as follows:

vba open workbook read only

In this case, the Excel workbook is opened as read-only, meaning that any changes made aren’t saved.

When I execute the Open_Workbook_Basic macro, Excel warns me about the opened workbook being read-only. Check out, for example, the screenshot below:

excel open workbook read only

Arguments #4 and#9: Format and Delimiter

The Format argument of the Workbooks.Open method is only relevant when opening text files.

Format determines what the delimiter character is. The delimiter is what allows you to split a single piece of content into different cells. By choosing the value of the Format argument, you specify what delimiter is used.

The following are the possible Format values and the delimiter each of them represents:

  • 1: Tabs.
  • 2: Commas.
  • 3: Spaces.
  • 4: Semicolons.
  • 5: Nothing.
  • 6: A custom character, which you then specify by using the Delimiter argument. The Delimiter argument must be a string. Also, the Delimiter is a single character. If you enter a longer string, the first character of the string is used as delimiter.

If you omit the Format argument when opening a text file, Excel uses whatever delimiter is currently being used.

Since the Open_Workbook_Basic macro makes reference to the Excel workbook named “Example – VBA open workbook.xlxs”, the Format argument isn’t really useful. However, for illustration purposes, the following screenshot shows the VBA code behind this macro using this argument for purposes of setting spaces as the delimiter.

vba open workbook format 2

The following image shows how the VBA code looks like if the Format argument is set to 6 (custom delimiter) and the Delimiter argument is defined as ampersand (&).

vba open workbook delimiter

Arguments #5 and #6: Password and WriteResPassword

You’d generally use the Password and WriteResPassword arguments when you’re working with Excel workbooks that are protected or write-reserved.

Both the Password and WriteResPassword are strings representing a particular password. Their main difference is on what type of protection the Excel workbook being opened has. More precisely:

  • Password: Is the password required to open a protected Excel workbook.
  • WriteResPassword: Is the password required to write in a write-reserved workbook.

If you’re opening an Excel workbook that anyway requires a password and you omit the relevant argument (Password or WriteResPassword, as the case may be), Excel asks the user for the appropriate password.

Let’s assume, for illustrative purposes, that the “Example – VBA open workbook.xlsx” opened by the Open_Workbook_Basic macro is protected by the password “VBA open workbook”. The following screenshot displays the VBA code of the macro with the appropriate Password argument:

vba open workbook password

Argument #7: IgnoreReadOnlyRecommended

Set a particular Excel workbook to be read-only recommended by activating the Read-Only Recommended option when saving the relevant workbook.

The consequence of this is that, when the read-only recommended workbook is opened, Excel displays a message recommending that the workbook is opened as read-only.

excel read only recommended

If the IgnoreReadOnlyRecommended argument is set to True, Excel doesn’t display this particular message when opening the workbook.

The following screenshot displays the VBA code of the Open_Workbook_Basic macro with the IgnoreReadOnlyRecommended argument.

vba open workbook readonlyrecommended

Note that, in this particular case, I’ve deleted the previously added ReadOnly argument. The reason for this is that, if both the ReadOnly and IgnoreReadOnlyRecommended arguments are set to True, Excel simply opens the workbook in read-only mode as required by the ReadOnly argument.

Argument #8: Origin

The Origin argument is only applicable when opening text files. You can use Origin to specify the platform (Microsoft Windows, Mac or MS-DOS) in which the file originated. Indicating the origin of the file allows Excel to map (i) code pages and (ii) Carriage Return/Line Feed properly.

The Origin argument generally takes one of the XlPlatform values, as follows:

  • 1: xlMacintosh.
  • 2: xlMSDOS.
  • 3: xlWindows.

If you omit the Origin argument, Excel uses the operating system of the computer that is opening the file.

The file named “Example – VBA open workbook.xlsx” that is opened by the Open_Workbook_Basic macro isn’t a text file. Therefore, I include the Origin argument in the screenshot below (specifying the origin as Microsoft Windows) only for illustrative purposes:

vba open workbook origin

Argument #9 (Delimiter) is explained above.

Argument #10: Editable

The Editable argument applies to the following types of files:

  • Microsoft Excel 4.0 add-ins. You’ll probably not work too much with these because it’s quite an old format. To give you an idea: Excel 4.0 was released in 1992. Editable doesn’t apply to any add-ins that have been created in later versions of Excel.
  • Excel templates.

The Editable parameter of the Workbooks.Open method works differently depending on which of the above files you’re working with. The general rules are as follows:

When working with Microsoft Excel 4.0 add-ins:

  • Setting Editable to True, opens the relevant add-in in a visible window.
  • Setting Editable to False (which is the default value), opens the add-in as hidden. Additionally, the add-in can’t be unhidden.

When working with a template:

  • Setting Editable to True opens the template for editing.
  • Setting Editable to False (the default value), opens a new Excel workbook that is based on the relevant template.

The workbook opened by the sample Open_Workbook_Basic property is neither a Microsoft Excel 4.0 add-on nor a template. Therefore, the Editable parameter isn’t applicable.

However, for illustrative purposes, the following is an example of how the VBA code to open “Example – VBA open workbook.xlsx” workbooks looks like with the Editable parameter set to True:

vba open workbook editable

Argument #11: Notify

The Notify argument of the Workbooks.Open method applies when you’re opening a file that can’t be opened in read/write mode. If you set the Notify argument to True, Visual Basic for Applications proceeds as follows whenever it encounters such a file:

  • Step #1: The file is opened as read-only and added to the file notification list. The file notification list stores files that could only be opened in read-only mode.
  • Step #2: The status of the file notification list is checked to confirm when the file is available. In more precise terms, the file notification list is polled.
  • Step #3: When the file becomes available, the user is notified about this.

If you omit the Notify argument, or set it to False:

  • The file isn’t added to the file notification list. In other words, no notification that the file is available is requested or received.
  • The attempt to open a file that isn’t available simply fails.

The following screenshot shows the VBA code of the sample Open_Workbook_Basic macro with the Notify argument set to True:

vba open workbook notify

Argument #12: Converter

The Converter argument is applicable whenever you want/need to use file converters. More precisely, you use the Converter parameter to specify the file converter that should be used first when Visual Basic for Applications tries to open a file.

In order to know how to specify a particular file converter, you need to understand the Application.FileConverters property. This property returns information about any file converters that are currently installed.

For example, if you use the Application.FileConverters property without specifying its arguments, the property returns an array with information about all the file converters that are installed. The array is organized as follows:

  • The number of rows is equal to the number of installed file converters. Each converter has its own row.
  • The number of columns is 3. The first column displays the long name of the relevant file converter. The second column contains the path of the converter’s DLL or code resource. The third column shows the file-extension search string.

When working with the Converter argument, you’ll be interested in the row numbers. The reason for this is the way in which you specify the first file converter to use when opening a file:

  • The Converter argument is an index.
  • Each file converter has such an index.
  • The index is the row numbers of the file converters that the Application.FileConverters property (explained above) returns.

There may be situations in which the file converter that you specify with the Converter argument (which is tried first) doesn’t recognize the file being opened. In such cases, the other converters are tried.

Argument #13: AddToMru

AddToMru determines whether the Excel workbook that is being opened is added to the list of recently used files or not. MRU stands for Most Recently Used.

The most recently used list is the list of files that have been recently opened in Excel. You can generally find it in the Open tab of the Backstage View.

excel most recently used list

The default value of AddToMru is False. In this case, the workbook isn’t added to the list of recently used files.

In order to have the Excel workbook added to the list of recently used files, set AddToMru to True. The image below shows how this looks like in the case of the Open_Workbook_Basic macro:

vba open workbook addtomru

Argument #14: Local

The Local parameter makes reference to language and localization settings. Therefore, you may encounter/use this argument if the macro you’re creating is to be used in an international setting where some computers may have different language settings.

More precisely, Local determines against which language are files saved. There are 2 possible values: True or False. Depending on the value you choose, files are saved as follows:

  • True: Files are saved against Excel’s language. This language is generally determined from the control panel settings.
  • False: Files are saved against VBA’s language. This language is generally English. There is a relatively obscure exception to this rule: When the VBA project containing the Workbooks.Open method is an old internationalized XL5/95 project. My guess is that the likelihood of you encountering such a file nowadays is about as high as that of finding the Microsoft Excel 4.0 add-ins which I refer to above.

The following image shows how the Local argument looks like when added to the sample Open_Workbook_Basic macro:

vba open workbook local

Argument #15: CorruptLoad

This is the final argument of the Workbooks.Open method. CorruptLoad determines how a file that has been corrupted is processed upon opening.

The CorruptLoad argument can take 1 of the following 3 values:

  • 0: Represents xlNormalLoad. In this case, the Excel workbook is opened normally. This is the default value, and applies if you don’t specify anything else.
  • 1: Stands for xlRepairFile. In such a case, the Excel workbook is opened in repair mode. In repair mode, Excel tries to recover as much as possible of the workbook being opened.
  • 2: Is the value for xlExtractData. When using this processing mode, the workbook is opened in extract data mode. In extract data mode, Excel extracts the values and formulas from the workbook. Generally, you use extract data mode when the repair mode fails to recover the data/workbook appropriately.

In the following screenshot, the VBA code of the Open_Workbook_Basic macro includes the CorruptLoad parameter. In this case, CorruptLoad is set to 1 (xlRepairFile).

vba open workbook corruptload

When executing this macro, Excel opens the “Example – VBA open workbook” file in repair mode and displays the following message:

excel repair mode dialog

The first time I read the arguments of the Workbooks.Open method, I was slightly surprised that there was no argument to determine whether macros are enabled or disabled upon opening an Excel workbook using VBA.

Eventually, I found out…

How To Enable Or Disable Macros In An Excel Workbook Opened With VBA

Macros are enabled by default whenever you open a file programmatically.

In order to modify the macro security setting that applies when opening an Excel workbook programmatically, you use the Application.AutomationSecurity property. This property allows you to set the security mode that Excel uses when opening files programmatically.

You can generally set the Application.AutomationSecurity property to any of the following 3 constants:

  • 1: Represents msoAutomationSecurityLow which enables all macros. As mentioned at the beginning of this section, msoAutomationSecurityLow is the default value.
  • 2: Stands for msoAutomationSecurityByUI. In this case, the actual security setting is set through the Security dialog box.
  • 3: This is called msoAutomationSecurityForceDisable. This security mode disables all macros and doesn’t show any alerts. This restriction doesn’t apply to Microsoft Excel 4.0 macros. If you open (programmatically) an Excel workbook containing such type of macros, Excel anyway asks the user if the file should be opened or not. This is the case even if the property is set to msoAutomationSecurityForceDisable.

You may want to (generally) reset Application.AutomationSecurity to the default (msoAutomationSecurityLow) after opening the appropriate Excel workbook and before ending the relevant Sub. This reduces the risk of having problems later when a particular solution relies on that default value.

The Application.GetOpenFilename Method: A Closer Look

I introduce and explain the basics of the Application.GetOpenFilename method at the beginning of this Excel tutorial.

The main reason to use the Application.GetOpenFilename method is that it allows your users to select the Excel workbook they want to open without having to remember or type the full path/name/extension. This has 2 main advantages:

  • Advantage #1: Generally, using the Application.GetOpenFilename is more user-friendly than simply relying on the Workbooks.Open method.
  • Advantage #2: The Application.GetOpenFilename ensures that the FileName parameter of the Workbooks.Open method is correct. In other words, GetOpenFilename pretty much guarantees that the path/name/extension argument used by the Open method is valid.

The Application.GetOpenFilename method has 5 arguments. In the sample Open_Workbooks_Dialog macro I’ve only used 1 (FileFilter).

In order to see which other settings you can work with, let’s take a closer look at the syntax of GetOpenFilename and its 4 other parameters:

The Application.GetOpenFilename Method: Full Syntax

The following is the full syntax of the Application.GetOpenFilename method:

expression.GetOpenFilename(FileFilter, FilterIndex, Title, ButtonText, MultiSelect)

“expression” stands for a variable representing an Application object. In practice, you’re like to end up simply using the Application object itself instead of such a variable. Therefore, you’re likely to commonly use the following syntax:

Application.GetOpenFilename

This is, for example, the syntax used in the Open_Workbook_Dialog macro, as shown below:

macro open workbook getopenfilename

I explain the FileFilter argument of the Application.GetOpenFilename method above. Let’s continue to dissect this helpful method by taking a look at the other 4 available parameters:

Parameters Of the Application.GetOpenFilename Method

The following table lists and introduces the 5 parameters of the GetOpenFilename method. All of these arguments are optional.

The arguments of the Application.GetOpenFilename method (generally) focus on the possibility of making some minor modifications to the Open dialog.

Position Name Description
1 FileFilter Determines file filters.
2 FilterIndex Determines the default file filter.
3 Title Determines the title of the (usually called) Open dialog box.
4 ButtonText Applies only when working in the Mac platform. 

Determines the text of the button.

5 MultiSelect Determines whether the user can select multiple files (or not).

I explain all of these arguments (except FileFilter) in more detail below.

Argument #2: FilterIndex

You determine the file filtering criteria using the FileFilter argument. Since this argument allows you to create several filters, Excel needs a way to determine which the default one is.

Here is where the FilterIndex argument comes in:

It “specifies the index numbers of the default file filtering criteria“.

To understand how the FilterIndex parameter works in practice, take a look at the following Open dialog. Notice that there are 2 filters (xl Files and xm Files) in the Files of type drop-down list box.

getopenfilename method filterindex vba

This Open dialog box is displayed when the following version of the Open_Workbook_Dialog macro is executed. Notice how the FileFilter parameter sets 2 file-filtering criteria but there’s no FilterIndex argument.

vba open workbook filefilter

When you omit the FilterIndex argument, Excel displays the first filter. In the case above, this filter is xl Files.

Let’s assume, however, that you want a different filter to be displayed as default. The following image shows how you can modify the Open_Workbook_Dialog macro to add the FilterIndex argument and select the second filter (xm Files) as the default filter.

vba open workbook filterindex

The resulting Open dialog box looks as follows. Notice that, now, the default filter is indeed xm Files, even though it continues to be in the second position within the Files of type drop-down list box.

excel open dialog filterindex

In the image above, you may also notice that the sample Excel workbook named “Example – VBA open workbook.xlsx” doesn’t appear as it does in previous screenshots. This is because it has been filtered out by the xm Files filter.

The xm Files filter is used to display only files whose extension begins with the letters “xm”. These are generally files that use the .xml format. In fact, the xm File filter can probably be specified more specifically with the string pair “xm Files,*.xml”.

The FilterIndex argument can only take values between 1 and the number of file filters that you’ve specified with the FileFilter argument. In the case above, this upper limit is 2.

If you set a value that is larger than the number of filters that actually exist, Excel uses the first file filter. In the case of the Open_Workbook_Dialog macro above, this would happen whenever the FilterIndex parameter has a value equal to or larger than 3. The VBA code for this case appears in the following image:

vba open workbook default filterindex

In this case, the Open dialog box is as follows. Notice how, as expected, the default filter is xl Files (the first filter).

excel open dialog filterindex default

Argument #3: Title

The Title argument of the Application.GetOpenFilename method is kind self-explanatory:

It allows you to determine the title of the dialog box that is usually known as the Open dialog. As you probably expect, if you omit this parameter, the title of the dialog box is “Open”.

The following image shows how the VBA code behind the Open_Workbook_Dialog macro looks like if the Title argument is set to “Example VBA Open Workbook”:

vba open workbook title

Notice how the new title appears at the top of the (previously Open) dialog box:

example vba open workbook dialog 1

Argument #4: ButtonText

The ButtonText only applies in Mac platforms. When used in Windows, the argument is ignored.

It allows you to determine the text that appears in the action button. This is the button regularly known as the Open button.

vba open workbook buttontext

The fact that you can’t change the text of the Open button when working in Windows may lead to slightly confusing situations:

Imagine, for example, that you’re using the GetOpenFilename method for a purpose other than opening an Excel workbook. In such cases, the button will continue to say “Open”, even though the file isn’t really opened later.

Argument #5: MultiSelect

The MultiSelect argument of the Application.GetOpenFilename method allows you to determine whether the user can select multiple file names at the same time.

By default, users are only allowed to select a single file. In this case, the value of the MultiSelect parameter is False. If you want to explicitly specify that MultiSelect is False, the VBA code of the Open_Workbook_Dialog macro looks as follows:

Application.GetOpenFilename | If myFilename Then | Workbooks.Open | End If

If you set MultiSelect to True, users can select several file names. If you set MultiSelect to True, the Application.GetOpenFilename method returns an array with the selected filenames. This is the case even if you select a single file. Therefore, when you enable MultiSelect, you must make the following 2 modifications to the VBA code example that appears above:

  1. Set the MultiSelect parameter to True.
  2. Treat the my_FileName variable as an array. This involves, in particular, modifying the way in which you open the workbook(s) whose filenames are returned by the GetOpenFilename method. If you only set MultiSelect to True (#1 above) but fail to appropriately handle the array that GetOpenFilename returns, VBA is likely to return a Type mismatch error.

Conclusion

2 of the most common operations when working with Excel are:

  • Opening Excel workbooks; and
  • Specifying file paths and names.

Workbooks.Open and Application.GetOpenFilename are the basic methods that you use for purposes of carrying out these operations with VBA. Therefore, you’re likely to use both of these methods quite bit when creating macros and working with Visual Basic for Applications.

Fortunately, if you’ve read this Excel tutorial, you’re knowledgeable enough to use both the Open and GetOpenFilename methods. In addition to knowing what their purpose is, you’ve seen what each of their parameters is and what they allow you to specify.

Понравилась статья? Поделить с друзьями:
  • Excel vba workbook methods
  • Excel vba text align
  • Excel vba workbook hide
  • Excel vba target value
  • Excel vba word колонтитул