Überprüfen geänderter, aber nicht gespeicherter Outlook-Element (maschinell übersetzt)

Zusammenfassung:  In diesem Artikel wird erläutert, wie Sie ermitteln können, ob ein Microsoft Outlook-Element, z. B. ein E-Mail-Element oder ein Kontaktelement, geändert, aber nicht gespeichert wurde.

Letzte Änderung: Dienstag, 5. April 2011

Gilt für: Office 2007 | Office 2010 | Outlook | Outlook 2007 | Outlook 2010

Inhalt dieses Artikels
Übersicht
Lösung
Codebeispiel
Schlussbemerkung
Weitere Ressourcen

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

Veröffentlicht:  Januar 2011

Zur Verfügung gestellt von:  Angela Chu Hatoun, Microsoft Corporation

Inhalt

• Übersicht

• Lösung

• Codebeispiel

• Schlussbemerkung

• Weitere Ressourcen

Übersicht

Microsoft Outlook unterstützt verschiedene Typen von Datensätzen, die als Elemente bezeichnet. In der Standardeinstellung wird Outlook bietet integrierte Elemente wie e-Mail-Nachrichten, Termine, Kontakte und Aufgaben und unterstützt auch die Erstellung von benutzerdefinierten Elementen. Outlook bietet Windows namens Inspektoren, die elementspezifische Formularunterstützung ermöglichen, dass Benutzer hinzufügen, anzeigen und Ändern der Outlook-Daten, die für diesen Typ des Elements ist. Sie können z. B. anzeigen und bearbeiten Sie die Startzeit und Endzeit des Termins in einem Terminformular, das in einem Inspektor angezeigt wird.

Beim Erstellen oder Ändern eines Outlook-Elements über die Outlook-Benutzeroberfläche, speichern Sie Benutzer explizit ihre Änderungen vor dem Schließen der Inspektoren. Eine Lösung kann programmgesteuert erstellen, öffnen und Ändern von Daten für ein Element. Die Lösung ruft explizit die Save oder SaveAs-Methode des betreffenden Elements, um die Änderungen zu speichern. Da Outlook das gleiche Element gleichzeitig über die Benutzeroberfläche und über Code zugegriffen werden kann, ist es üblich, für Entwickler, um zu bestimmen, ob ein Outlook-Element geändert wurde und noch nicht gespeichert haben.

Dieser Artikel zeigt, wie können Sie programmgesteuert ermitteln, ob ein Outlook-Element geändert wurde und nicht gespeichert wurde. Die Lösung verwendet eine dispidFDirty-Dispatch-ID und das Outlook-Objektmodell ist nicht erforderlich. Sie können die Lösung in einer verwalteten oder nicht verwalteten Sprache implementieren. Dieser Artikel enthält Beispielcode in c# und Visual Basic. Eine C++-Version des Codebeispiels finden Sie unter How to: Determine Whether an Outlook Item Has Been Modified but Not Saved in der Outlook 2010 Auxiliary-Referenz.

Lösung

Outlook unterstützt eine dispidFDirty-Dispatch-ID, die an eine Eigenschaft in einem Outlook-Element, der angibt entspricht, ob das Element geändert wurde, aber nicht gespeichert wurde. Verwenden Sie die Dispatch-ID dispidFDirty für den Zugriff auf diese Eigenschaft zum Aufrufen dieser Eigenschaft. Rufen Sie in verwaltetem Code die InvokeMember(String, BindingFlags, Binder, Object, [])-Methode auf, übergeben das Item-Objekt und Ausdrücken von dispidFDirty als ein Zeichenfolgenargument, das die aufzurufenden Eigenschaft darstellt. In C++ können rufen Sie die IDispatch::Invoke-Methode auf.

Codebeispiel

Im Codebeispiel in diesem Artikel besteht aus zwei Methoden: IsActiveInspectorModified und IsItemModified. IsActiveInspectorModified erhält das Outlook-Element im aktiven Inspektor, wenn jedes Element in einem Inspektor geöffnet wird. Ist ein aktiven Inspektor, ruft IsActiveInspectorModifiedIsItemModified, das Element als Argument übergeben. Je nach der von IsItemModified zurückgegebene Ergebnis zeigt IsActiveInspectorModified eine entsprechende Meldung über, ob das Element nicht gespeicherten Änderungen verfügt.

IsItemModified akzeptiert das Elementobjekt, item, als Eingabeparameter. Um die Type.InvokeMember-Methode auf das Item-Objekt verwenden, verwendet IsItemModified zuerst die Object.GetType()-Methode, um ein System.Type-Objekt für das Element zu erhalten. Da die Type.InvokeMember-Methode eine Dispatch-ID, ausgedrückt als Zeichenfolgenargument an den name-Parameter erfordert, erstellt IsItemModified die Zeichenfolgendarstellung der dispidFDirty-Dispatch-ID als dispidIsItemModifiedMemberName. IsItemModified ruft dann die Type.InvokeMember-Methode, und geben die folgenden Argumenten:

• Die Zeichenfolge dispidIsItemModifiedMemberName als Argument für den Parameter name.

• Das Ergebnis der logischen OR-Operation, die auf die Flags System.Reflection.BindingFlags.InvokeMethod und System.Reflection.BindingFlags.GetProperty, als Argument für den Parameter invokeAttr angewendet. Weitere Informationen zu unterstützten Flags finden Sie in der BindingFlags-Enumeration.

• Das Outlook-Elementobjekt, item, als Argument für den Parameter target.

Schließlich IsItemModified wandelt den Rückgabewert von Type.InvokeMember as Boolean, und gibt den booleschen Wert (True, um anzugeben, dass das Element Änderungen ungespeicherte; andernfalls False).

Im folgenden finden im Codebeispiel in zwei Sprachen, Visual Basic und c# geschrieben.

Wenn Sie dieses Codebeispiel mit Microsoft Visual Studio testen, müssen Sie zuerst einen Verweis auf die Microsoft Outlook 14.0-Objektbibliothekkomponente hinzufügen und dann die Outlook-Variable angeben, wenn Sie den Microsoft.Office.Interop.Outlook-Namespace importieren. Die Anweisung Imports oder using darf nicht direkt vor den Funktionen im Codebeispiel auftreten, sondern muss vor der öffentlichen Class-Deklaration hinzugefügt werden. In den folgenden Codezeilen sehen Sie, wie der Import und die Zuweisung in Visual Basic und C# ausgeführt werden.

Imports Outlook = Microsoft.Office.Interop.Outlook

using Outlook = Microsoft.Office.Interop.Outlook;

Sub IsActiveInspectorModified()
Dim itm As Object
If (Application.ActiveInspector() Is Nothing) Then
    MessageBox.Show("ActiveInspector() returned null. You must open an inspector.", _
        "IsActiveInspectorModified", _
        MessageBoxButtons.OK, _
        MessageBoxIcon.Error)
End If
itm = Application.ActiveInspector.CurrentItem
If (IsItemModified(itm)) Then
    MessageBox.Show("Item has been modified", _
        "IsActiveInspectorModified", _
        MessageBoxButtons.OK, _
        MessageBoxIcon.Information)
Else
    MessageBox.Show("Item has not been modified", _
        "IsActiveInspectorModified", _
        MessageBoxButtons.OK, _
        MessageBoxIcon.Information)
    End If
End Sub

Public Function IsItemModified(ByVal item As Object) As Boolean
Dim typeDispatch As Type = item.GetType()
Dim dispidIsItemModifiedMemberName As String = String.Format("[DispID={0}]", _
    &HF024)
Dim retVal As Boolean = False
Try
    retVal = CType(typeDispatch.InvokeMember(dispidIsItemModifiedMemberName, _
        System.Reflection.BindingFlags.InvokeMethod _
        Or System.Reflection.BindingFlags.GetProperty, _
        Nothing, _
        item, _
        Nothing), _
        Boolean)
Catch comEx As System.Runtime.InteropServices.COMException
    Debug.WriteLine(comEx.Message)
End Try
End Function

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;
}

Schlussbemerkung

Dieser Artikel zeigt ein einfaches Verfahren zum Aufrufen einer Eigenschaft für ein Outlook-Element, um festzustellen, ob das Element nicht gespeicherte Änderungen enthält. Diese Technik eines Aufrufs der Eigenschaft erfordert keine Outlook-Objektmodell. Dieser Technik können in Ihren verwalteten oder nicht verwalteten Outlook-Lösungen.

Weitere Ressourcen

How to: Determine Whether an Outlook Item Has Been Modified but Not Saved (Outlook 2010 Auxiliary Reference)