Article ID: 201096 - Last Review: November 23, 2006 - Revision: 3.4

How to automate Outlook from another program

View products that this article applies to.
This article was previously published under Q201096
For a Microsoft Outlook 97 version of this article, see 168095  (http://support.microsoft.com/kb/168095/ ) .
For a Microsoft Outlook 98 version of this article, see 181202  (http://support.microsoft.com/kb/181202/ ) .
For a Microsoft Outlook 2002 version of this article, see 291120  (http://support.microsoft.com/kb/291120/ ) .

On This Page

Expand all | Collapse all

SUMMARY

This article provides an overview of programming Outlook using Automation from another program.
Back to the top

MORE INFORMATION

Microsoft provides programming examples for illustration only, without warranty either expressed or implied, including, but not limited to, the implied warranties of merchantability and/or fitness for a particular purpose. This article assumes that you are familiar with the programming language being demonstrated and the tools used to create and debug procedures. Microsoft support professionals can help explain the functionality of a particular procedure, but they will not modify these examples to provide added functionality or construct procedures to meet your specific needs.
If you have limited programming experience, you may want to contact a Microsoft Certified Partner or Microsoft Advisory Services. For more information, visit these Microsoft Web sites:

Microsoft Certified Partners - https://partner.microsoft.com/global/30000104 (https://partner.microsoft.com/global/30000104)

Microsoft Advisory Services - http://support.microsoft.com/gp/advisoryservice (http://support.microsoft.com/gp/advisoryservice)

For more information about the support options that are available and about how to contact Microsoft, visit the following Microsoft Web site:http://support.microsoft.com/default.aspx?scid=fh;EN-US;CNTACTMS (http://support.microsoft.com/default.aspx?scid=fh;en-us;cntactms) Automation allows one program to control another program by either issuing commands or retrieving information programmatically. You can use the code examples in this article in Microsoft Word, Microsoft Excel, Microsoft Visual Basic, or any other program that supports Automation.
Back to the top

Early vs. Late Binding

You can use either "early" or "late" binding to start an Automation session. Late binding uses either the GetObject or CreateObject function to initialize Outlook. For example, the following code sets an object to the Outlook program, which is the highest level object in the Outlook object model. All Automation code must first define an Outlook.Application object in order to access any of the other Outlook objects below that.
Dim objOL as Object
Set objOL = CreateObject("Outlook.Application")
To use early binding, you first need to reference the available Outlook object library. To do this from Visual Basic (VB) or Visual Basic for Applications, follow these steps:
  1. In the Visual Basic Editor, on the Tools menu, click References.
  2. Click to select the Microsoft Outlook 9.0 Object Library check box, and then click OK.
The object library file is Msoutl9.olb and installs to the C:\Program Files\Microsoft Office\Office folder by default. Once you reference the Outlook object library, you can use the following syntax to start an Outlook session: 
Set ol = New Outlook.Application
Using early binding has two important advantages. First, code using early binding runs faster than code using late binding (CreateObject/GetObject). Second, because you reference the Outlook object library, you can get online Outlook programming help using the object browser and Help system.
Back to the top

The Outlook Object Model

The Outlook object model allows you to manipulate data stored in Outlook folders. New features in Outlook also allow you to manipulate the Outlook Bar, work with selected items in a folder, and manipulate both item-level and application-level windows. By adding events, your code can respond to many things that occur in Outlook, allowing you to create an event-driven solution.

However, you will find that compared to Word and Excel, there is limited functionality available to control Outlook itself. Many features of Outlook are not exposed or customizable through the Outlook object model. For example, you cannot use the object model to change the Options settings on the Tools menu, although a new feature in Outlook is that you can can create your own page in the Options, or Folder Properties dialog box.

NOTE: As a possible workaround to limitations regarding the object model, you can use the CommandBars object provided by Microsoft Office to execute most commands that are assigned to either toolbar buttons or menu commands. For example, you can use the CommandBars object to run the New Call command, on the Dial submenu of the Tools menu, to bring up the New Call dialog box.

Most programming solutions need to interact with the data stored in Outlook. Outlook stores all of its information in Messaging Application Programming Interface (MAPI) folders. Therefore, after you set an object variable to Outlook.Application, you will commonly set a Namespace object to MAPI:
Set ol = New Outlook.Application
Set olns = ol.GetNamespace("MAPI")
Once you set the Namespace object, you are ready to set the next object to a folder within the MAPI Namespace. One common way of doing this is by specifying the Outlook default folders, which are the folders at the same folder level as the Inbox that receives incoming e-mail. The following code will set the objFolder object to the default Contacts folder: 
Set ol = New Outlook.Application
Set olns = ol.GetNamespace("MAPI")
Set objFolder = olns.GetDefaultFolder(olFolderContacts)
For additional information about referencing other types of folders, please see the following article in the Microsoft Knowledge Base:
208520  (http://support.microsoft.com/kb/208520/EN-US/ ) Programming examples for referencing items and folders
Once you are programmatically at the folder that contains the items you want to either use or create, you can use appropriate code to accomplish your programming task. See the examples later in the article for some common programming examples.

In addition to accessing Outlook data from another application, you can also have your application become aware of when certain events occur in Outlook. Examples of events are when an item is added to a folder, when the user selects a different item in the folder, or when an Outlook reminder is displayed. For a complete list of available events, see the Microsoft Outlook Visual Basic Reference (Vbaoutl9.chm). For information on obtaining the help file, see the References section in this article.

For an example of how you can integrate Outlook events in your application, please see the following article in the Microsoft Knowledge Base:
225502  (http://support.microsoft.com/kb/225502/EN-US/ ) Using Outlook events in another program
Back to the top

Sample Code for Common Programming Tasks

Example: Create a New Default Task Item

Sub CreateNewDefaultOutlookTask()

   Dim ol As Outlook.Application
   Dim NewTask As Outlook.TaskItem

   ' Set the Application object.
   Set ol = New Outlook.Application

   ' Create a new standard task.
   Set NewTask = ol.CreateItem(olTaskItem)

   ' Display the new task form so the user can fill it out.
   NewTask.Display

End Sub

Example: Create a New Contact Using a Custom Form

Sub CreateNewContactFromCustomForm()

   Dim ol As Outlook.Application
   Dim olns As Outlook.NameSpace
   Dim objFolder As Outlook.MAPIFolder
   Dim AllContacts As Outlook.Items
   Dim NewContact As Outlook.ContactItem

   ' Set the Application object.
   Set ol = New Outlook.Application

   ' Set the Namespace object.
   Set olns = ol.GetNamespace("MAPI")

   ' Set the default Contacts folder.
   Set objFolder = olns.GetDefaultFolder(olFolderContacts)

   ' Set objAllContacts equal to the collection of all contacts.
   Set AllContacts = objFolder.Items

   ' Add a new contact to the AllContacts collection using the
   ' "IPM.Contact.MyForm" form.
   Set NewContact = AllContacts.Add("IPM.Contact.MyForm")

   ' Display the new contact form.
   NewContact.Display

End Sub

Example: Loop Through All the Default Contacts

Sub GetOutlookContacts()

   Dim ol As Object
   Dim olns As Object
   Dim objFolder As Object
   Dim objAllContacts As Object
   Dim Contact As Object

   ' Set the Application object.
   Set ol = New Outlook.Application

   ' Set the Namespace object.
   Set olns = ol.GetNamespace("MAPI")

   ' Set the default Contacts folder.
   Set objFolder = olns.GetDefaultFolder(olFolderContacts)

   ' Set objAllContacts equal to the collection of all contacts.
   Set objAllContacts = objFolder.Items

   ' Loop through each contact.
   For Each Contact In objAllContacts

      ' Display the Fullname field for the contact.
      MsgBox Contact.FullName

   Next

End Sub
Back to the top

REFERENCES

For additional information about available resources and answers to commonly asked questions about Microsoft Outlook 2000 solutions, please see the following article in the Microsoft Knowledge Base:
146636  (http://support.microsoft.com/kb/146636/EN-US/ ) Questions about custom forms and Outlook solutions
Back to the top
APPLIES TO
  • Microsoft Outlook 2000 Standard Edition
Back to the top
Keywords: 
kbautomation kbdtacode kbhowto kbprogramming KB201096
Back to the top
 

Get Help Now

Contact a support professional by E-mail, Online, or Phone

Article Translations