In recent articles I’ve covered working with various pieces
of the Microsoft Office Suite including Word and Excel. Today,
I’ll continue the concept by manipulating Microsoft Outlook via Microsoft .NET
Working with Outlook
As with other Microsoft Office products, Visual Basic
for Applications (VBA) is utilized. Consequently, a little COM (Component
Object Model) knowledge comes in handy. However, the .NET
COM interop feature simplifies the process for
.NET developers. Thus, you can easily utilize COM objects within a .NET
The Outlook object model exposes many features of the
Outlook environment. This includes the following functionality:
- E-mail: create, send, and
manipulate mail items
- Contacts database: Utilize the
Outlook contacts databases. You may add new contacts, edit existing, or
integrate with other applications like creating a letter via Word and
information from an Outlook contact.
- Calendar: create, edit, delete,
and manipulate individual calendar entries
- Notes and Tasks: Interact with the
notes and tasks portions of Outlook
- Outlook user interface: Control or
manipulate explorers, inspectors, command bars, and so forth.
Microsoft supplies an interop
assembly, which ships with Outlook 2003. This assembly, named Microsoft.Office.Interop.Outlook.dll,
resides in the Global Assembly Cache under the name
Microsoft.Office.Interop.Outlook.dll. To reference this assembly from Visual
Studio .NET 2003, access the COM tab from the Add References dialog box and
select Microsoft Outlook 11.0 Object Library.
Outlook object model
Outlook exposes an overwhelming number of objects with
associated methods, properties, and so forth. Thankfully, their functions are
documented and available with an installation of Microsoft Office. The help
files are located on the hard drive (if help is installed) in the following
<drive letter>:\Program Files\Microsoft Office\OFFICE11\1033
There will be help files for all Office applications
installed. A drawback of the help documentation is all code examples are
presented via VBScript, so you will have to be aware of this difference when
trying to apply to the .NET Framework. With that said, let’s take a closer look
at individual entities within the Outlook object model. We’ll focus on the
- Application: The Outlook
application environment. This is the root object necessary to work with
- Namespace: The Namespace object
represents the messaging service provider. The MAPI namespace is required
to gain access to Outlook folders and items.
- MailItem: The MailItem
object allows you to work with Outlook mail memos. There are various item
objects available to work with the various item types including notes, calendar
entries, contacts, and so forth.
- MAPIFolder: If you use Outlook, you’re
familiar with folders. (I’m often chastised for my organized Outlook
inbox, with everything filed in the appropriate folder.) The MAPIFolder object provides a vehicle for working with
Let’s put these objects to use by creating and sending e-mails via Outlook.
In the next example, a simple mail message is created and
sent via Outlook.
Listing A uses C#, while
Listing B shows the example with VB.NET.
A few notes on the code:
copy of the mail message is copied to the Drafts folder for the purpose of
demonstrating how placing a message in a folder works. The olDefaultFolders object contains a list of the default
folders included with Outlook.
creation of a mail item uses the CreateItem
method of the Outlook.Application class. The
call to this method requires a cast to the necessary Item type (in this
various properties of a mail message are included as properties of the MailItem class: to, subject, body, and so forth.
- The SaveSentMessageFolder property of the MailItem class allows you to designate where a copy of
the message should be saved (it is optional).
Send method of the MailItem class sends the
message via Outlook.
creation is included in a try/catch block that handles COM exceptions. The
COMException class is available in the System.Runtime.InteropServices namespace, so this
namespace should be included in the code.
Security is an important aspect of Outlook, and allowing
external code to create and send mail messages is considered a big security
risk. When and if you execute the code in the previous example, you will see an
Outlook security dialog box that says “A program is trying to
automatically send e-mail on your behalf. Do you want to allow this? If this is
unexpected, it may be a virus and you should choose ‘No’.” The dialog box
contains Yes, No, and Help buttons, so the user may cancel the operation with a
simple click of the mouse.
Creating an appointment
In the next example, we create an Outlook appointment to
appear on the user’s calendar. Once again, the base Application object is
utilized. In addition, an AppointmentItem is used as
opposed to the previously used MailItem since we are
creating a calendar entry. Listing C
uses C# to demonstrate how you may accomplish this. Listing D provides the example in VB.NET.
A few notes on the code:
- The AppointmentItem class includes various properties for
setting up an appointment. In this example, we utilize the Subject (what
appears in the calendar), body (visible when an entry is opened), location, start date/time, and end date/time.
- The ReminderSet property of the AppointmentItem
class determines if a reminder is displayed to the user. The associated ReminderMinutesBeforeStart property determines when
the reminder will be displayed.
Importance property of the AppointmentItem class
sets the item’s importance. Values for the property are set via the OlImporantance enumerator, which has the following
values: olImportanceHigh, olImportanceLow,
- The BusyStatus property determines how the appointment is
displayed on the calendar (i.e., whether the time is blocked off as busy,
tentative, free, and so forth. The OlBusyStatus
enumerator contains the following list of possible values: olBusy, olFree, olOutOfOffice, and olTentative.
Another developer option
Microsoft Office is the most popular office productivity
suite in the world, and it is a desktop standard for most large organizations.
For this reason, it is often available for you to take advantage of in your
.NET applications. A Windows Forms application may easily utilize the mail
features of Outlook and, likewise, add calendar appointments or contact
database entries with very little code. The interoperability between the .NET
platform and Microsoft Office greatly expand the developer’s options.
TechRepublic’s free .NET newsletter, delivered each Wednesday, contains useful tips and coding examples on topics such as Web services, ASP.NET, ADO.NET, and Visual Studio .NET. Automatically sign up today!