Export (0) Print
Expand All

Verifying Whether an Outlook Item Has Been Modified but Not Saved

Office 2010

Summary:  This article shows how to determine whether a Microsoft Outlook item, such as a mail item or contact item, has been modified and has not been saved.

Applies to:  Microsoft Outlook 2010 | Microsoft Office Outlook 2007 | Microsoft Office Outlook 2003

Published:  January 2011

Provided by:  Angela Chu-Hatoun, Microsoft Corporation

Contents

Overview

Microsoft Outlook supports different types of data records called items. By default, Outlook provides built-in items such as email messages, appointments, contacts, and tasks, and also supports creation of custom items. Outlook provides windows called inspectors that support item-specific forms, allowing users to add, view, and modify Outlook data that is specific to that type of item. For example, you can view and edit the start time and end time of an appointment in an appointment form that is displayed in an inspector.

Upon creating or modifying an Outlook item through the Outlook user interface, users explicitly save their changes before closing the inspectors. Programmatically, a solution can create, open, and modify data for an item. The solution explicitly calls the Save or SaveAs method of that item to save the changes. Because Outlook allows the same item to be accessed through the user interface and through code at the same time, it is common for developers to have to determine whether an Outlook item has been modified and has not yet been saved.

This article shows how to programmatically determine whether an Outlook item has been modified and has not been saved. The solution uses a dispidFDirty dispatch ID and does not require the Outlook object model. You can implement the solution in a managed or unmanaged language. This article shows sample code in C# and Visual Basic. For a C++ version of the code sample, see How to: Determine Whether an Outlook Item Has Been Modified but Not Saved in the Outlook 2010 Auxiliary Reference.

Solution

Outlook supports a dispidFDirty dispatch ID that corresponds to a property in an Outlook item, which specifies whether the item has been modified but has not been saved. To access that property, use the dispidFDirty dispatch ID to invoke that property. In managed code, call the InvokeMember method, passing the item object and expressing dispidFDirty as a string argument that represents the property to invoke. In C++, call the IDispatch::Invoke method.

Code Example

The code example in this article consists of two methods: IsActiveInspectorModified and IsItemModified. IsActiveInspectorModified obtains the Outlook item in the active inspector, if any item is currently open in an inspector. If there is an active inspector, IsActiveInspectorModified calls IsItemModified, passing the item as an argument. Depending on the result returned by IsItemModified, IsActiveInspectorModified displays an appropriate message about whether the item has any unsaved changes.

IsItemModified accepts the item object, item, as an input parameter. To use the Type.InvokeMember method on the item object, IsItemModified first uses the System.Object.GetType method to obtain a System.Type object for the item. Because the Type.InvokeMember method requires a dispatch ID to be expressed as a string argument to the name parameter, IsItemModified constructs the string representation of the dispidFDirty dispatch ID as dispidIsItemModifiedMemberName. IsItemModified then calls the Type.InvokeMember method, specifying the following arguments:

  • The string dispidIsItemModifiedMemberName as the argument for the name parameter.

  • The result of the logical OR operation applied to the flags System.Reflection.BindingFlags.InvokeMethod and System.Reflection.BindingFlags.GetProperty, as the argument for the invokeAttr parameter. For more information about supported flags, see the BindingFlags enumeration.

  • The Outlook item object, item, as the argument for the target parameter.

Finally, IsItemModified casts the return value from Type.InvokeMember as Boolean, and returns the Boolean value (True to indicate that the item has unsaved changes; otherwise, False).

The following is the code example written in two languages, Visual Basic and C#.

If you use Microsoft Visual Studio to test this code example, you must first add a reference to the Microsoft Outlook 14.0 Object Library component and specify the Outlook variable when you import the Microsoft.Office.Interop.Outlook namespace. The Imports or using statement must not occur directly before the functions in the code example but must be added before the public Class declaration. The following lines of code show how to do the import and assignment in Visual Basic and C#.

using Outlook = Microsoft.Office.Interop.Outlook;
void IsActiveInspectorModified()
{
    object item;
    if (Application.ActiveInspector() == null)
    {
        MessageBox.Show("ActiveInspector() returned null. You must open an inspector.", 
            "IsActiveInspectorModified", MessageBoxButtons.OK, MessageBoxIcon.Error);
        return;
    }
    item = Application.ActiveInspector().CurrentItem;
    if (IsItemModified(item))
    {
        MessageBox.Show("Item has been modified", 
            "IsActiveInspectorModified", 
            MessageBoxButtons.OK, 
            MessageBoxIcon.Information);
    }
    else
    {
        MessageBox.Show("Item has not been modified", 
            "IsActiveInspectorModified", 
            MessageBoxButtons.OK, 
            MessageBoxIcon.Information);
    }
}

public bool IsItemModified(object item)
{
    Type typeDispatch = item.GetType();
    string dispidIsItemModifiedMemberName = String.Format("[DispID={0}]", 0xF024);
    bool retVal = false;

    try
    {
        retVal = (bool)typeDispatch.InvokeMember(dispidIsItemModifiedMemberName,
            System.Reflection.BindingFlags.InvokeMethod |
            System.Reflection.BindingFlags.GetProperty,
            null,
            item,
            null);
    }
    catch (System.Runtime.InteropServices.COMException comEx)
    {
        Debug.WriteLine(comEx.Message);
    }
    return retVal;
}

Conclusion

This article shows a simple technique to invoke a property on an Outlook item, to determine whether the item has unsaved changes. This technique of invoking the property does not require the Outlook object model. You can use this technique in your managed or unmanaged Outlook solutions.

Additional Resources

Community Additions

ADD
Show:
© 2014 Microsoft