March 23, 2019



New features


•   Added ForwardAsAttachment and NewMeeting events to the SafeMailItem object. These events are exposed by Outlook on the low level (IConnectionPointContainer / IConnectionPoint / etc.), but they are not defined in the type library, making it impossible to use them in VBA / VB Script and non-trivial in the .Net languages.

The events are similar to the MailItem.Reply / ReplyAll / Forward events in the Outlook Object Model.

private SafeMailItem _sItem;

private MailItem _oItem;


_oItem = _application.ActiveExplorer().Selection[1];

_sItem = new SafeMailItem();

_sItem.Item = _oItem;

_sItem.ForwardAsAttachment += OnForwardAsAttachment;


private void OnForwardAsAttachment(object Forward, ref bool Cancel)


    MailItem newMessage = (MailItem)Forward;

    if (OlSensitivity.olConfidential == _oItem.Sensitivity)


        MessageBox.Show($"Confidential message '{_oItem.Subject}' cannot be forwarded");

        Cancel = true;




        newMessage.Subject = _oItem.Subject;

        newMessage.Body = $"Please see the attached message '{_oItem.Subject}'.";




•   Outlook Object Model parity: added content indexer support to the search queries used by RDOItems.Restrict and MAPITable.ExecSQL. You can now use ci_phrasematch and ci_startswith operators instead of / in addition to = and LIKE operators. Make sure the store supports content indexing by checking the new RDOStore2 / RDOPSTStore / RDOExchangeMailbox / RDOEASStore.IsInstantSearchEnabled property first. Keep in mind that these operators only work on queries returning multiple matches, which means RDOItems.Find / FindNext will not work.

Set Session = CreateObject("Redemption.RDOSession")

Session.MAPIOBJECT = Application.Session.MAPIOBJECT

Set store = Session.Stores.DefaultStore

query = ""

If store.IsInstantSearchEnabled Then

    query = "Subject ci_phrasematch 'Redemption'"

    Debug.Print "Instant search is enabled"


    query = "Subject like '%Redemption%'"

    Debug.Print "Instant search is NOT enabled"

End If

Set folder = Store.GetDefaultFolder(olFolderInbox)

Set items = folder.Items

Set result = items.Restrict(query)

Debug.Print result.Count & " matches found"



Bug fixes


•   Setting RDOAppointmentItem.Start / End / Duration properties could lead to unexpected errors on machines with missing time zone MUI files.


•   Saving in the MSG file format (RDOMail.SaveAs and Safe*Item.SaveAs) sometimes produced MSG files in plain text even if the original message was HTML.


•   RDOSignature.ApplyTo could corrupt Unicode signature characters if the signature character set (as specified in the HTML header) was different from the current system code page and the Unicode characters were not HTML-encoded.


•   RDOSession.GetAutodiscoverXml did not respect the value of the RDOSession.MAPITimeoutShort and always used a short timeout.


•   SafeInspector.ActiveInlineResponseDiscard and ActiveInlineResponsePopOut actions were reversed  under some older builds of Outlook.


•   Importing MIME files with an attachment without an extension using Redemption MIME converter (olRfc8222_Redemption), a default extension ".dat" was added.


•   Exporting in the MIME format using Redemption MIME converter  (olRfc8222_Redemption), Message-ID header was not exported if PR_INTERNET_MESSAGE_ID property was missing even if the message id was present in the PR_TRANSPORT_MESSAGE_HEADERS property.


•   Importing an iCal file (RDOAppointmentItem.Import or RDOFolder2.Import) would not mark the imported appointment as all-day if DTEND field was not present.


•   Importing a vCard file (RDOAppointmentItem.Import or RDOFolder2.Import) raised an exception if the image specified in the vCard file was invalid / unrecognizable rather than ignoring the error.




January 28, 2019



This version is a hotfix for the appointment issues (version specific)


Bug fixes


•   Setting RDOAppointmentItem.Start / End / Duration properties could lead to unexpected errors.

•   Reading RDOAppointmentItem.Start and End properties returned from RDOFolder2.GetActivitiesForTimeRange for a folder with free/busy-only access rights raised MAPI_E_NO_ACCESS exceptions.

•   The interop dlls (Interop.Redemption.dll  and Interop.Profman.dll) were signed, but not strongly named.



January 22, 2019



New features, bug fixes, Windows 10, Outlook 2016/2019 and Outlook Centennial (Windows Store) compatibility


New features


•   Added the ability to export and import items in the Fast Transfer Stream format (used by the Exchange Server and its Exchange Web Services API - ExportItems and UploadItems operations).
This makes it possible  to upload and download full fidelity Exchange items using Exchange Web Services (EWS) - Fast Transfer Stream uses format similar to the MSG files and preserves all MAPI properties without conversion to or from MIME - you can convert data downloaded from EWS to MSG or PST format or upload MSG or PST files to an Exchange mailbox through EWS.

All Redemption methods capable of exporting or importing data (RDOMail.SaveAs / Import, Safe*Item.SaveAs / Import, RDOFolder2.Import) now support this new format through the new rdoSaveAsType.olFTS enum (1034).

Set Session = CreateObject("Redemption.RDOSession")

Session.MAPIOBJECT = Application.Session.MAPIOBJECT

Set Folder = Session.GetFolderFromID(Application.ActiveExplorer.CurrentFolder.EntryID)

Set item = Folder.Items.Add

item.Sent = true

item.Import "c:\temp\test.fts", olFTS



•   Added RDOExchangeMailboxStore.IsConsumerAccount property. Returns true for a free mailbox, and false otherwise.


•   Outlook 2016 / 2019 compatibility: Added RDOAppointmentItem.DoNotForwardMeeting / DoNotAllowProposeNewTime properties.


•   Saving messages in the MSG format (RDOMail.SaveAs(..., olMsg)) performance was improved by as much as 90% in case of an online Exchange store.


•   The performance of importing MSG files (RDOMail.Import(..., olMsg)) into an online Exchange store was improved by as much as 50%.


•   The performance of the RDOFolder2.GetActivitiesForTimeRange method was improved by 50% - 80%.


•   Accessing RDOMail.Sender, RDOMail.SentOnBehalfOf, RDOMail.ReplyRecipients, RDODistListItem.OneOffMembers, RDORecipient.AddressEntry properties no longer requires an active MAPI session (e.g. if an MSG file is opened using RDOSession.GetMessageFromMSGFile without calling Logon or setting the MAPIOBJECT property) as long as the address is a one-off SMTP address.


Bug fixes


•   Creating any Redemption object (such as RDOSession or SafeMailItem) under Outlook 2016 November 2018 update could crash if an older version of mso.dll was already loaded by the parent process, e.g. when running under an older (2010/2013) version of msaccess.exe or if an older Access OLEDB provider was loaded in the process address space prior to using Redemption.


•   Creating any Redemption object (such as RDOSession or SafeMailItem) under Windows 10 with no Outlook installed could cause a crash in mmgaclient.dll (Windows 10 bug).


•   RDOSession.GetArchiveMailbox did not use auto discover XML cached by RDOSession.CacheAutodisocverXml.


•   RDOSession.Stores.AddDelegateExchangeMailBoxStore required Outlook restart after a delegate mailbox was added under Outlook 2016 or 2019.


•   RDOMail.Delete failed to delete the message if the message was opened in the online mode (e.g. using MAPI_NO_CACHE flag) and the parent cached folder did not contain the message (e.g. if it was outside of the time range cached by the OST store).


•   MAPIUtils.HrArrayToString method could be slow for large arrays


•   RDOFolder2.Import method could be slow with large EML files if the Redemption MIME converter (olRfc822_Redemption) was used.


•   RDOMail.SaveAs created an MSG file with only the message body and recipients populated for some corrupted messages in PST stores.


•   Importing iCalendar (ICS) files using RDOAppointmentItem.Import or RDOFolder2.Import, if the meeting organizer was listed as both the organizer and as an attendee, the organizer was not marked as such in Outlook.


•   Accessing SafeRibbon.Controls collection under Outlook 2016/2019 sometimes raised "Could not convert variant of type (OleStr) into type (Int64)" exception.


•   When the ribbon was compacted under Outlook 2016/2019, SafeInspector.ActiveInlineResponseDiscard and ActiveInlineResponsePopOut actions were reversed  - ActiveInlineResponseDiscard was popping the inline response instead of discarding it, and ActiveInlineResponsePopOut was discarding the inline response instead of showing the inline response in a new inspector.



October 6, 2018



New features, bug fixes, Windows 10, Outlook 2019 (beta) and Outlook Centennial (Windows Store) compatibility


•   Added RDOFolder2.Import method. The method allows to import from a file, IStream COM interface, or from a variant array (of byte or of variant). All import formats supported by RDOMail.Import are supported by RDOFolder2.Import.  Since RDOMail.Import method signature cannot be changed to support an import source other than a file (a frequently requested Redemption feature), this method can be used instead.

The method allows to import iCal files with multiple events or vCard files with multiple contacts. For all other formats, a single new item is created. The method returns RDOItems collection with the newly created items. To retrieve RDOFolder2 interface, cast any RDOFolder object to RDOFolder2.

Set Session = CreateObject("Redemption.RDOSession")

Session.MAPIOBJECT = Application.Session.MAPIOBJECT

Set Folder = Session.GetDefaultFolder(olFolderCalendar)

Set items = Folder.Import("c:\temp\MultipleItems.ics", olICal)

For Each item In items

  debug.Print item.Subject



•   RDOMail.Import and Safe*Item.Import methods now support olTxt format (olRtf and olHTML formats were supported before). In case of the file based data, Import is an easier and more reliable option that setting the RTFBody, HTMLBody, or Body properties as the file contents would not have to be converted to a Unicode string first before setting the body properties.


•   Specifying "Recipients / To / CC /BCC" in the RDOItems.Find/Restrict/etc. SQL queries, only searched the PR_DISPLAY_NAME and PR_EMAIL_ADDRESS MAPI properties in the recipient table. The latest version will also match on the PR_SMTP_ADDRESS recipient property.


Bug fixes


•   Under Windows 10 October 2018 Update (1809), accessing any DateTime property resulted in the "System Error. Code: 18. There are no more files" exception when Redemption attempted to load the time zone definitions.


•   RDOSignature.ApplyTo erroneously copied the signature to the clipboard wiping out any existing clipboard content.


•   Accessing RDOSignature.HTMLBody property sometimes produced "No mapping for the Unicode character exists in the target multi-byte code page" exception.


•   Under Outlook Centennial (Windows Store), calling RDOContactItem.AddPicture, passing RDOAttachment object to the RDOMail.Attachments.Add method, or reading the RDOAttachment.FileSize property resulted in the "Interface not supported" exception.


•   Under Outlook Centennial (Windows Store),  RDOSession.LogonPstStore crashed the calling process due to a bug in the HrValidateIPMTree MAPI function,


•   Under Outlook Centennial (Windows Store), handling RDOItems or RDOFolders events could lead (after processing at least one event) to the MAPI system shutdown requiring application or mmgaserver.exe restart due to a bug in the ScCopyProps MAPI function.


•   Some MSG files produced by Redemption (RDOMail.SaveAs(..., olMsg)) were missing parts of the message body when displayed by Outlook even if RDOMail.Body returned correct data.


•   On some systems loading Redemption showed a message box with an error "Missing procedure entry point ShowBucketedString@8 could not be located"


•   RDOItems.Sort could not handle quoted property names in the DASL format (unquoted property names worked as expected).


•   RDOMail.Move failed to move the message if the message was opened in the online mode (e.g. using MAPI_NO_CACHE flag) and the parent cached folder did not contain the message (e.g. if it was outside of the time range cached by the OST store).


•   Importing some iCal files with multiple attendees, one of which contained an invalid ("invalid:nomail") email, import sometimes causes MAPI_E_INVALID_PARAMETER exception from IMessage::ModifyRecipients.


•   Importing MIME files with a plain text body only and double Unix-style line breaks (0x0D, 0x0D) using Redemption MIME converter (olRfc8222_Redemption) could corrupt the message body.




May 29, 2018



New features, bug fixes, Outlook Centennial (Windows App Store) compatibility


•   Outlook Object Model parity - RDOAttachments.Add now supports adding web-by-reference (RDOAttachment.Type == olByWebReference (7)) attachments. The Source parameter must be a valid http or https url and Type parameter must be olByWebReference.


•   Added new property - RDOSession.HeadersOnlyOnSlowConnection. Corresponds to "Send / Receive | Download | On Slow Connectiosn Download Only Headers" in the Outlook UI.

Highslide JS


•   RDOSession.ExchangeConnectionMode property can now be set (it was read-only previously). Not all rdoExchangeConnectionMode enum values are allowed: olCachedDisconnected (the same as setting the RDOSession.Offline property to true), olCachedConnectedHeaders, olCachedConnectedDrizzle, olCachedConnectedFull can be used (see the screenshot above)


•   Added RDORecipient.AddressType property. This property was added to discourage the use of the RDORecipient.AddressEntry.Type property - accessing RDORecipient.AddressEntry (which returns an instance of the RDOAddressEntry object) can be expensive, especially in the online mode.


•   RDOSelectFoldersDialog object (returned by RDOSession.PickFolder) icons were updated to match Outlook 2016 folder icons. When running under Outlook 2013 or older, old style icons are used to be consistent with the Outlook UI.

Highslide JS


Bug fixes


•   Under Outlook Centennial, retrieving items from the RDOFolder.Items collection failed (Error in PropCopyMore: MAPI_E_INVALID_PARAMETER) .


•   Under Outlook Centennial, RDOAddressEntry object returned from RDOSession.CurrentUser had all properties empty .


•   RDOStore.StoreKind property sometimes returned skEAS instead of skIMAP4 under Outlook Centennial.


•   RDOSession.GetSharedMailbox  failed under Outlook 2013 or older.


•   RDOSearchFolder.SearchCriteria.AsSQL raised an exception under the latest builds of Outlook 2016.


•   RDOSelectFoldersDialog object (returned from RDOSession.PickFolder) sorted the folders alphabetically, rather than in the order displayed by Outlook.


•   RDOMail.BodyFormat property returned olFormatPlain and RDOSignature.ApplyTo inserted plain text signature for the new messages (Body / HTMLBody / RtfBody properties never set)


•   Retrieving free/busy information failed under locales with a time separator other than ":".


•   No properties could be set on existing recurring recurring appointment exceptions (setting properties on new exceptions worked properly).


•   Setting RDORecurrencePattern.PatternEndDate property sometimes added one extra occurrence (as returned by the RDORecurrencePattern.Occurrences property).


•   Redemption MIME exporter sometimes corrupted Unicode characters in the message body when exporting MIME files when quoted-printable MIME encoding was used.


•   Redemption MIME importer did not import Categories and message flag if they were specified in an EML file.


•   Redemption MIME importer replaced Unicode characters with "?" in the display names of embedded message attachments.


•   Better RDOSession.GetSharedMailbox error handling - instead of raising a generic "Could not find the store DN" exception, the error now includes extra information that led to that error.


•   Setting RDOMail.HTMLBody property on a standalone MSG file returned from RDOSession.GetMessageFromMsgFIle / CreateMessageFromMsgFIle sometimes resulted in Outlook displaying the MSG file in plain text.


•   RDOMail.HTMLBody property returned garbage if the native HTML erroneously specified "unicode" as the content charset.


•   RDOAddressListSearch.GetResults raised MAPI_E_END_OF_SESSION exception when used for the very first time in a session under Outlook 2016.


•   Importing some malformed MSG files (RDOMail.Import(..., olMsg)) created by third-party software failed to import the message body.






February 19, 2018



New features and improvements


•   Added support for the Windows Store version of Outlook 2016 . Previous versions of Redemption could not find and load the MAPI system (which is installed in a different location and the executables have different file names)


•   Added RDOStore2.GetFolderFromPath method. Similar to the RDOSession.GetFolderFromPath method, but allows to open a folder by path on the per-store level. RDOStore2.GetFolderFromPath includes an optional parameter (CanCreate) that can be used to create the folders along the path if they do not already exist.. If the folder path includes the store name (prefixed with "\\"), it is ignored. This makes it possible to retrieve RDOFolder.FolderPath from a folder in one store and recreate the same path in another store.

RDOSession session = new RDOSession();


RDOStore store = session.Stores.DefaultStore;

RDOStore2 store2 = store as RDOStore2;

RDOFolder folder = store2.GetFolderFromPath(@"Inbox\Test folder", true);



•   Added  RDOExchangeMailboxStore.AutoDiscoverUrl / LastSyncTime (may not be present on all stores) / MAPIHTTPMailboxInternalUrl / MAPIHTTPMailboxExternalUrl / MAPIHTTPAddressbookInternalUrl / MAPIHTTPAddressbookExternalUrl properties.


•   Added RDORecurrencePattern.FirstDayOfWeek property - recurrence pattern specific first day of week (can be different from the local setting).


•   MAPITable.ExecSQL performance was greatly improved (especially against an online Exchange store). If a restriction was specified, the previous versions defaulted to using the MAPI equivalent of Find/FindNext retrieving one row at a time rather than using Restrict by default to retrieve multiple rows in a single call.  This was previously done to mitigate Exchange Server performance issues when the server cached the queries; newer versions of Exchange  handle restrictions much better now.


•   Added RDOSyncMessageItem.Fields[] and RDOSyncMessageItem.PropList properties that allow to access the list of property tags and their values provided by the ICS API  (especially if RDOFolderSynchronizer.IncludeSyncProperties was used to request extra properties) without opening the message using RDOSyncMessageItem.Item.


Bug fixes


•   RDOMail.HTMLBody property and saving messages in the HTML format produced corrupted text for some codepages.


•   Exporting messages in the MIME format using built-in Redemption MIME converter (RDOMail.SaveAs(..., olRfc822_Redemption)) sometimes corrupted Unicode characters HTML body in the exported MIME message if the code page specified in the HTML header did not match the actual data in the HTML body.


•   When accessing a read-only MSG files opened using RDOSession.GetMessageFromMsgFile, Redemption returned empty values for named MAPI properties accessed using RDOMail.Fields[] and for properties based on named MAPI properties (e.g. RDOAppointmentItem.Location).


•   When RDOMail object created on top of an MSG file was deleted or simply released while references to its child recipients or attachments were still alive, those references could cause an access violation later when the child objects were released (either explicitly or by the .Net Garbage Collector).


•   Opening a folder in the  online mode (using MAPI_NO_CACHE flag) sometimes caused its child messages (from the Items collection and Items event handlers) to return empty values for the named properties (such RDOMail.Mileage, RDOAppointmentItem.Start, etc.)


•   Redemption MIME import/export sometimes did not correctly handle recipient/sender display names with special characters (such as ", <, >, etc.)


•   Redemption MIME importer sometimes (if the code page was not explicitly specified) misidentified the message code page as UTF-7 if character sequences like "+1-" were present in the message body.


•   Redemption MIME importer was slow when converting large (10 Mb+) text (or text based) attachments using quoted-printable encoding.


•   RDOMail.ReplyRecipients collection sometimes mangled Unicode characters.


•   Setting RDOMail.ReplyRecipients collection to that from another message or passing RDOMail.ReplyRecipients collection to RDOAddressBook.ShowAddressBook could cause memory corruption or crash.


•   RDOExchangeAccount.User property under cached Office 365 profile sometimes returned RDOAddressEntry object with most fields blank.


•   RDOSession.GetSharedDefaultFolder sometimes caused an access violation instead of raising a meaningful COM exception when a name that cannot be resolved was passed as a parameter.


•   When saving HTML messages in the olHTML format (RDOMail.SaveAs), the date in the "Due By" header could be corrupted when running under a locale other than English.


•   Importing ICS files (RDOAppointmentItem.Import(..., olICal)) with a present but  empty ORGANIZER field could produce an exception.


•   When setting RDOMail.Sender and RDOMail.SentOnBehalfOf properties, PR_SenderSimpleDispName and PR_SentRepresentingSimpleDispName MAPI properties were not being set, sometimes resulting in OWA showing empty sender name.



October 4, 2017


This version is a hotfix for the problem introduced in version when Redemption defaulted to the Japanese language (see below).


Bug fixes

•   Instead of using the Outlook or system locale, Redemption defaulted to the Japanese language for its UI (RDOSession.PickFolder) and methods that required localizable stings (e.g. RDOMail.SaveAs(..., olTxt), RDOStore.ValidateIPMTree, etc.). This problem was version specific.


•   RDOSession.OutlookVersion property sometimes retrieved the version information from the MAPI system (olmapi32.dll) rather than outlook.exe.



October 1, 2017



New features and improvements


•   Added RDOFolderSynchronizer.IncludeSyncProperties collection that allows to specify which properties must be included by the sync, which can significantly reduce the network traffic during synchronization.


•   Added enumerator support (foreach) to the PropList collection returned by the MAPIProp.GetPropList property (most Redemption objects are derived from the MAPIProp object - RDOMail, RDOFolder, RDOAttachment, etc.)


•   Added RDOAddressBook. ResolveNameCheckOrder property (rdoResolveNameCheckOrder enum). Determines the order in which a name is resolved by the address book. Prior to multiple Exchange Server support in Outlook 2010, the order was always determined by the RDOAddressBook.SearchPath list. Starting with Outlook 2010,  the order can change based on the currently selected store in Outlook.




Bug fixes


•   RDOMail.HTMLBody and Safe*Item.HTMLBody properties sometimes returned HTML body with Unicode characters corrupted if the message code page did not match the code page specified in the HTML body header.


•   RDOSession.CurrentUser sometimes under cached Office 365 profile returned RDOAddressEntry object with most fields blank.


•   Setting most RDONickName properties corrupted the property values.


•   Outlook MIME converter (used by the olRfc822 and olRfc822_Outlook formats) sometimes produced as access violation when converting some Office 365 message stamped with a invalid property. Redemption now removes the invalid  properties before using the Outlook MIME converter (IConverterSession). Note that the Redemption MIME converter (olRfc822_Redemption) was not affected.


•   When retrieving autodicover XML, Redemption could hang in an infinite loop if one url was redirecting to another url redirecting to the first one (self-redirections were handled in the previous versions).


•   RDOEncryptedMessage.GetDecryptedMesage could not handle signed messages with the message class of IPM.NOTE.SMIME (instead of the expected IPM.NOTE.SMIME.MultipartSigned)


•   RDOSession.GetRDOObjectFromOutlookObject returned an error for some signed or encrypted Outlook messages with an invalid or missing certificate.


•   For certain recurring appointment exceptions, the same RDOException object was returned for multiple items from the RDOExceptions collection.


•   For some nicknames, RDONickName.SMTPAddress property returned an empty string.


•   When Outlook 2007 was installed prior to installing Outlook 2016, Redemption sometimes loaded olmapi32.dll instead of msmapi32.dll resulting in an application crash.


•   Safe*Item's Attachment object did not support OneDrive (Type == olOneDrive)  attachments in Attachment.SaveAsFile method.  RDOAttachment.SaveAsFile functioned properly.


•   Redemption MIME converter exported recipients differently from the Outlook converter (IConverterSession) when converting an Outlook NDR to a MIME file.


•   Redemption MIME sometimes failed to import MIME headers  when malformed MIME files with mixed (0x0D, 0x0A) and (0x0D) line breaks were processed


•   RDOSession.GetSharedMailbox sometimes returned the primary mailbox in the profile instead of the specified delegate mailbox.


•   RDOSession.PickFolder dialog box was displayed in English for the Japanese and Chinese versions of Office.


•   ProfMan library: Profile.OpenProfileSection did not raise an exception if an invalid GUID was specified and instead created  a new profile section with a random GUID. Profile.OpenProfileSection now also allows to pass a hex sting representing the GUID (such as a hex string returned by RDOAccount.Fields[] for a PT_BINARY property or a hex string returned by MAPIUtils.HrArrayToString)


•   Incremental Change Synchronization API (ICS): RDOSyncFolderItem.Item property raised MAPI_E_NOT_FOUND exception for the folders that were created in the online store but not yet downloaded to the cached local store.


•   RDOAttachment.HIdden property was always true for the attachments of messages returned from the RDOEncryptedMessage.GetDecryptedMessage.method.




May 16, 2017

Version - a hot fix for the out-of-memory problem when accessing a large number of appointments.


•   Accessing a large number of the RDOAppointmentItem objects was slow and could cause out-of-memory errors in 32 bit applications.


•   Redemption could not handle cached Outlook autodiscover XML that only contained a redirect to another url.




May 07, 2017



New features and improvements


•   Added RDOAddressBook.AllRooms and RDOExchangeAccount.AllRooms properties that returns an instance of the RDOAddressList object representing the Exchange "All Rooms" address book container


set Session = CreateObject("Redemption.RDOSession")
Session.MAPIOBJECT = Application.Session.MAPIOBJECT
set ABDialog = Session.GetSelectNamesDialog
ABDialog.InitialAddressList = Session.AddressBook.AllRooms
ABDialog.AllowMultipleSelection = false
ABDialog.Caption = "Select a room"
ABDialog.ShowOnlyInitialAddressList = true
ABDialog.ForceResolution = true
set roomRecipients = ABDialog.Display(true)


•   Added RDOTimezone.NameLocalized / StandardDesignationLocalized / DaylightDesignationLocalized properties that contain time zone names in the current Windows locale.


•   Added two new values to the rdoDefaultFolders enumeration used by RDOSession.GetDefaultFolder / RDOStore.GetDefaultFolder  - olFolderArchive (corresponds to the Archive default folder in Exchange mailboxes) and olFolderAllItemsSearch (corresponds to the "All Items" search folder containing all items in the given Exchange mailbox).


•    Faster MIME import for messages with large number of recipients (hundreds or thousands)


•    RDOSession.GetRDOObjectFromOutlookObject  now supports the account object - given an Account Outlook object, it will return the matching RDOAccount object.


•    RDOAttachments.Add method can now take another RDOAttachment object as a parameter


Bug fixes


•    Date/time properties for the various Redemption objects (such as RDOMail,. RDOAppointmentItem, etc.) sometimes returned wrong values for the dates in the past if the Windows language was other than English - Redemption failed to locate the correct list of dynamic DSTs based on the localized time zone name.

This issue also caused RDOSession.Timezones.CurrentTimeZone property to return null on non-English versions of Windows.


•    RDOSession.GetAutoDiscoverXML would sometimes fail with an error like "CheckSynchronize called from thread xyz, which is NOT the main thread".  The same problem sometimes caused GetSharedMailbox to fail if used on a secondary thread.


•    RDOAddressBook.GetAddressEntryFromStoreItem  sometimes produced an access violation in the 64 bit version of Redemption.


•    Recurring appointments created in a local time zone different from the appointment time zone (RDOAppointmentItem.StartTimezone / EndTimezone) were sometimes missing first or last occurrence.


•    Signed messages in the EML format imported using Redemption MIME converter (olRfc822_Redemption) created an attachment with an invalid attachment type (0)


•    RDOMail.PrintOut raised a generic MAPI_E_INVALID_PARAM error instead of an exception informing the caller that there is no active session for the messages with no active MAPI session (e.g. messages returned by RDOSession.CreateMessageFromMsgFile / GetMessageFromMsgFile ).


•    Setting the RDORecurrencePattern.PatternEndDate property sometimes produced invalid results.


•    Calling RDOSession.LogonHostedExchangeMailbox under Outlook 2016 with no credentials (if the user is running under the identity of the domain user who owns the specified mailbox) raised a MAPI_E_LOGON_FAILED error


•    RDORecipients.Add / AddEx sometimes corrupted Unicode characters under the Hebrew locale


•    Redemption sometimes failed to use autodiscover XML already cached by Outlook.


•    RDOFolder2.GetActivitiesForTimeRange failed to return some activities.


•    RDOSession.PickFolder would not allow to select the top level folder of any store (version 5.12 specific).


•    Importing iCal files using (RDOAppointmentItem.Import(..., olICal) failed to import X-MS-OLK-SENDER field if it was different from the ORGANIZER field.


•    Could not read RDOAppointmentItem.Start /End /AllDay properties for the private appointments in delegate mailboxes.


•    Delay (several seconds) when calling RDOStore.StoreAccount when more than one version of Outlook is installed


•    Could not load MAPI system under Outlook 2013 when running under a Local System account (e.g. in a Windows service)


•    Redemption MIME importer could not correctly process some RFC2231 formatted attachment names.


•    For the Office 365 mailboxes upgraded from accounts, the MAPI session created by LogonHostedExchangeMailbox sometimes hanged when resolving message recipients.


•    RDOAppointmentItem.GlobalAppointmentID  property sometimes (depending on the start date and the time zone) returned different values before and after the instance was turned into an exception.


•    Setting the RDOAppointmentItem.HTMLBody / RtfBody properties on an instance of a recurring appointment created the exception, but set the body on the master appointment instead of the specified occurrence.



January 09, 2017


Miscellaneous and Outlook 2013 / 2016 / Click-To-Run specific fixes.


New features and improvements


•    Redemption MIME converter could not import RFC2231 formatted attachments with wrapped long file names.  Note that Outlook (and Outlook MIME converter invoked when olRFC822_Outlook format is specified) does not handle attachments like that.  To make sure Redemption converter is used, specify the olRFC822_Redemption format when calling RDOMail.Import.


Bug fixes


•    RDONicknames.Add created duplicate entries and sometimes caused heap corruption resulting in a crash.


•    RDOSignature.ApplyTo did not copy the HTML styles from the signature to the specified message resulting in the signature text with a wrong font .


•    RDOSignature.ApplyTo sometimes missed images that had special characters or were located in custom folders.


•    RDOSignature.ApplyTo corrupted the resulting message text if the signature contained extended Unicode characters and the original message body did not .


•    Saving in the olHTMLEmbeddedImages format (RDOMail.SaveAs, the images in the HTML body are saved inside the <img> HTML tags) leaked memory and could result in the application running out of memory if called repeatedly.


•    RDOSession.LogonHostedExchangeMailbox / GetAutodiscoverXml / etc. did not use HTTP proxy settings configured in the Internet Explorer.


•    RDOAddressEntry object returned from RDOSession.CurrentUser sometimes returned empty strings for most of its properties for some on-prem Exchange servers.


•    Saving a recurring appointment with exceptions created on top of an MSG file (RDOSession.GetMessageFromMsgFile)) in the ICS format (RDOAppointmentItem.SaveAs(..., olICal) produced "Error in IMessage.OpenAttach: MAPI_E_NO_ACCESS" exception.


•    Saving an appointment in the MIME format (RDOAppointmentItem.SaveAs(..., olRfc822)) produced the "The parameter is incorrect" exception if the appointment was in a time zone that could not be recognized locally.


•    RDOSession.Stores.AddDelegateExchangeMailBoxStore did not work with RPC-over-HTTP and MAPI-over-HTTP stores.


•    Outlook Object Model compatibility fix: for the MAPI_P1 recipients, RDORecipient.Type returned 0 instead of MAPI_P1 (0x10000000).


•    Calling RDOCategories.Add before accessing any other RDOCategories properties or methods caused RDOCategories object to skip populating the default categories if no categories were present in the store.


•    Importing iCal, vTodo, and vCard files (RDOMail.Import) with UTT-8 encoded data under Japanese / Chinese / Korean locales sometimes resulted in corrupted data.


•    Importing some ICS files (RDOMail.Import) produced by iPhone sometimes generated '$/R' is not a valid integer value exception.


•    Setting RDOContactItem.Email1Address / Email2Address / Email3Address to an empty string sometimes produced invalid data


•    Several Redemption methods that allow to pass HWND of the parent window (such as RDOAddressBook.ResolveName, RDOMail.Display, etc.) could not handle COM variants produced by .Net and could not use  Explorer or Inspector Outlook objects passed as parameters.


•    vCard files created by RDOContactItem.SaveAs(..., olVCard) encoded line returns in quoted-printable values as "\n" instead of of "=0D=0A".


•    Folder selection dialog (RDOSession.PickFolder) could display an access violation error when expanding a folder that only contained subfolders inaccessible to the current user.


•    Folder selection dialog (RDOSession.PickFolder) sometimes came up with an empty folder tree if there was an EAS store in the profile.


•    RDOSesssion.AddDelegateExchangeMailboxStore raised an exception if autodiscover XML could not be retrieved instead of falling back to the pre RPC-over-HTTP logic.


•    Importing EML (MIME) files using Redemption MIME converter (olRfc822_Redemption) placed all MIME headers into the message body if the message did not contain any MIME parts .and did not contain a terminating empty line.


•    SafeInspector.Text and SelText properties returned an error if the inspector had a custom form region with a browser control.


•    SafeInspector.WordEditor returned null instead of raising an exception if there was an exception returned by the Word editor.


•    RDOTaskItem.MarkComplete / MarkCompleteEx did not remove the reminder from the completed instance of a recurring task and did not advance the reminder to the next instance for the recurring tasks.


•    Setting RDOContactItem.Email1EntryID / Email2EntryID / Email3EntryID to a value with a Unicode SMTP address, produced ???? for the email display name.


•    Setting RDORecurencePattern.Duration / StartTime / EndTime properties instead of RDOAppointmentItem.Duration / Start / End properties sometimes produced appointments with unexpected duration/start/end properties.


•    RDOException.OriginalDate returned wrong value for all-day appointments.


•    RDORecipient.SMTPAddress raised an exception instead of returning an empty string if there was no active MAPI session available (e.g. for the messages returned by RDOSession.GetMessageFromMsgFile which does not require a call to RDOSession.Logon or setting the RDOSession.MAPIOBJECT property).


•    RDOAppointmentItem.Attachments collection for the RDOAppointmentItem objects representing exceptions or instances of recurring appointments sometimes returned attachments from the master appointment containing recurrence exceptions.


•    RDOMail.BodyFormat property  sometimes returned olFormatPlain for RTF (olFormatRichText) emails.


•    RDOMail.BodyFormat property sometimes returned olFormatPlain for some HTML messages.




May 07, 2016



More Outlook 2016 and Click-To-Run fixes and tweaks as well as new features.


New features and improvements


•    Creating. modifying, and saving new RDOContactItem, RDOAppointmenttItem and RDOTaskItem objects is now much faster (3-5 times) in the online Exchange mailboxes.



Inspector inspector = application.ActiveInspector();

MailItem mailItem = (MailItem)inspector.CurrentItem;

if (string.IsNullOrEmpty(mailItem.Subject))


    SafeInspector safeInspector = new Redemption.SafeInspector();

    safeInspector.Item = inspector;

    MessageBox.Show("The message must have a subject");




•    Added RDOSession.MAPIVersion and RDOSession.MAPIDllFileName properties. OutlookVersion and Version properties were implemented previously.


•    Added RDOMail.MarkAsTask method (marks the item as a task and assigns a task interval for the object).


•    Added RDOExchangeMailboxStore.MonthsToKeepOffline and DaysToKeepOffline properties.


•    Support for the OneDrive attachments in Outlook 2016 - added olOneDrive value to the rdoAttachmentType enum used by the RDOAttachment.Type property. Note that OneDrive attachments saved by the RDOAttachment.SaveAsFile method are always saved as link files with the URL extension (even if a different extension is specified) for the consistency with the Outlook Object Model.


•    cpEnterprise value was added to the rdoCredentialPersist enumeration (used by RDOCredentials.Add).


•    Methods requiring EWS or autodiscover calls to an Exchange server (RDOSession.GetSharedMailbox, (RDOSession.GetAutodiscovreXml, etc.) can now use cached Outlook credentials saved when the user checks the "Remember my credentials" checkbox in the authentication prompt dialog in Outlook.


•    RDOSession.PickFolder method and RDOSelectFoldersDialog object are now much faster in the profiles with a large number of stores, especially delegate Exchange mailboxes (the stores are no longer opened when the dialog is displayed).



Bug fixes


•    Outlook 2016 installed in the click-to-run mode (C2R) sometimes caused Redemption to fail to load the MAPI system (missing api-ms-win-crt-string-l1-1-0.dll file).


•    RDOAppointmenttItem.Respond sometimes caused a hard crash in ntdll.dll.


•    November 19, 2015, update for Outlook 2013 (KB2975838) caused Redemption to crash when calling RDOSession.Logon / LogonExchangeMailbox / LogonHostedExchangeMailbox /LogonPstStore.


•    RDOMail.SaveAs(..., olMsg) under Exchange 2016 saved RTF messages with embedded OLE attachments were sometimes created in a corrupted state.


•    Setting a MAPI property using SafeRecipient.Fields sometimes caused application crash. The RDORecipient object functioned properly.


•    RDOSearch.Delete raised 0x8000FFFF (Catastrophic failure) exception.


•    RDOSession.CurrentUser.Name returned "?"s for the Unicode characters under POP3/SMTP and IMAP4/SMTP accounts (Outlook bug). Exchange accounts behaved properly.


•    RDOAppointmenttItem.Send sometimes produced meeting requests with no body under the standalone version of MAPI.


•    Installing the 64 bit version of Redemption (redemption64.dll) using Windows Installer (MsiExec) sometimes caused "Redemption64.dll failed to register. HRESULT -1066598274. Contact your support personnel" error to be displayed,.


•    RDOFolder.OnMessageCreated event did not fire when a new message was created in the folder.


•    RDOFolder.OnMessageCreated  event fired when a message was deleted instead of the RDOFolder.OnMessageDeleted event (which never fired).


•    RDOAccount.ReplySignature and RDOAccount.NewMessageSignature returned an error if the signature was reset to (none) in Outlook options.


•    RDOSession.GetArchiveMailbox failed for the archive mailboxes in a different domain (e.g. an on-premise primary mailbox and an Office 365 hosted archive mailbox).


•    Importing EML (MIME) files using Redemption MIME converter (olRfc822_Redemption) sometimes hanged for the EML files with only HTML (no plain text) message body.


•    RDOOutOfOfficeAssistant ignored explicitly specified credentials (e.g.  by the RDOAdrressEntry.GetOutOfOfficeAssistant method) when the settings were saved.


•    Setting the RDOOutOfOfficeAssistant.OutOfOffice property would force the OOF state to be "Enabled" instead of "Scheduled" even if the State property was explicitly set.


•    RDOAccount.AccountCategories property never returned the acStore (1) bit. Instead, acMail (2) bit was always returned.


•    RDOAppointmenttItem.Parent property for the recurrence instance appointments returned by RDOFolder2.GetActivitiesForTimeRange or RDORecurrencePattern.Item pointed to the parent folder instead of the parent (master) appointment.  This bug was introduced in version 5.10.


•    Calling RDOAppointmenttItem.Save on a recurrence instance returned by RDOFolder2.GetActivitiesForTimeRange or RDORecurrencePattern.Item and deleted using RDOAppointmenttItem.Delete caused both deleted and modified exceptions to be created resulting in the recurrence instance staying intact.


•    RDORecurrencePattern.GetOccurence sometimes raised "The activity does not occur on <date>" exception for the last instance of a recurring sequence depending on the end time and the time zone.




October 17, 2015



Hotfix: version released on October 5, 2015, created, upon registering with regsvr32.exe, an empty registry key (HKCR\TypeLib\{2D5E2D34-BED5-4B9F-9793-A31E26E6806E}\5.10) that can prevent .Net run-time from being able to create or use Redemption objects (TYPE_E_LIBNOTREGISTERED). The updated version will not create that key and will delete the erroneous key if it exists.


Bug fixes


•    When registered with regsvr32.exe, version created an empty registry key HKCR\TypeLib\{2D5E2D34-BED5-4B9F-9793-A31E26E6806E}\5.10 sometimes causing .Net to raise a TYPE_E_LIBNOTREGISTERED exception. The updated version will not create that key and will remove it if present when the dll is installed using regsvr32.exe.

•    RDOMail.Delete(dfMoveToDeletedItems) sometimes silently failed on IMAP4 stores without raising any errors.

•    RDOMail.Reply / ReplyAll / Forward sometimes garbled new message headers under locale other than English.

•    RDOMail.Reply / ReplyAll / Forward always created localized headers even if "Options | Advanced | Use English for message headers..." in Outlook was set.

•    RDOMailboxDelegates.Save sometimes raised HTTP error 500.





October 05, 2015



This release focuses on Outlook 2016 support (released September 22, 2015).

Note: older versions of Redemption would cause a crash in the Outlook 2016 MAPI marshalling system when a MAPI object is marshaled out-of-proc, e.g.  when setting the RDOSession.MAPIOBJECT property or when using SafeMailItem or MAPITable objects.


New features


•    RDOSession.LogonHostedExchangeMailbox now fully supports Outlook 2016.


•    Added RDOSession.UseEWSImpersonation property. If set to true, forces Redemption to add the ExchangeImpersonation header when making EWS calls (e.g. when retrieving free/busy range or mail tips).


•    Added RDOMail.SetProps method that allows to set multiple properties in a single call (RDOMail.GetProps to read multiple properties was added in version 5.0)

 dim tags(3)
dim values(3)

'OOM property name
tags(0) = "Subject" 'PR_SUBJECT_W
'DASL property names
'integer property tag
tags(3) = &H1000001F 'PR_BODY_W

values(0) = "Test subject"
values(1) = #9/1/2015 2:00PM# 'This is UTC
values(2) = #9/1/2015 3:00PM# 'This is UTC
values(3) = "Test body"

set Session = CreateObject("Redemption.RDOSession")
Session.MAPIOBJECT = Application.Session.MAPIOBJECT
set Folder = Session.GetDefaultFolder(olFolderDrafts)
set Msg = Folder.Items.Add
Msg.SetProps tags, values


Bug fixes

•   MAPI marshalling in Outlook 2016 was broken resulting in a crash when setting the RDOSession.MAPIOBJECT property to Namespace.MAPIOBJECT from Outlook or when using SafeMailItem or MAPITable objects in a process other than outlook.exe.


•   RDOSession.LogonHostedExchangeMailbox did not work under Outlook 2016.


•   The order of the autodiscover probes in the Active Directory was changed to test for the most often used configurations first thus eliminating the timeouts when attempting to connect to the non-existent LDAP servers.


•   RDOSignatures collection sometimes could not find any signatures in the versions of Outlook with a locale other than English


•   Messages created using RDOMail.Reply / ReplyAll / Forward sometimes corrupted Unicode recipient names.


•   Importing MIME messages with TNEF attachments (such as those created by the Exchange server) using RDOMail.Import and the built-in Redemption converter (olRfc822_Redemption) imported the messages in the plain text format


•   Importing MSG files in the RTF format using RDOMail.Import (.., olMsg) turned RTF messages into HTML messages.


•   Importing vCard files using RDOMail.Import (.., olVCard) did not import addresses for the vCard files with field grouping (e.g. item1.ADR - some Apple products create vCard files like that).


•   Exporting messages in the iCalendar format using built-in Redemption MIME converter (RDOMail.SaveAs(..., olICal)) did not export embedded message or OLE attachments. Note that the Outlook Object Model does not export such attachments.


•   Exporting messages in the MIME format using built-in Redemption MIME converter (RDOMail.SaveAs(..., olRfc822_Redemption)) sometimes corrupted Unicode names in the Reply-To MIME header.


•   Exporting vCard files using RDOMail.SaveAs (.., olVCard) sometimes did not correctly export the business address. 


•   RDOSelectFoldersDialog dialog did not update the values of the Left, Top, Width, Height properties during and after the folder selection dialog was shown.


•   Importing iCalendar (olICal) or MIME (olRfc822_Redemption) with a calendar/text MIME part raised "End time must be greater than the start time" exception instead of defaulting to a duration of 15 minutes for appointments with the (invalid) end time less than the start time.


•   RDOAddressEntry.GetFreeBusy did not respect the value of the RDOSession.SkipAutodiscoverLookupInAD property


•   RDOAttachment.SaveAsFile method could not save embedded message attachments deeper than 14 levels.


•   Customized versions of Redemption.dll did not use the custom type library name specified in customize.exe.


•   RDOEncryptedMessage.GetDecryptedMessage sometimes raised MAPI_E_NO_ACCESS exception for the encrypted messages in one of the Public Folders store.



June 25, 2015



This release focuses on the upcoming Outlook 2016 support as well as performance improvements, especially when connected to a hosted remote online Exchange store.


New features


•    RDOMail and the objects derived from it (RDOContactItem, RDOAppointmentItem, RDOTaskItem, etc) were revamped to minimize the number of RPC calls made when an item is created, modified, accessed or saved. In some cases, the number of RPC calls was cut down by a factor of 10, resulting in a greatly increased performance under an online Exchange store.


•   Setting RDOMail.To / CC / BCC properties was slow for a large number of recipients. Version 5.9 speeds up setting these properties by up to a factor of 100 when setting hundreds of recipients.


•    Improved MAPI event handling (RDOMail, RDOFolder, RDOStore, RDOItems, RDOFolders events). In the older versions, when a MAPI notification was received, Redemption would switch to the main thread (where the corresponding object was created) using SendMessage Windows API function, thus blocking the MAPI notification thread until the main thread finished processing the event. This degraded the performance, caused some events to be skipped, and sometimes caused hangs when the IMAP4 provider was used. The newest version of Redemption queues the notifications internally and returns immediately without blocking the MAPI notifications thread. The notifications are processed later (the order of events is preserved) when the main thread is idle.


•    Added RDOAddressEntry.GetMailTips method that allows to retrieve Out-Of-Office text, max message size, etc. for an Exchange mailbox. See RDOMailTips object for more information.

set Session = CreateObject("Redemption.RDOSession")

Session.MAPIOBJECT = Application.Session.MAPIOBJECT

Session.SkipAutodiscoverLookupInAD = true

set AdrEntry = Session.AddressBook.ResolveName("user@domain.demo")

set mailTips = AdrEntry.GetMailTips("me@domain.demo", "<My Password>") 'optional authentication parameters for EWS

MsgBox mailTips.MaxMessageSize   


•    Added RDOAddressEntry.GetOutOfOfficeAssistant method that allows to retrieve Out-Of-Office settings for an Exchange mailbox. OOF settings were previously implemented only through RDOExchangeMailboxStore.OutOfOfficeAssistant property, which required to open the mailbox first. Note that RDOAddressEntry.GetOutOfOfficeAssistant (unlike RDOAddressEntry.GetMailTips) requires impersonation privileges.

set Session = CreateObject("Redemption.RDOSession")

Session.MAPIOBJECT = Application.Session.MAPIOBJECT

Session.SkipAutodiscoverLookupInAD = true

set AdrrEntry = Session.AddressBook.ResolveName("user@domain.demo")

set oofSettings = AdrrEntry.GetOutOfOfficeAssistant("me@domain.demo", "<My Password>") 'optional authentication parameters for EWS

MsgBox oofSettings.StartTime     


•    Added RDOSession.SkipAutodiscoverLookupInAD property. Normally, Redemption methods that require autodiscover XML (such as LogonHostedExchangeMailbox, GetSharedMailbox, free/busy methods, etc.) look (each in a separate thread) for the autodiscover XML in a few predetermined HTTP locations with a timeout of 5 seconds. A lookup in the Active Directory however, especially if the remote server cannot be contacted through LDAP, can take a long time to time out. Set SkipAutodiscoverLookupInAD property to true if you are connecting to a hosted Exchange server. Leave it as false if you are connecting to an on-premises Exchange serer that does not publish autodiscover through HTTP.


•    Importing iCal files (RDOAppointmentItem.Impor(..., olICal) is now much faster for the appointments with a large (>100) list of attendees as attendees are now added in a single call.


•    Added RDORecipient.SMTPAddress property - jumps through a few hoops to retrieve the SMTP address while trying to avoid opening the underlying address entry. Similar to RDOAddressEntry.SMTPAddress, but attempts to retrieve the data from the message recipient table avoiding expensive calls to open the underlying address book object.


set Session = CreateObject("Redemption.RDOSession")

Session.MAPIOBJECT = Application.Session.MAPIOBJECT

set Item = Session.GetMessageFromID(Application.ActiveExplorer.Selection(1).EntryID)

for each Recip in Item.Recipients

    Debug.Print Recip.SMTPAddress



•    Added RDOAddressBook.ExchangeAddressToEntryId method. It allows to open and use address entries hidden from GAL. E.g. you can read the legacyDN attribute from the Active Directory and use it to call RDOAddressBook.ExchangeAddressToEntryId, which can then be used to open the GAL address entry (RDOSession.GetAddressEntryFromId) even if it is hidden, and pass it to RDOSession.GetSharedMailbox.


set Session = CreateObject("Redemption.RDOSession")

Session.MAPIOBJECT = Application.Session.MAPIOBJECT


set addressEntry = Session.GetAddressEntryFromId(userEntryId)

set delegateStore = Session.GetSharedMailbox(addressEntry)

MsgBox delegateStore.GetDefaultFolder(olFolderInbox).Items.Count


Bug fixes


•   Loading Redemption under Outlook 2016 (when running outside of the outlook.exe process space) displayed the "The operating system is not presently configured to run this application" message box. All Redemption  objects were unusable.


•   RDOFolder2..GetActivitiesForTimeRange would always skip the last occurrence of recurring appointments for the time zones east of Greenwich.


•   RDOMail.Print would hang if used on a secondary thread that does not run the Windows message pump (GetMessage / TranslateMessage / DispatchMessage).


•   RDOUserProperty.Delete raised an error (Access violation) in the 64 bit version of Redemption (32 bit version functioned properly).


•   Reading the RDOMail.HTMLBody hanged for some HTML messages.


•   RDOStores.UnwrapStore always returned the original store passed as the parameter. This problem was specific to version 5.8.


•   Creating appointments (RDOAppointment object) that end at midnight UTC sometimes produced invalid appointments with the end time earlier than the start time.


•   RDOContactItems.Birthday property behavior was inconsistent with the Outlook Object Model - if both PidLidBirthdayLocal and PidTagBirthday were present and contained different values, OOM returned PidTagBirthday while Redemption preferred PidLidBirthdayLocal.


•   RDOAppointment object sometimes saved recurrence pattern with the pattern start and end dates one day off.


•   VCF (vCard) files created by Redemption (RDOContactItem.SaveAs(..., olVCard)) did not specify the code page for the Western European languages.


•   VCF (vCard) files created by Redemption (RDOContactItem.SaveAs(..., olVCard)) did not did not include the contact's picture if the contact was retrieved from an MSG file (RDOSession.GetMessageFromMsgFile).


•   RDOEncryptedMessage.GetDecryptedMessage raised "Not logged in" exception if the encrypted message was opened using RDOSession.GetMessageFromMsgFile without calling RDOSession.Logon. Signed messages function properly.


•   MAPIUtils.HrSetOneProp and Safe*Item.Fields[] etc. "dirtied" the underlying Outlook object by resetting the Subject property, which resulted in Outlook changing the ConversationIndex property. This version resets the MessageClass property, which does not seem to cause any side-effects.


•   Redemption did not use locally cached autodiscover XML when PreferLocalXML registry value was set .


•   RDOMail.Fields() did not understand some DASL property names in the urn:schemas:contacts.* namespace (such as urn:schemas:contacts:mailingpostaladdress).


•   RDOMail.Fields() did not decode "%" encoded DASL property names (e.g.{00020329-0000-0000-C000-000000000046}/Test%20Name).


•   RDOSession.GetDefaultFolder(olFolderSentItems) sometimes raised an error when used on a secondary thread.


•   RDOSignature.Apply sometimes truncated the signature


•   RDOSelectFoldersDialog disabled the Ok button if both AllowMultipleSelection and ContainerClass were set and the user select the root store folder.


•   Exporting messages with an empty body in the MIME format using built-in Redemption MIME converter (RDOMail.SaveAs(..., olRfc822_Redemption)) sometimes hanged.


•   Exporting messages with a large (~100Mb) embedded messages attachments in the MIME format in 32 bit using built-in Redemption MIME converter (RDOMail.SaveAs(..., olRfc822_Redemption)) sometimes raised out-of-memory error.


•   Accessing RDOAppointmentItem.End property for the exceptional appointments returned from the RDOException.Item property sometimes crashed the calling process with a stack overflow.


•   RDOMail.SaveAs(.., olRfc822_Redemption) raised "Error in Storage.OpenStream: STG_E_FILENOTFOUND" for some RTF formatted messages.


•   RDOMail.SaveAs(.., olRfc822_Redemption) sometimes corrupted sender and recipient names when saving in the Korean, Japanese, or Chinese code pages (other codepages including UTF-8 were not affected).


•   RDOMail.SaveAs(.., olRfc822_Redemption) raised E_FAIL exception for the contacts (IPM.Contact) if there was no active MAPI session (e.g. RDOSession.Logon was not called and a message was opened using RDOsession.GetMessageFromMsgFile).


•   RDOSearchFolder.SearchCriteria.AsSQL returned an empty string for brand new search folders before RDOSearchFolder.Start was called even if RDOSearchFolder.SearchCriteria.AsSQL was explicitly set before.


•   RDOAppointmentItem.Import(.., olICal) did not set the Organizer / Sender / SentOnBehalfOf properties.


•   RDOStore.ValidateIPMTree under German locate named "Sent Items" folder "Gesendete Objekte" instead of "Gesendete Elemente" used by Outlook 2010 and newer.


•   Importing MIME messages using RDOMail.Import and the built-in Redemption converter (olRfc822_Redemption) imported the p7m attachment for the signed or encrypted messages twice .


•   RDOMail.HTMLBody property was slow in 64 bit for the plain text messages with a large body and a large number of characters that must be HTML-encoded (such as <, >, &).


•   When setting RDOMail.To / CC / BCC properties, Redemption would add everything following a double semicolon (;;) as a single recipient.


•   RDOIMAPAccount.SaveSentMessageFolder sometimes returned the profile's default Sent Items folder rather than the IMAP4 store's folder.







New features


•    Added RDORecipients.AddMultiple method. Adding recipients one at a time can severely degrade the performance as the time it takes to add a single recipient is proportional to the number of existing recipients in a message. RDORecipients.AddMultiple allows to add  hundreds of recipients in a single call with a performance improvement on the order of 100. RDORecipients.AddMultiple takes an array of string, RDORecipient, RDOAddressEntry, RDOContactItem or RDODistListItem objects..


dim Recips(2)

Recips(0) = ""

Recips(1) = ""

Recips(2) = ""

set Session = CreateObject("Redemption.RDOSession")

Session.MAPIOBJECT = Application.Session.MAPIOBJECT

set Contacts = Session.GetDefaultFolder(olFolderContacts)

set Drafts = Session.GetDefaultFolder(olFolderDrafts)

set Msg = Drafts.Items.Add

Msg.Recipients.AddMultiple(Recips. olTo)


Msg.Subject = "test"



•    Added RDOAddressBook.GetAddressEntryFromStoreItem. Returns an instance of the RDOAddressEntry object from an RDOContactItem or RDODistListItem object. This is the counterpart of the GetContact and GetDistList methods implemented by the RDOAddressEntry object.


•    Added SafeExplorer.ActiveInlineResponseDiscard and SafeExplorer.ActiveInlineResponsePopOut methods. Note that ActiveInlineResponsePopOut  functionality is not exposed by the Outlook Object Model at all, and MailItem.Close cannot be used for the inline responses returned by the Explorer.ActiveInlineResponse property.


set sExplorer = CreateObject("Redemption.SafeExplorer")

sExplorer.Item = Application.ActiveExplorer



•    Added RDOSession.Signatures collection that allows to read, create, and modify Outlook signatures. See RDOSignatures and RDOSignature objects for more information.


set Session = CreateObject("Redemption.RDOSession")

Session.MAPIOBJECT = Application.Session.MAPIOBJECT

for each Signature in Session.Signatures

  Debug.Print Signature.Name



•    Added RDOAccount.ReplySignature and RDOAccount.NewMessageSignature properties.


set Session = CreateObject("Redemption.RDOSession")

Session.MAPIOBJECT = Application.Session.MAPIOBJECT

set Drafts = Session.GetDefaultFolder(olFolderDrafts)

set Msg = Drafts.Items.Add

Msg.To = ""

Msg.Subject = "testing signatures"

Msg.HTMLBody = "<html><body>some <b>bold</b> message text</body></html>"

set Account = Session.Accounts.GetOrder(2).Item(1) 'first mail account

if Not (Account Is Nothing) Then

  set Signature = Account.NewMessageSignature

  if Not (Signature Is Nothing) Then

    Signature.ApplyTo Msg, false 'apply at the bottom

  End If

End If



•    Added RDOExchangeMailboxStore.GetOwaNicknames property that exposes Exchange 2010 nicknames (Exchange 2013 uses the same nicknames list as Outlook). The current version of Redemption provides read-only access to the OWA nicknames.


•    Added RDOCalendarOptions.TimeZone / WorkDays / WorkDayStart / WorkDayEnd properties. RDOCalendarOptions object can be accessed using the RDOExchangeMailbox.CalendarOptions property.


•    Added RDOSession.MAPIFormMgr property (returns RDOMAPIFormMgr object) that exposes MAPI forms available in the current MAPI session. See RDOMAPIFormMgr, RDOMAPIFormContainer and RDOMAPIFormInfo objects for more details.


set Session = CreateObject("Redemption.RDOSession")

Session.MAPIOBJECT = Application.Session.MAPIOBJECT

set PersonaFormContainer = Session.MAPIFormMgr.OpenLocalFormContainer

for each FormInfo in PersonaFormContainer

  Debug.Print FormInfo.DisplayName



•    Added RDOFolder2.Rules property. Exchange server rules  are already exposed on the store level (stored in the store's Inbox folder) through the RDOExchangeMailboxStore.Rules property. RDOFolder2.Rules adds support for rules on the folder level to support the Public Folders store, where rules can be set on any mail enabled folder.


•    Added RDOSession.CacheAutodiscoverXml and RDOSession.GetAutodiscoverXml methods that allow to cache autodiscover XML instead of  retrieving it each time it is needed. This allows to speed up Redemption methods that require  autodiscover, such as RDOSession.LogonHostedExchangeMailbox, RDOSession.GetArchiveMailbox, , RDOSession.GetSharedMailbox, RDOOutOfOfficeAssistant,


•    Redemption now retrieves autodiscover XML information from the Outlook cache (if available) first before attempting to download it from a remote server.


•    Exposed RDOAccount.JunkEmailOptions property. Starting with Outlook 2010, Junk Mail options are stored on the per-account basis for the POP3/SMTP accounts.


•    RDORule.RawConditions and RDORule.Actions properties are now settable (which means you can copy rules between two Exchange mailboxes). If any named property tags are used by the conditions or actions, they are properly reset to the appropriate named properties in the target mailbox.


•    Added RDORule.ProviderData property.


•    Exchange version of MAPI cannot handle Outlook Address Book (OAB) address entries (since it does not include the OAB provider). RDOSession.GetAddressEntryFromID can now handle such entries internally.


•    Added MinHeight and MinWidth properties to the RDOSelectFoldersDialog object.



Bug fixes


•   RDODistListItem.AddMember raised an error for the address entries pointing to address lists.


•   Saving HTML messages with more than 60 images in the olHTMLEmbeddedImages format (RDOMail.SaveAs) sometimes hanged.


•   MAPITable.ExecSQL sometimes raised an error (MAPI_E_CALL_FAILED) when both "TOP" and "WHERE" clauses were specified.


•   Importing MIME messages using RDOMail.Import and the built-in Redemption converter (olRfc822_Redemption) failed to correctly import messages with mixed Windows (0xD,0xA) and Unix (0xA) line breaks.


•   Exporting encrypted or signed MIME messages using built-in Redemption MIME converter (RDOMail.SaveAs(..., olRfc822_Redemption)) always specified smime-type=signed-data for both signed and encrypted messages.


•   RDOMail.Display(true) sometimes raised "Error in IMAPISession.ShowForm: MAPI_E_INVALID_PARAMETER"  exception when running under 64 bit version of Outlook under Windows 8.


•   64 bit version of Redemption raised E_UNEXPECTED exception instead of MAPI_E_USER_CANCEL from RDOAddressBook.ShowAddressBook when the address book dialog was cancelled.


•   RDOException.OriginalDate / StartDateTime / EndDateTime properties returned invalid values for some appointments created by the older (Outlook 2002 or below) versions of Outlook.


•   Importing MSG files (RDOMail.Import) without an RTF body (PR_HRML only) resulted in plain text messages under the online Exchange store (cached Exchange and PST stores were fine)


•   RDOMail.Parent property for the messages retrieved from a search folder (RDOSearchFolder) returned the search folder rather than the actual parent folder (RDOFolder).


•   If the IN operator was the only SQL operator used in MAPITable.ExecSQL  / RDOItems.Find / RDOItems.Restrict (e.g. "Categories IN ('one', 'two')" ), Redemption raised an exception "Assertion failed: Number of fields == 1"


•   RDOSession.GetMessageFromMsgFile always returned a generic RDOMail object instead of a more specific kind (e.g. RDOEncryptedMessage or RDOContactItem derived from RDOMail) for the Unicode MSG files under the standalone version of MAPI (Outlook version of MAPI always worked fine).


•   RDOEncryptedMessage.GetDecryptedMessage raised "Not logged in" exception if the encrypted/signed message was opened using RDOSession.GetMessageFromMsgFile ;e without calling RDOSession.Logon.


•   RDOTaskItem.MarkComplete / MarkCompleteEx sometimes set Start and DueDate properties one day too early.


•   RDORecurrencePattern.PatternEndDate sometimes was 1 day off.


•   Setting RDORecurrencePattern.PatternEndDate did not update the RDORecurrencePattern.Occurrences property.


•   RDOMail.Send did not raise a COM exception if IMessage::SubmitMessage MAPI call returned an error (e.g. when trying to send on behalf of a wrong user).


•   Creating a new appointment (RDOAppointmentItem) under online Office 365 mailbox store sometimes produced "Error in Set_ReminderSet: MAPI_E_INVALID_PARAMETER" exception.


•   Sending a meeting request/update (RDOAppointmentItem.Send) under online Office 365 mailbox store sometimes produced "Error in IMessage::SaveChanges: MAPI_E_INVALID_PARAMETER" exception.


•   RDOUserProperty.Delete or RDOUserProperty.Remove sometimes raised an access violation exception.


 •   Copying messages between Exchange and PST stores (RDOMail.CopyTo) sometimes did not preserve  created / last modified dates.


•   RDOAccounts.AddPOP3Account sometimes returned IOlkAccountManager.FindAccount: E_ACCT_NOT_FOUND exception


•   RDOSession.LogonHostedExchangeMailbox raised E_UNEXPECTED exception when it was used with empty user name and password instead of using the current user's credentials.


•   Unicode MSG files opened using RDOSession.GetMessageFromMsgFile under the standalone (Exchange) version of MAPI returned empty strings for the RDORecipient.Name / Address / etc. string properties.


•   Saving modified recurrence data for the RDOAppointmentItem or RDOTaskItem objects always reset the pattern start date to the start date of the appointment or task.






New features


•    Added CloseOnDoubleClick and  Left, Top, Width, Height properties to the RDOSelectFoldersDialog object.


•    Added RDOEncryptedMessage.CertificateIssuerName property.


•    Added RDOAddressList.Search property (returns RDOAddressListSearch object) that allows to set search criteria on a particular address list (represented by the RDOAddressList object). WARNING: among standard Outlook Address book providers, only the Exchange Address Book provider supports this feature. This method is necessary since most address book providers provide no or very little search support (unlike store providers).

set Session = CreateObject("Redemption.RDOSession")
Session.MAPIOBJECT = Application.Session.MAPIOBJECT
set AddrList = Session.Addressbook.GAL
set Search = AddrList.Search
Search.FirstName = "John"
Search.City = "Phoenix"
set AddressEntries = Search.GetResults
for each AddressEntry in AddressEntries
    Debug.Print AddressEntry.Name


•    Added RDOFolder.OnProgress event. It fires when RDOFolder.CopyTo is called and reflects the progress of the folder copy operation.


•    Added RDOAddressEntry.Owners property (corresponds to the ExchangeDistributionList.GetOwners method in the Outlook Object Model). This property is Exchange specific.

dim Session, ae, vOwner

set Session = CreateObject("Redemption.RDOSession")

Session.MAPIOBJECT = Application.Session.MAPIOBJECT

set ae = Session.AddressBook.Resolvename("DL List name>")

for each vOwner in ae.Owners

  debug.print vOwner.Name



•    Added SafeInspector.FocusEditor method. It allows to bring focus back to the editor from some other control (e.g. from a user control in an Inspector region).

set sInspector = CreateObject("Redemption.SafeInspector")
sInspector.Item = Application.ActiveInspector


•    Added SafeExplorer.ActiveInlineResponseSend method. Outlook Object Model does not allow to call MailItem.Send on a message returned by the Explorer.ActiveInlineResponse property. SafeExplorer.ActiveInlineResponseSend works around that limitation.

set oExplorer = Application.ActiveExplorer
set Item = oExplorer.ActiveInlineResponse
Item.UserProperties.Add("Redemption test", olText).Value = "test value"
set sExplorer = CreateObject("Redemption.SafeExplorer")
sExplorer.Item = oExplorer


•    Added RDOSearchFolder.IsContentIndexedSearch / IsStaticSearch properties (Exchange specific)


•    Importing MIME messages using RDOMail.Import now auto detects the message code page is one is not specified in the MIME headers.


•    Exporting MIME messages using built-in Redemption MIME converter (RDOMail.SaveAs(..., olRfc822_Redemption)) now exports contacts (MIME type text/vcard) and tasks (MIME type text/calendar). Appointments (MIME type text/calendar) were already exported before.




Bug fixes


•   RDOSession.LogonHostedExchangeMailbox method sometimes displayed credentials prompt (if RDOSession.ParentWindows property was set) or returned an error when connecting to an Exchange 2010 mailbox.


•   SafeAppointmentItem.Send sometimes caused memory heap corruption causing the application to crash. RDOAppointmentItem.Send functioned properly.


•   Importing MIME messages using RDOMail.Import and the built-in Redemption converter (olRfc822_Redemption) sometimes corrupted MAPI memory heap resulting in an application crash.


•   Importing MIME messages using RDOMail.Import and the built-in Redemption converter (olRfc822_Redemption) sometimes added ";" to the recipient email address.


•   Importing MIME messages using RDOMail.Import and the built-in Redemption converter (olRfc822_Redemption) failed to correctly import the DRM protected messages.


•   Importing MIME messages using RDOMail.Import sometimes failed to import sender related properties if only the sender email address was available.


•   Importing MIME messages using RDOMail.Import sometimes failed to import MIME messages with a TNEF part. This problem was specific to version 5.6.


•   Importing vCard files using RDOMail.Import raised an error if vCard included a PHOTO header with VALUE=URL attribute. The latest version downloads the image from the specified url and adds it as the contact picture.


•   Importing vTodo files using RDOMail.Import did not correctly import the reminder time if it was specified in UTC time zone.


•   Importing vTodo files using RDOMail.Import and saving vTodo files using RDOMail.SaveAs(..., olVTodo) did not correctly process the task's priority.


•   Importing some EML files to a standalone MSG file sometimes caused Outlook to display the "The operation failed because of a registry or installation problem. Restart Outlook and try again. If the problem persists, reinstall." error message when opening the resulting MSG file.


•   Exporting MIME messages using built-in Redemption MIME converter (RDOMail.SaveAs(..., olRfc822_Redemption)) failed to save existing empty headers stored in the PR_TRANSPORT_MESSAGE_HEADERS property.


•   Exporting MHTML messages  (RDOMail.SaveAs(..., olMHTML)) sometimes failed to save embedded images for the message that used to be in the RTF format with embedded OLE objects.


•   Exporting iCal messages  (RDOMail.SaveAs(..., olICal)) sometimes corrupted Unicode characters under non-Latin language operating systems (suck as Chinese versions of Windows).


•   Exporting iCal messages  (RDOMail.SaveAs(..., olICal)) sometimes did not correctly export exception dates (EXDATE iCal header) for the time zones east of GMT.


•   Exporting HTML messages  (RDOMail.SaveAs(..., olHTML)) sometimes raised Index out of bounds exception for the messages with binary (PT_BINARY) user properties.


•   Exporting tasks in the vTodo format  (RDOMail.SaveAs(..., olVToDo)) did not export the PERCENT-COMPLETE header if RDOTaskItem.PercentComplete property was 0.


•   Exporting tasks in the vTodo format  (RDOMail.SaveAs(..., olVToDo)) did not export the RRULE and DTSTART properties in the TIMEZONE part.


•   RDOMail.Import did not correctly import monthly BYDAY recurrences with a modifier (e.g. RRULE:FREQ=MONTHLY;INTERVAL=1;BYDAY=3WE)


•   RDOAppointmentItem.Start and RDOException.StartDateTime properties sometimes returned wrong values for the appointment exceptions created in a time zone different from teh local time zone.


•   RDORecurrencePattern.GetOccurence hanged for non-recurring appointments or tasks.


•   RDOExchangeMailboxStore.IsCached / RDOExchangePublicFoldersStore.IsCached property always returned the value for the primary mailbox store in the profile even if there were multiple mailboxes in the profile.


•   RDOReminders.Count sometimes returned 0 for the delegate Exchange stores.


•   RDOSession.GetArchiveMailbox did not use the credentials passed to RDOSession.LogonHostedExchangeMailbox or set using RDOSession.ExchangeConnectionProperties.


•   RDOSelectFoldersDialog did not adjust the position of the folder tree view if the RDOSelectFoldersDialog.LabelCaption property contained line breaks.


•   Setting RDORecipient.Fields[] to an invalid value (e.g. setting a PT_BINARY property to a variant other than an array or a hex string) sometimes raised an access violation instead of throwing a meaningful error.


•   RDOTaskItem.Send sometimes caused an access violation if one of the task recipients could not be resolved.


•   Reading named MAPI properties using RDOMail.Fields[] raised an exception if the property did not exist instead of returning an empty variant for the read-only messages (e.g. messages created on top of read-only MSG files or opened in the read-only mode from an Outlook folder).


•   Search folders created by Redemption (RDOStore2.Searches and RDOFolders.AddSearchFolder) did not include any results under Exchange 2013 online store. This was due to the NON_CONTENT_INDEXED_SEARCH flag used (still needed for Exchange 2010).


•   Redemption cached the value of the local time zone on start up and did not refresh it even if the local Windows time zone was changed


•   Retrieving RDOStore.Reminders sometimes caused an error.


•   RDOSession.LogonHostedExchangeMailbox sometimes showed the credentials prompt even though the correct credentials were specified.


•   SafeInspector.SelText property sometimes returned an empty string even if text was selected in the inspector.


•   RDOSession.GetFolderFromPath sometimes returned errors if the store name contained encoded characters (such as %, \, etc.)


•   Accessing RDOSession.Accounts property returned "Error in IOlkAccountManager.Init: 0x800C8001" exception under Outlook 2013 Click-To-Run if an older version of Outlook (e.g. 2007 or 2010) was also installed.


•   RDOMail.Reply / ReplyAll / Forward always used Arial as the font for the new message even if a different font was specified in Outlook options.


•   Accessing RDOSession.Accouns collection under a brand new profile (never used by Outlook) raised "Error in IOlkAccountManager.Init : MAPI_E_NOT_ENOUGH_MEMORY" exception under Outlook 2007. The same error was raised in other versions of Outlook if the global profile section was missing or corrupt.






New features



Bug fixes






This release mostly deals with Outlook 2013 support as well as general bug fixes.

Note that if you are using Outlook 2013 click-to-run (C2R) setup (e.g. Office 2013 downloaded from, you may receive errors when using Safe*Item objects or when setting the RDOSession.MAPIOBJECT property in a process other than outlook.exe. To fix these MAPI marshalling errors, please download Outlook_2013_C2R_fix.ZIP.


New features


Bug fixes:


September 2, 2012



New features:




Bug fixes:






New features:


Bug fixes:





Bug fixes:




New features and major stability improvements in the 64 bit version and under the RedemptionLoader.

New features:

Bug fixes:






New features:


Bug fixes:





New features:



Bug fixes:





New features:

Bug fixes:





New features:

Bug fixes:





New features:

Bug fixes:




New features:

Bug fixes:


Version This version does not introduce any new functionality, but only fixes several issues introduced in the previous versions.

Bug fixes




New features

Bug fixes:




New features

Bug fixes:



New features


Bug fixes:













The primary goal of this intermediate release was stability under every supported version of Outlook (98 through 2003) in every possible configuration, language pack or service pack whether Redemption is used in a COM add-in or a in separate exe. There were dozens of bugs fixed ranging from access violations to inconsistent behavior.

The only three new features are: