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
the Microsoft fee-based consulting line at (800) 936-5200. For more
information about the support options available from Microsoft, please see
the following page on the World Wide Web:
Properly Referencing Members of a Collection
If you use Visual Basic or Visual Basic for Applications code that loops
through items in a folder, you may see the modifications to those items are
not saved. You may be unintentionally re-retrieving the item from the Items
collection, and any changes that you have made to an item are unexpectedly
lost.
Many Outlook solutions modify the contents of items in a folder. In most
scenarios, you loop through the Items collection in the Outlook object
model. If you do not properly reference the items in the collection, you
may receive unexpected results.
Before modifying an item and saving it, you should set an object variable
to the item, make changes to the item using the object variable, and then
save the object.
Consider the following Visual Basic automation code sample, which is
designed to reset the birthday field for each contact in the default
Contacts folder:
NOTE: Be sure to reference the Outlook 98 Object Library before running
these code examples and be aware running this code will modify any existing
contacts you have in your Contacts folder.
Sub ResetBirthdays1()
Dim olns as Outlook.Namespace
Dim oConItems As Outlook.Items
Dim iNumItems As Integer
Set ol = New Outlook.Application
Set olns = ol.GetNamespace("MAPI")
Set oConItems = olns.GetDefaultFolder(olFolderContacts).Items
iNumItems = oConItems.Count
For I = 1 to iNumItems
oConItems.Item(I).Birthday = "1/1/4501"
oConItems.Item(I).Close olSave
Next
Set oConItems = Nothing
Set olns = Nothing
Set ol = Nothing
End Sub
In the previous sample, the loop is adequately structured and will process
all of the items in the folder. However, within the loop, each time
ConItems.Item(I) is executed, it retrieves the specific item from the
collection of items. In this case, the Birthday is set for an item, but
then then following line of code gets the item from the collection again.
The end result is that an unmodified item is saved.
The following example is one way of modifying the previous code sample, so
that it executes as expected:
Sub ResetBirthdays2()
Dim olns As Outlook.Namespace
Dim oConItems As Outlook.Items
Dim iNumItems As Integer
Set ol = New Outlook.Application
Set olns = ol.GetNamespace("MAPI")
Set oConItems = olns.GetDefaultFolder(olFolderContacts).Items
iNumItems = oConItems.Count
For I = 1 to iNumItems
Set oCurItem = oConItems.Item(I)
oCurItem.Birthday = "1/1/4501"
oCurItem.Close olSave
Next
Set oConItems = Nothing
Set olns = Nothing
Set ol = Nothing
End Sub
In the previous sample, oCurItem is set to a specific item in the
collection, modifications to the item are made using that object variable,
and the object is saved. This avoids getting an item from the collection
and losing any changes.
The following example provides the same functionality as the previous
example, but uses the For Each...Next structure to loop through the items:
Sub ResetBirthdays3()
Dim olns as Outlook.Namespace
Dim oConItems As Outlook.Items
Set ol = New Outlook.Application
Set olns = ol.GetNamespace("MAPI")
Set oConItems = olns.GetDefaultFolder(olFolderContacts).Items
For Each oCurItem in oConItems
oCurItem.Birthday = "1/1/4501"
oCurItem.Close olSave
Next
Set oConItems = Nothing
Set olns = Nothing
Set ol = Nothing
End Sub
Deleting All Members of a Collection
If you want to programmatically delete all of the members of a collection,
there are a few approaches that will work but there are also a number of
approaches that will not work. Unexpected results occur because a
collection is changing as you delete members from within it and the
collection is not update dynamically. Typically you will find that every
other item in the collection is deleted.
The following automation code example exhibits this behavior. Before
running this code, create a subfolder of your Inbox called Test and copy
(not move) some items into the folder so that they can be deleted.
Sub DeleteItems()
Set ol = New Outlook.Application
Set olns = ol.GetNamespace("MAPI")
Set TestFolder = olns.GetDefaultFolder(olFolderInbox).Folders("Test")
Set TestItems = TestFolder.Items
For Each Itm In TestItems
Itm.Delete
Next
End Sub
To workaround this problem, delete the items from the collection in reverse
order using the following approach:
Sub DeleteItems()
Set ol = New Outlook.Application
Set olns = ol.GetNamespace("MAPI")
Set TestFolder = olns.GetDefaultFolder(olFolderInbox).Folders("test")
Set TestItems = TestFolder.Items
NumItems = TestItems.Count
For I = NumItems To 1 Step -1
TestItems(I).Delete
Next
End Sub
Handling Unexpected Item Types
If you are looping through items in a folder, you should make sure your
solution will work even if the folder contains items that you might not
expect to be there. The Inbox typically poses the most concern since the
user generally has less control over what items are placed in that folder.
Examples of items that you might unexpectedly find in a folder include:
- A Meeting or Task Request item in the Inbox.
- An item that is a file from an external source, such as a Microsoft Word
document or a Microsoft Excel spreadsheet. These files may be directly
posted into a folder from another application or they may have been
dragged into a folder.
- A Conflict message sent by Microsoft Exchange if more than one person
has edited an item at the same time in a Public Folder.
- An item that is based on a form designed using the Exchange Form
Designer (EFD). These types of items may not function exactly like
Outlook items in all circumstances. For example, you cannot
programmatically add an attachment that is a link to an EFD-based item.
- A "Distribution List" item in a Contacts folder. If you are using
Outlook 98 in Internet Mail Only (IMO) mode you can create a
distribution list using the Windows Address Book (WAB). These lists are
stored -- but not exposed -- in the default Contact folder, but if you
programmatically loop through the items in the folder, you will find
items with a "IPM.DistList" message class.
Typically you will not run into problems when your code references one of
these items. Problems usually occur when you try to reference a property of
a particular item type and that property does not exist.
Following are approaches you can use to avoid these types of problems.
Choose the approach that is best suited to your solution, the type of
folder you are working with and the types of items that could potentially
affect your solution.
- Use the TypeName function to test the type of object being referenced:
If TypeName(objMyItem) = "ContactItem" Then...
- Check the MessageClass property of an item:
If Left(objMyItem.MessageClass,11) = "IPM.Contact" Then...
- Use error trapping to simply skip over lines of code that may
potentially cause a problem:
For Each oMyMailItem in oMyInboxItems
On Error Resume Next
oMyMailItem.VotingOptions = ""
oMyMailItem.Save
Next