Exemplarische Vorgehensweise: Debuggen einer SharePoint-Anwendung mithilfe von IntelliTrace

Artikel
08/10/2011

Mit IntelliTrace können Sie Anwendungen, einschließlich jenen, die Webseiten integrieren (z. B. SharePoint-Lösungen), leichter debuggen. Herkömmliche Debugger erstellen lediglich eine aktuelle Momentaufnahme des Zustands der Anwendung. Sie können mithilfe von IntelliTrace jedoch zu in der Vergangenheit in der Anwendung aufgetretenen Ereignissen sowie zum Kontext, in dem sie aufgetreten sind, navigieren und die Ereignisse überprüfen.

In dieser exemplarischen Vorgehensweise wird veranschaulicht, wie IntelliTrace verwendet wird, um in Visual Studio 2010 ein SharePoint-Projekt zu debuggen. Dieses Projekt integriert einen Funktionsempfänger, der bei aktivierter Funktion der Liste "Aufgaben" eine Aufgabe und der Liste "Ankündigungen" eine Ankündigung hinzufügt. Wenn die Funktion deaktiviert wird, wird die Aufgabe als abgeschlossen gekennzeichnet, und der Liste "Ankündigungen" wird eine zweite Ankündigung hinzugefügt. Die Prozedur enthält jedoch einen logischen Fehler, der verhindert, dass das Projekt ordnungsgemäß ausgeführt wird. Mit IntelliTrace können Sie den Fehler suchen und korrigieren.

In dieser exemplarischen Vorgehensweise werden die folgenden Aufgaben veranschaulicht:

Erstellen einer Funktion und eines Funktionsereignisempfängers.
Reagieren auf Funktionsereignisse mithilfe von Code.
Verweisen auf die Listen "Aufgabe" und "Ankündigung" mithilfe von Code.
Suchen und Bearbeiten von Listenelementen mithilfe von Code.
Verwenden von IntelliTrace, um einen Codefehler zu suchen und zu korrigieren.
Tipp

Auf Ihrem Computer werden möglicherweise andere Namen oder Speicherorte für einige Benutzeroberflächenelemente angezeigt als die in den folgenden Anweisungen aufgeführten. Diese Elemente ändern sich auf Grundlage der Einstellungen und der Edition von Visual Studio. Weitere Informationen finden Sie unter Arbeiten mit Einstellungen.

Vorbereitungsmaßnahmen

Zum Durchführen dieser exemplarischen Vorgehensweise benötigen Sie die folgenden Komponenten:

Unterstützte Editionen von Windows und SharePoint. Weitere Informationen finden Sie unter Anforderungen für die Entwicklung von SharePoint-Lösungen.
Visual Studio 2010 Professional SP1, Visual Studio 2010 Premium SP1 oder Visual Studio 2010 Ultimate SP1.

Erstellen eines Funktionsempfängers

Erstellen Sie zunächst ein leeres SharePoint-Projekt mit einem Funktionsempfänger.

So erstellen Sie einen Funktionsempfänger

Starten Sie Visual Studio mit der Option Als Administrator ausführen.
Zeigen Sie im Menü Datei auf Neu, und klicken Sie dann auf Projekt.

Das Dialogfeld Neues Projekt wird angezeigt.
Klicken Sie am oberen Rand des Dialogfelds in der Liste auf .NET Framework 3.5, wenn dies nicht bereits ausgewählt ist.
Erweitern Sie den Knoten SharePoint unter der gewünschten Sprache, und klicken Sie anschließend auf den Knoten 2010.
Klicken Sie im Bereich Vorlagen auf Leeres SharePoint-Projekt, ändern Sie den Namen des Projekts in IntelliTraceTest, und klicken Sie dann auf OK.

Der Assistent zum Anpassen von SharePoint wird angezeigt, in dem Sie die SharePoint-Website für Ihr Projekt und die Vertrauensebene der Projektmappe angeben können.
Klicken Sie auf Als Farmlösung bereitstellen und dann auf Weiter.

IntelliTrace kann nur für Farmlösungen verwendet werden.
Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Knoten Funktionen und dann auf Funktion hinzufügen.

"Feature1.feature" wird angezeigt.
Klicken Sie mit der rechten Maustaste auf "Feature1.feature" und dann auf Ereignisempfänger hinzufügen, um der Funktion ein Codemodul hinzuzufügen.

Hinzufügen von Code zum Funktionsempfänger

Fügen Sie anschließend zwei Methoden im Funktionsempfänger Code hinzu: FeatureActivated und FeatureDeactivating. Diese Methoden lösen immer dann aus, wenn eine Funktion in SharePoint aktiviert bzw. deaktiviert wird.

So fügen Sie dem Funktionsempfänger Code hinzu

Fügen Sie am Anfang der Feature1.EventReceiver-Klasse den folgenden Code hinzu, um Variablen zu deklarieren, die die SharePoint-Website und die -Unterwebsite angeben:

' SharePoint site/subsite.
Private siteUrl As String = "https://localhost"
Private webUrl As String = "/"

// SharePoint site/subsite.
private string siteUrl = "https://localhost";
private string webUrl = "/";

Ersetzen Sie die FeatureActivated-Methode durch folgenden Code:

Public Overrides Sub FeatureActivated(ByVal properties As SPFeatureReceiverProperties)
    Try
        Using site As New SPSite(siteUrl)
            Using web As SPWeb = site.OpenWeb(webUrl)
                ' Reference the lists.
                Dim announcementsList As SPList = web.Lists("Announcements")
                Dim taskList As SPList = web.Lists("Tasks")

                ' Add a new announcement to the Announcements list.
                Dim listItem As SPListItem = announcementsList.Items.Add()
                listItem("Title") = "Activated Feature: " & Convert.ToString(properties.Definition.DisplayName)
                listItem("Body") = Convert.ToString(properties.Definition.DisplayName) & " was activated on: " & DateTime.Now.ToString()
                listItem.Update()

                ' Add a to-do task to the Task list.
                Dim newTask As SPListItem = taskList.Items.Add()
                newTask("Title") = "Deactivate feature: " & Convert.ToString(properties.Definition.DisplayName)
                newTask.Update()
            End Using
        End Using

    Catch e As Exception
        Console.WriteLine("Error: " & e.ToString())
    End Try

End Sub

public override void FeatureActivated(SPFeatureReceiverProperties properties)
{
    try
    {
        using (SPSite site = new SPSite(siteUrl))
        {
            using (SPWeb web = site.OpenWeb(webUrl))
            {
                // Reference the lists.
                SPList announcementsList = web.Lists["Announcements"];
                SPList taskList = web.Lists["Tasks"];

                // Add a new announcement to the Announcements list.
                SPListItem listItem = announcementsList.Items.Add();
                listItem["Title"] = "Activated Feature: " + properties.Definition.DisplayName;
                listItem["Body"] = properties.Definition.DisplayName + " was activated on: " + DateTime.Now.ToString();
                listItem.Update();

                // Add a to-do task to the Task list.
                SPListItem newTask = taskList.Items.Add();
                newTask["Title"] = "Deactivate feature: " + properties.Definition.DisplayName;
                newTask.Update();
            }
        }
    }

    catch (Exception e)
    {
        Console.WriteLine("Error: " + e.ToString());
    }

}

Ersetzen Sie die FeatureDeactivating-Methode durch folgenden Code:

Public Overrides Sub FeatureDeactivating(ByVal properties As SPFeatureReceiverProperties)
    Try
        Using site As New SPSite(siteUrl)
            Using web As SPWeb = site.OpenWeb(webUrl)
                ' Reference the lists
                Dim taskList As SPList = web.Lists("Tasks")
                Dim announcementsList As SPList = web.Lists("Announcements")

                ' Add an announcement that the feature was deactivated.
                Dim listItem As SPListItem = announcementsList.Items.Add()
                listItem("Title") = "Deactivated Feature: " & Convert.ToString(properties.Definition.DisplayName)
                listItem("Body") = Convert.ToString(properties.Definition.DisplayName) & " was deactivated on: " & DateTime.Now.ToString()
                listItem.Update()

                ' Find the task the feature receiver added to the Task list when the
                ' feature was activated.
                Dim qry As New SPQuery()
                qry.Query = "<Where><Contains><FieldRef Name='Title' /><Value Type='Text'>Deactive</Value></Contains></Where>"
                Dim taskItems As SPListItemCollection = taskList.GetItems(qry)

                For Each taskItem As SPListItem In taskItems
                    ' Mark the task as complete.
                    taskItem("PercentComplete") = 1
                    taskItem("Status") = "Completed"
                    taskItem.Update()
                Next
            End Using

        End Using

    Catch e As Exception
        Console.WriteLine("Error: " & e.ToString())
    End Try

End Sub

public override void FeatureDeactivating(SPFeatureReceiverProperties properties)
{
    try
    {
        using (SPSite site = new SPSite(siteUrl))
        {
            using (SPWeb web = site.OpenWeb(webUrl))
            {
                // Reference the lists
                SPList taskList = web.Lists["Tasks"];
                SPList announcementsList = web.Lists["Announcements"];

                // Add an announcement that the feature was deactivated.
                SPListItem listItem = announcementsList.Items.Add();
                listItem["Title"] = "Deactivated Feature: " + properties.Definition.DisplayName;
                listItem["Body"] = properties.Definition.DisplayName + " was deactivated on: " + DateTime.Now.ToString();
                listItem.Update();

                // Find the task the feature receiver added to the Task list when the
                // feature was activated.
                SPQuery qry = new SPQuery();
                qry.Query = "<Where><Contains><FieldRef Name='Title' /><Value Type='Text'>Deactive</Value></Contains></Where>";
                SPListItemCollection taskItems = taskList.GetItems(qry);

                foreach (SPListItem taskItem in taskItems)
                {
                    // Mark the task as complete.
                    taskItem["PercentComplete"] = 1;
                    taskItem["Status"] = "Completed";
                    taskItem.Update();
                }
            }
        }

    }

    catch (Exception e)
    {
        Console.WriteLine("Error: " + e.ToString());
    }
}

Testen des Projekts

Nachdem dem Funktionsempfänger der Code hinzugefügt wurde, führen Sie die SharePoint-Anwendung aus, um zu testen, ob sie ordnungsgemäß funktioniert. In diesem Beispiel ist ein kleiner Fehler im Code enthalten. Nachdem der Fehler aufgetreten ist, können Sie das Problem mithilfe von IntelliTrace aufspüren.

So testen Sie das Projekt

Drücken Sie F5, um das Projekt auszuführen.

Nach der Bereitstellung wird die Funktion automatisch aktiviert. Dadurch wird bewirkt, dass der Funktionsempfänger eine Ankündigung und eine Aufgabe hinzufügt.
Klicken Sie nach dem Start von SharePoint im Navigationsbereich auf Listen und dann auf die Liste "Ankündigungen" und die Liste "Aufgaben", um deren Inhalt anzuzeigen.

In der Liste "Ankündigungen" wurde eine neue Ankündigung mit dem Namen Activated feature: IntelliTraceTest_Feature1 hinzugefügt, und in der Liste "Aufgaben" wurde eine neue Aufgabe mit dem Namen Deactivate feature: IntelliTraceTest_Feature1 hinzugefügt. Der Status der Aufgabe lautet "Nicht gestartet".
Deaktivieren Sie die Funktion, indem Sie unter Websiteaktionen auf Websitefeatures verwalten klicken. Klicken Sie dann neben IntelliTraceTest Feature1 auf Deaktivieren und anschließend auf der Seite "Warnung" auf den Link Dieses Feature deaktivieren.

Der Wert Status der Aufgabe sollte jetzt "Completed" lauten, und der Wert % Complete sollte "100%" betragen. Stattdessen weisen die Werte immer noch die Standardeinstellungen auf. Ein Fehler im Code verhindert, dass die Aufgabe aktualisiert wird.

Debuggen des Projekts

Verwenden Sie IntelliTrace, um das Problem im Code zu suchen und zu korrigieren.

So debuggen Sie das Projekt

Suchen Sie in der FeatureDeactivating-Methode die Zeile SPQuery qry = new SPQuery();, und drücken Sie F9, um einen Haltepunkt in dieser Zeile einzufügen.

Da das Problem auftritt, wenn die Funktion deaktiviert wird, ist diese Zeile ein logischer Ausgangspunkt für das Debuggen.
Drücken Sie F5, um das Programm erneut auszuführen. Aktivieren und deaktivieren Sie dann die Funktion, indem Sie die weiter oben unter dem Thema "So testen Sie das Projekt" angegebenen Schritte wiederholen.

Wenn der Haltepunkt in FeatureActivated erreicht ist, wird das IntelliTrace-Fenster angezeigt. Dort werden alle Schritte aufgeführt, die bisher von der Anwendung ausgeführt wurden.
Drücken Sie F11, um jede Codezeile schrittweise zu durchlaufen, bis das Programm abgeschlossen ist.

Immer wenn Sie F11 drücken, wird dem IntelliTrace-Debugverlauf der Anwendung eine weitere "Debugger:"-Zeile hinzugefügt.
Klicken Sie im IntelliTrace-Fenster auf den Link Alle unterbrechen, wenn das Programm abgeschlossen ist.

Dieser Schritt ist erforderlich, um die IntelliTrace-Daten zu speichern.

Optional können Sie Aufrufinformationen für die Anwendung anzeigen, indem Sie auf der IntelliTrace-Symbolleiste auf IntelliTrace-Einstellungen öffnen und dann auf IntelliTrace-Ereignisse und Aufrufinformationen klicken.
Speichern Sie die Debugdaten, indem Sie auf der IntelliTrace-Symbolleiste auf Aktuelle IntelliTrace-Sitzung speichern klicken.

Die Datei hat die Erweiterung ".iTrace".
Klicken Sie in Visual Studio auf Debuggen beenden.
Öffnen Sie die Datei ".iTrace".

Dieser Schritt öffnet eine andere Instanz von Visual Studio, die die Seite "IntelliTrace-Zusammenfassung" anzeigt, die Debuginformationen (z. B. Ausnahmedaten und eine Liste von Threads) bereitstellt, die im Programm verwendet werden.
Erweitern Sie die Threadliste, klicken Sie auf Hauptthread und dann auf Debuggen starten.

Dieser Schritt startet eine Debugsitzung in Visual Studio, bei der die .iTrace-Daten verwendet werden. Um weitere Details zu einem Ereignis im IntelliTrace-Fenster anzuzeigen, klicken Sie darauf.
Da wir vermuten, dass der Fehler in der FeatureDeactivating-Methode auftritt, klicken Sie auf den Link Lokal im Schritt Debugger: für SPListItemCollection taskItems = taskList.GetItems(qry);.

Das Fenster "Lokal" wird angezeigt.
Erweitern Sie die variable Liste im Fenster "Lokal", suchen Sie qry.Query, und überprüfen Sie, ob die Abfrage zum Suchen der Aufgabe statt nach "Deactivate" fälschlicherweise nach "Deactive" sucht.

Dieser Fehler bedeutet, dass die Aufgabe nie in der Abfrage der Liste "Aufgaben" gefunden wird.

Erneutes Testen des Projekts

Da Sie das Problem mit IntelliTrace identifiziert haben, korrigieren Sie den Fehler, und testen Sie das Projekt erneut.

So testen Sie das Projekt erneut

Schließen Sie die Debugsitzung von Visual Studio, und öffnen Sie dann das IntelliTrace-Testprojekt erneut, falls es nicht bereits geöffnet ist.
Ändern Sie in der Abfragezeichenfolge (qry.Query = "<Where><Contains><FieldRef Name='Title' /><Value Type='Text'>Deactive</Value></Contains></Where>") des Codes den Wert von Deactive in Deactivate.
Drücken Sie F5, um das Projekt erneut auszuführen.
Öffnen Sie die Liste "Aufgaben", und überprüfen Sie, ob der Wert Status der Aufgabe "Deactivate" jetzt ordnungsgemäß auf "Abgeschlossen" gesetzt ist, und der Wert % abgeschlossen jetzt "100%" beträgt.

Siehe auch

Konzepte

Debuggen mit IntelliTrace

Weitere Ressourcen

Überprüfen und Debuggen von SharePoint-Code mithilfe von ALM-Funktionen

Exemplarische Vorgehensweise: Überprüfen von SharePoint-Code mithilfe von Komponententests

Freigeben über