Mindy Martin
Independent Consultant
August 21, 1998
This article originally appeared in the conference proceedings for the Microsoft Office and VBA Solutions Conference and Exposition, held in London, England, July 12-15, 1998, and is reprinted with permission of Informant Communications Group, Inc. Please visit their Web site at http://www.informant.com/mod/index.asp.
Microsoft Outlook™, a desktop information manager and 32-bit e-mail client, is the newest addition to the Microsoft Office suite. Designed for optimal use as the e-mail client to Exchange 5.5, Outlook is the replacement for both the Exchange client and Schedule+. In addition to e-mail capabilities, Outlook has a number of personal management modules, such as a calendar tool for setting appointments, contact management, task management, and a journal tracking system. By utilizing Outlook functionality, you can add modules to your Office applications that can be used for collecting and submitting information, document tracking, item requests, purchase orders, and registration and notification.
The first step towards integrating Outlook functionality into your applications is to understand the Outlook object model. Figure 1 displays a sample of the Outlook object model. At the top is the Application object, which represents Outlook as a whole. Below the Application object is the Namespace object, which represents the message store. The Namespace object contains Folders, which in turn contain Items. An item is a particular instance of Outlook data such as an e-mail message or a contact.
Figure 1. Outlook object model
Application. The Application object represents the entire Outlook application and is the top object in the hierarchy. The Application object is also the only object that can be returned when Automating Outlook. The major purposes of the Application object are as follows:
Namespace. The Namespace object represents the messaging service provider or message store. Currently the only available message store in Outlook is MAPI, which allows access to all Outlook folders and items. Some of the features of the Namespace object include:
Folders. All Outlook items are contained within folders. These folders are then grouped into a collection of folders called the Folders collection object. The Folders collection object represents a collection of all folders within Outlook. Although currently only MAPIFolder objects exist in this collection, eventually other folder types may exist.
MAPIFolder. A MAPIFolder object represents a single Outlook folder such as Contacts or the Inbox. A MAPIFolder object can contain individual items such as messages or appointments, or it can contain other folders. Folders can be typed to contain only a default item such as only e-mail items or only appointment items.
Items. Every folder has an Items collection object, which represents all Outlook objects within that folder. The Items collection can be broken down further into specific types of items such as e-mail messages, appointments, and tasks.
AddressLists and AddressEntries. The AddressLists collection object represents all of the address books installed for a particular profile. Within each individual AddressList object is a collection of AddressEntries. This collection contains all of the entries in that particular book. Entries can be added, edited, and removed programmatically.
To begin automating Outlook, you must first set a reference to the Outlook type library. Within your project, bring up your references dialog box and select the Microsoft Outlook 8.5 Object Library option. If this is not visible, browse for the file MSOUTL85.OLB wherever Office 97 was installed.
After a reference has been set, create a new instance of the Outlook application class object. The Application object is the only object that can be referenced directly. If Outlook is not currently running, it will be started and minimized. If Outlook is already running, a new instance will not be created, but a reference to the current instance is returned.
Once a reference is set to the Application object, you can then specify a namespace and log on to the system. Use the GetNamespace method of the Application object to establish a MAPI namespace and then call the Logon method of the Namespace object to officially log on to Outlook. The Logon method takes up to four optional arguments:
Bypassing the use of the Logon method when Outlook is not running forces the Outlook Profile dialog box to be displayed or the default profile to be used. If Outlook is already running and the Logon method is bypassed, the current profile and session is used. The code shown below creates a new instance of Outlook, retrieves the MAPI namespace, and displays the Outlook Profile dialog box to the user.
Function startOutlook()
Dim ol As New Outlook.Application
Dim ns As Outlook.NameSpace
'Return a reference to the MAPI layer.
Set ns = ol.GetNamespace("MAPI")
'Let the user logon to Outlook with the
'Outlook Profile dialog box,
'and then create a new session.
ns.Logon , , True, True
End Function
As opposed to other Office 97 applications, Outlook does not have any events associated with the Application object. All events in Outlook are centered on the Outlook form, which is used to display item data. However, you can simulate an application's Open and Quit events if you are automating Outlook from Access or Visual Basic® by wrapping a class module around an instance of Outlook.
Once you have finished automating Outlook, you should clean up and log off of the current session. In addition, you should release all memory from your object variables no longer needed. The code shown below demonstrates the use of the Logoff method.
Function CleanUpOutlook()
'This logs the current profile off of a session.
ns.Logoff
'Release all memory.
Set ns = Nothing
Set ol = Nothing
End Function
In order to move around in Outlook, you will need to know how to navigate within folders. All Outlook data is organized into folders, which often contain specific information. For example, a folder can be designated to only hold e-mail messages or contact information. This section covers how to access folders, navigate within nested folders, and how to create new folders.
When Outlook is first installed, a number of default folders are created in the Outlook message store. Each folder is designed for a specific purpose and to hold a particular item type. For example, the Inbox is used to receive incoming e-mail.
You can use the GetDefaultFolder method of the Namespace object to return one of these folders. Table 1 lists the folder names and the associated constant that is used with the GetDefaultFolder method.
Table 1. Default folders and the associated constant
| Default Folder | Default Folder Constant |
| Deleted Items | OlFolderDeletedItems |
| Outbox | OlFolderOutbox |
| Sent Items | OlFolderSentMail |
| Inbox | OlFolderInbox |
| Calendar | OlFolderCalendar |
| Contacts | OlFolderContacts |
| Journal | OlFolderJournal |
| Notes | OlFolderNotes |
| Tasks | OlFolderTasks |
The code shown below demonstrates the use of the GetDefaultFolder method to retrieve the Inbox folder for the currently logged on user. After a MAPI message store has been returned, the GetDefaultFolder method is used to set a reference to the Inbox folder. Finally the folder is displayed in a new Outlook Explorer window. Even if Outlook is already running, a new window will be opened.
Sub GetDefaultInbox()
Dim ol As New Outlook.Application
Dim ns As Outlook.NameSpace
Dim fdInbox As Outlook.MAPIFolder
Set ns = ol.GetNamespace("MAPI")
'Reference the default Inbox folder
Set fdInbox = ns.GetDefaultFolder(olFolderInbox)
'Display the Inbox in a new Explorer window
fdInbox.Display
End Sub
One of the more powerful features of Outlook allows you to access another user's folders and items. To accomplish this, the user who is sharing a folder, the delegate, must first explicitly delegate access to the folder. Once this is done, you can use the GetSharedDefaultFolder method to return one of the delegate's default folders.
In the code shown below, a new recipient is created for the name of the user passed into the procedure and resolved. If the person does exist in the network, return the default Calendar using the GetSharedDefaultFolder method and display the folder in a new Outlook Explorer window. If the user doesn't exist, alert the user to select a different person.
Sub GetSharedFolder(strRecip As String)
Dim ol As New Outlook.Application
Dim ns As Outlook.NameSpace
Dim del As Outlook.Recipient
Dim dfdCalendar As Outlook.MAPIFolder
Set ns = ol.GetNamespace("MAPI")
'Create a new recipient object and resolve it.
Set del = ns.CreateRecipient(strRecip)
del.Resolve
'If this user exists on the Exchange server..
If del.Resolved Then
'Get the shared calendar folder
Set dfdCalendar = ns.GetSharedDefaultFolder _
(del, olFolderCalendar)
'Display it in a new Outlook Explorer window.
dfdCalendar.Display
Else
MsgBox "Unable to locate " & strRecip & ". _
Try another name.", vbInformation
End If
End Sub
Because you have the ability to create custom folders within Outlook, you may find it necessary to access a folder other than one of the default folders. For example, you may want to find a nested folder within the Inbox, or you may want to create a subfolder of an Exchange Public Folder. You can retrieve a nested folder by using a combination of the Folders property to return a collection of folders and by using the Folders(x) syntax to refer to the folder by name or index number. After locating the folder, use the Parent property to determine the container folder.
The code shown below demonstrates how to loop through all of the nested folders of a Personal Folder to locate a particular folder. First a reference is set to return all of the folders contained within a Personal Folder called Development. Next a For Each loop is used to explore each of the nested folders looking for one named Acme. When the folder is found, the For Each loop is exited and the reference to the folder is maintained. To make sure the reference is good, the Parent property is used to display the name of the parent folder.
Sub ExploreFolders()
Dim ol As New Outlook.Application
Dim ns As Outlook.NameSpace
Dim fds As Outlook.Folders
Dim fd As Outlook.MAPIFolder
Set ns = ol.GetNamespace("MAPI")
'Set a reference to all folders within
'a personal folder called development
Set fds = ns.Folders("Development").Folders
'Loop through all of the folders looking
'for one named Acme.
For Each fd In fds
If fd.Name = "Acme" Then
Exit For
End If
Next
'Display the name of the parent folder
MsgBox fd.Parent
End Sub
To create a new folder in Outlook, use the Add method of the Folders collection object and pass the name of the new folder as a string argument. You can also indicate the type of items the folder will hold, such as e-mail messages or contact items. If you do not supply this argument, the folder takes on the type of its parent folder. For example, if you create a new folder under the Inbox folder, the new folder defaults to hold e-mail messages.
In the code shown below, a reference is first set to the default Contact folder. Next the Folders property is used to return the Folders collection. Finally the Add method can then be called to create a new folder. The name is passes as an argument, but because the type is not indicated the folder will inherit the properties of the parent Contact folder.
Sub CreateNewFolder()
Dim ol As New Outlook.Application
Dim ns As Outlook.NameSpace
Dim fdsConts As Outlook.MAPIFolder
Set ns = ol.GetNamespace("MAPI")
'Reference the default Contacts folder.
Set fdsConts = ns.GetDefaultFolder(olFolderContacts)
'Add a new folder to the contacts folder collection.
'By not specifying the type, the folder will hold
'Contact items.
fdsDContacts.Folders.Add ("Acme Contacts")
End Sub
Within a folder is a collection of Items, which represent Outlook data. An Item can be one of a number of different types that represent the different functions of Outlook such as e-mail items, contacts, and appointments. Outlook items are actually instances of a message class. Outlook Items that can be created programmatically are listed and described in Table 2.
Table 2. Outlook Items that can be created programmatically
| Outlook Item | Description |
| AppointmentItem | An appointment in a Calendar folder, which can be a meeting, one-time appointment, or recurring appointment or meeting. |
| ContactItem | A contact in the Contacts folder. |
| JournalItem | A journal entry in the Journal folder. |
| MailItem | An e-mail message in an e-mail folder such as the Inbox. |
| NoteItem | Post-it type note in a Notes folder. |
| PostItem | Posting in a public folder that others may browse. Post items are not sent to anyone. |
| TaskItem | A task in a Tasks folder. The task can be assigned, delegated, or self-imposed. |
The easiest way to create a new item is to use the CreateItem method of the Application object. The CreateItem method creates a new standard Outlook item of the specified type and returns a reference to it. This method allows you to bypass navigating the object model to get to the methods of the Item object in order to create a new item. In the code shown below, a new Task item is created with the CreateItem method of the Application object. After creating the task, a few properties are set, and the item is saved.
Sub CreateTaskItem()
Dim ol As New Outlook.Application
Dim ns As Outlook.NameSpace
Dim itmTask As Outlook.TaskItem
Set ns = ol.GetNamespace("MAPI")
'Create a new Task item.
Set itmTask = ol.CreateItem(olTaskItem)
'Set some properties of the Task item.
With itmTask
.Subject = "Write article"
.DueDate = "8/22/97"
.Importance = olImportanceHigh
.Save
End With
End Sub
If you will be creating an item that is based on a customized Outlook form (a standard form that has been altered in Outlook), you cannot use the CreateItem method. To create a new item based on a custom form, use the Add method of the Items collection object and pass the message class name of the custom form. The code shown below demonstrates how to create a new item based on a custom form.
Sub CreateCustomTaskItem()
Dim ol As New Outlook.Application
Dim ns As Outlook.NameSpace
Dim fdTasks As Outlook.MAPIFolder
Dim fdAcme As Outlook.MAPIFolder
Dim itmTask As Outlook.TaskItem
Set ns = ol.GetNamespace("MAPI")
'Reference the appropriate folders.
Set fdTasks = ns.GetDefaultFolder(olFolderTasks)
Set fdAcme = fdTasks.Folders("Acme Project")
'Create a new custom item and set some properties.
Set itmTask = fdAcme.Items.Add("IPM.Task.Acme Task")
With itmTask
.Subject = "Call Accounting"
.DueDate = "12/1/97"
.Importance = olImportanceLow
.Save
End With
End Sub
The Add method can also be used to create one of the standard items. By omitting the argument, an item of the default item type of the folder will be created. The following example creates a new custom Contact:
Set ol = Application.GetnameSpace("MAPI")
Set fdContacts = ol.GetDefaultFolder(olFolderContacts)
Set newContact = fdContacts.Items.Add
Probably the most common item you will work with is the e-mail message. The e-mail message item represents an e-mail message. Aside from the common properties and methods including Subject, Body, To, CC, and Send, you will need to be able to work with two other objects nested within the item. These objects are the Recipients collection object, which represents all recipients of the e-mail (To and CC alike), and the Attachments collection object, which represents any attachments to the e-mail. The code shown below demonstrates the creation of an e-mail message with recipients and an attachment.
To indicate a recipient, use the Add method of the Recipients collection and pass the name or address of the user. To make certain that the person can be reached through e-mail, use the Resolve method and the Resolved property.
To include an attachment to an e-mail message (or any item), use the Add method of the Attachments collection and pass the location of the file to be attached, and the way the file should be attached such as by reference or embedded. You can also specify a different display name for the item with the DisplayName property of the Attachment object.
Sub NewMailMessage()
Dim ol As New Outlook.Application
Dim ns As Outlook.NameSpace
Dim newMail As Outlook.MailItem
'Return a reference to the MAPI layer.
Set ns = ol.GetNamespace("MAPI")
'Create a new mail message item.
Set newMail = ol.CreateItem(olMailItem)
With newMail
'Add the subject of the mail message.
.Subject = "Training Information for October 1997"
'Create some body text.
.Body = "Here is the training information you requested:" & vbCrLf
'Add a recipient and test to make sure that the
'address is valid using the Resolve method.
With .Recipients.Add("mindym@imginc.com")
.Type = olTo
If Not .Resolve Then
MsgBox "Unable to resolve address.", vbInformation
Exit Sub
End If
End With
'Attach a file as a link with an icon.
With .Attachments.Add _
("\\Training\training.xls", olByReference)
.DisplayName = "Training info"
End With
'Send the mail message.
.Send
End With
'Release memory.
Set ol = Nothing
Set ns = Nothing
Set newMail = Nothing
End Sub
To bring the Internet and intranet into your e-mail, you can include hyperlinks with your items. Hyperlinks may only be added within the body of an item, but can be included in any Outlook item. Some of the more common protocols that can be used in Outlook are listed in Table 3.
Table 3. Common protocols used in hyperlinks in Outlook
| Protocol | Description |
| File:// | Used to open files on a local server. |
| FTP:// | File Transfer Protocol (FTP) is used to transfer files over the Internet. |
| HTTP:// | Hypertext Transfer Protocol (HTTP) is used to display Web pages. |
| Mailto:// | Used with an e-mail address. Creates a new e-mail message to a particular person by clicking the hyperlink. |
| News:// | Opens an Internet newsgroup. Recipient must be attached to an NNTP server. |
| Outlook:// | Used to open an Outlook folder or item. |
If any part of the hyperlink contains spaces, you must enclose the entire address in angled brackets. The code shown below demonstrates the alternate use of a hyperlink to a file as opposed to attaching the file. Notice that the entire hyperlink is enclosed in angled brackets.
Sub useHyperlinks()
Dim ol As New Outlook.Application
Dim ns As Outlook.NameSpace
Dim newMail As Outlook.MailItem
Set ns = ol.GetNamespace("MAPI")
'Create a new mail message item.
Set newMail = ol.CreateItem(olMailItem)
With newMail
.Subject = "Trainer Information for October 1997"
'Create some body text with a hyperlink.
.Body = "Here is the training information you requested:" _
& vbCrLf & "<file:/http://msdn.microsoft.com/training/trainer info.xls>"
With .Recipients.Add("mindym@imginc.com")
.Type = olTo
If Not .Resolve Then
MsgBox "Unable to resolve address.", vbInformation
Exit Sub
End If
End With
'Send the mail message.
.Send
End With
'Release memory.
Set ol = Nothing
Set ns = Nothing
Set newMail = Nothing
End Sub
Another common interaction with Outlook is to schedule meetings. Some of the more common properties and methods include MeetingStatus, Start, End, Location, and Send. In addition, if you need to determine if a person is available or not, add the names of the attendees to the Recipients collection. You can then use the FreeBusy method to determine if the recipient is free or busy for a particular time slot.
The code shown below demonstrates how to schedule a meeting. Start by creating an Appointment item, and then set the MeetingStatus property to olMeeting to turn the appointment into a meeting request. Next some properties are set, such as where the meeting will be held, and the required attendees are indicated. You could also use the Recipients collection at this point and include the FreeBusy method. Finally a reminder is created and the invitations are sent out.
Sub ScheduleMeeting()
Dim ol As New Outlook.Application
Dim ns As Outlook.NameSpace
Dim appt As Outlook.AppointmentItem
'Return a reference to the MAPI layer.
Set ns = ol.GetNamespace("MAPI")
'Create a new mail message item.
Set appt = ol.CreateItem(olAppointmentItem)
With appt
'By changing the meeting status to meeting, you create a
'meeting invitation. You do not need to set this if
'it is only an appointment.
.MeetingStatus = olMeeting
'Set the importance level to high.
.Importance = olImportanceHigh
'Create a subject and add body text.
'Notice the hyperlink.
.Subject = "Acme Client Potential"
.Body = "Let's get together to discuss the possibility of Acme " & _
"becoming a client. Check out their website in the meantime:" _
& vbCrLf & "http://www.acme.com"
'Set the start and end time of the meeting and the location.
.Start = "10:00 AM 10/9/97"
.End = "11:00 AM 10/9/97"
.Location = "Meeting Room 1"
'Invite the required attendees.
'These names will also be placed in the To field by default
.RequiredAttendees = "RichardK; StefanieK"
'Turn the reminder on and set it for 30 minutes prior.
.ReminderSet = True
.ReminderMinutesBeforeStart = 30
'Send the meeting request out.
.Send
End With
'Release memory.
Set ol = Nothing
Set ns = Nothing
Set appt = Nothing
End Sub
To find a particular item, use the Find method. The Find method applies a filter to the Items collection object of a folder and returns the first item that matches the filter. After the Find method runs, FindNext returns the next item in the collection that matches the filter. FindNext starts from the current position in the collection. The Find method uses a filter expression that evaluates to True or False and can contain one or more clauses joined by the logical operators And, Not, and Or. Property names can be used and should be included in square brackets. Variables and constants are not allowed.
The code shown below demonstrates how to locate an item using the Find method. First a reference is set to the default Contacts folder, and then one is set to return the Items collection contained within the folder. Next, a string variable is filled with the criteria to be used. Notice how the Contact property is in square brackets and the value must be enclosed within additional quotes. Finally, the argument is passed to the Find method. If the item is not found, a message box is displayed; if the item is found, the resulting Contact is displayed.
Sub FindAnItem()
Dim ol As New Outlook.Application
Dim ns As Outlook.NameSpace
Dim fdContacts As Outlook.MAPIFolder
Dim itmsContacts As Outlook.Items
Dim itm As Object
Dim criteria As String
Set ns = ol.GetNamespace("MAPI")
'Reference the default Contacts folder and then
'return the Items collection of the folder.
Set fdContacts = ns.GetDefaultFolder(olFolderContacts)
Set itmsContacts = fdContacts.Items
'Establish the criteria and locate the Contact.
criteria = "[LastName] = 'Martin'"
Set itm = itmsContacts.Find(criteria)
'Determine if the item was found.
If itm Is Nothing Then
MsgBox "Unable to locate the item."
Else
'Display the Contact.
itm.Display
End If
End Sub
If you will be locating a subset of items in a folder, use the Restrict method. The Restrict method also applies a filter to a folder, but this method returns a new collection containing all items that match the filter. The Restrict method has slightly slower performance that the Find and FindNext methods, but it is handy in the sense that it returns a collection rather than a single item. Restrict also uses a filter.
The code shown below demonstrates the use of the Restrict method. First, a reference is made to the default Contact folder and then to all items in the folder. Next, the criteria are set to locate all items with a category value of Holiday Cards. The argument is then passed to the Restrict method, which creates a new collection of items with that criterion. Finally, a For Each loop displays each item.
Sub RetrictHolidayCards()
Dim ol As New Outlook.Application
Dim ns As Outlook.NameSpace
Dim fdContacts As Outlook.MAPIFolder
Dim itmsContacts As Outlook.Items
Dim holidayCards As Outlook.Items
Dim itm As Object
Dim criteria As String
Set ns = ol.GetNamespace("MAPI")
'Reference the deafult Contacts folder and then
'return the Items collection of the folder.
Set fdContacts = ns.GetDefaultFolder(olFolderContacts)
Set itmsContacts = fdContacts.Items
'Establish the criteria and locate all Contacts
'with a category value of Holiday Cards.
criteria = "[Categories] = 'Holiday Cards'"
Set holidayCards = itmsContacts.Restrict(criteria)
For Each itm In holidayCards
itm.Display
Next
End Sub
The Restrict method cannot be used with certain properties such as Saved and Unread. For a complete list, see Visual Basic for Outlook help file.
In addition to creating new items, you can also retrieve items and their properties to another application. For example, you can return all scheduling information to Excel for analysis or display message information in Access form.
To retrieve Outlook data, locate the folder that contains the information you require. Next, use a For Each loop to loop through the items in the folder or use the Find method to find a particular item. Finally, use the properties of the individual item classes to acquire the necessary data.
The code shown below uses a form in Access to display properties of unread messages. The Load event of the form begins a new instance of Outlook for the currently logged on user and places the subjects of all unread messages into a list box. Whenever a new subject is selected in the list box, various properties of the message are displayed in a number of textboxes.
Private ol As New Outlook.Application
Private ns As Outlook.NameSpace
Private itms As Outlook.Items
Private Sub Form_Load()
Dim fd As Outlook.MAPIFolder
Dim itm As Object
'Get to the current session of Outlook.
Set ns = ol.GetNamespace("MAPI")
'Retrieve a collection of mail messages in the inbox.
Set itms = ns.GetDefaultFolder(olFolderInbox).Items
'Loop through the items and display the subjects of the unread
'messages in a list box on a form.
For Each itm In itms
If itm.UnRead = True Then
lstSubjects.RowSource = lstSubjects.RowSource _
& itm.Subject & ";"
End If
Next
End Sub
Private Sub lstSubjects_AfterUpdate()
Dim itm As Object
Dim criteria As String
'Find the mail item with the subject currently selected
'in a list box called lstSubjects.
criteria = "[subject] = '" & lstSubjects.Value & "'"
Set itm = itms.Find(criteria)
'Place some item information into text boxes.
txtFrom = itm.SenderName
txtRecieved = itm.ReceivedTime
txtBody = itm.Body
End Sub
New in Microsoft Outlook 98 is the ability to programmatically access the address book for a particular profile. The approach to this is rather straightforward. Begin by returning a Namespace object. Next call the AddressLists property and pass a book name or index value. Once the particular address book has been returned, you can then use the AddressEntries property to return the entire contents of the book. This allows you to then add entries, edit entries, delete them, or simply read the list. The code shown below demonstrates how to return the Personal Address Book, scroll though all of the entries, and fill an array with some of the properties of individual entries.
Sub RetrievePAB()
Dim aPAB() As Variant
Dim adl As Outlook.AddressList
Dim e As Outlook.AddressEntry
Dim i As Integer
ReDim aPAB(100, 2)
Set nsMAPI = ol.GetNamespace("MAPI")
'Return the personal address book.
Set adl = nsMAPI.AddressLists("Personal Address Book")
'Loop through all entries in the PAB
' and fill an array with some properties.
For Each e In adl.AddressEntries
'Display name in address book.
aPAB(i, 0) = e.Name
'Actual e-mail address
aPAB(i, 1) = e.Address
'Type of address ie. internet, CCMail, etc.
aPAB(i, 2) = e.Type
i = i + 1
Next
ReDim aPAB(i - 1, 2)
End Sub
Microsoft Outlook 98 is a powerful e-mail and personal management tool on its own, but when the abilities of Outlook are incorporated with other Office 97 applications, the possibilities are endless. Regardless of whether your application requires e-mail capabilities, scheduling tools, or a contact management system, the Outlook object model can be automated to fulfill each of these needs and more. One object model, unlimited possibilities.
Mindy Martin is an independent consultant, trainer, and author based in Chicago, IL. Mindy is a Microsoft Certified Solution Developer and Microsoft Certified Trainer, and she specializes in everything VBA. Her primary focus is the integration of Microsoft Office into everything from the desktop environment to the Internet, but also finds enjoyment in the creation of collaborative applications with Outlook and Exchange. She is a contributing author of a number of development publications including Microsoft Office and Visual Basic for Applications Developer and VB/Access/Office Advisor, and is currently working on a book on Excel for Sybex. She is a regular speaker at conferences worldwide including Tech*Ed, Informant, and Advisor DevCons.