Integrieren benutzerdefinierter Silverlight-Anwendungen in SharePoint Server 2010

  • Artikel

Zusammenfassung:  Informationen zum Verwenden des verwalteten Clientobjektmodells von SharePoint Foundation 2010 für verwalteten Microsoft Visual C#-Code im Kontext von benutzerdefinierten Silverlight 4-Anwendungen, um SharePoint-Listendaten zu nutzen und zu verwenden.

Letzte Änderung: Freitag, 2. Dezember 2011

Gilt für: Business Connectivity Services | Office 2010 | Open XML | SharePoint | SharePoint Designer 2010 | SharePoint Foundation 2010 | SharePoint Online | SharePoint Server 2010 | Visual Studio

Inhalt dieses Artikels
Übersicht
Vorteile der Entwicklung mit dem verwalteten Clientobjektmodell von SharePoint Foundation 2010
Allgemeine Integrationsszenarien für benutzerdefinierte Silverlight-Anwendungen und SharePoint Server 2010
Übersicht über das Szenario: Kombinieren von Silverlight und SharePoint zum Erstellen eines Dashboards
Erstellen des Incident-Dashboards
Schlussbemerkung
Weitere Ressourcen
Informationen zum Autor

Bereitgestellt von:  Casey Margell, FooBarbarians (in englischer Sprache)

Inhalt

  • Übersicht

  • Vorteile der Entwicklung mit dem verwalteten Clientobjektmodell von SharePoint Foundation 2010

  • Allgemeine Integrationsszenarien für benutzerdefinierte Silverlight-Anwendungen und SharePoint Server 2010

  • Übersicht über das Szenario: Kombinieren von Silverlight und SharePoint zum Erstellen eines Dashboards

  • Erstellen des Incident-Dashboards

    • Erstellen der Silverlight 4-Anwendung mithilfe von Visual Studio 2010

    • Hinzufügen von Verweisen auf die Assemblys des verwalteten Clientobjektmodells von SharePoint Foundation 2010

    • Hinzufügen einer Using-Anweisung zum verwalteten Clientobjektmodell

    • Abrufen von SharePoint-Listendaten

    • Sicherheit und domänenübergreifende Aufrufe

    • Hinzufügen und Aktualisieren von SharePoint-Listendaten

  • Hinzufügen der Unterstützung bestimmter Silverlight 4-Features

    • Aktivieren des Druckens mit Silverlight 4

    • Implementieren der Rechtsklickunterstützung in Silverlight 4

    • Aktivieren von Zwischenablagevorgängen in Silverlight 4

    • Erstellen eines Silverlight-Webparts in SharePoint Foundation 2010

  • Schlussbemerkung

  • Weitere Ressourcen

  • Informationen zum Autor

Klicken Sie hier, um den Code abzurufen  Beispielcode herunterladen (in englischer Sprache)

Übersicht

Eine der Verbesserungen in Microsoft SharePoint Foundation 2010 ist die Einführung des verwalteten Clientobjektmodells von SharePoint Foundation 2010. Das verwaltete Clientobjektmodell bietet ein Framework für den Zugriff auf mehrere SharePoint-Datenquellen über .NET Framework-basierten verwalteten Code und JavaScript/ECMAScript (JavaScript, JScript). Früher mussten Sie die Server-API verwenden und Code direkt auf dem Server testen, von dem die SharePoint Server-Installation gehostet wurde. Mit dem verwalteten Clientobjektmodell können Sie Anwendungen erstellen, die auf SharePoint-Daten zugreifen und diese verwenden, und Konfigurationsaufgaben ausführen, ohne Code direkt auf dem Servercomputer zu erstellen oder zu installieren.

Dieser Artikel ist Teil einer Reihe von Artikeln, in denen die Integration von Clientanwendungen mit Geschäftsprozessen und Workflows beschrieben wird:

Vorteile der Entwicklung mit dem verwalteten Clientobjektmodell von SharePoint Foundation 2010

Das verwaltete Clientobjektmodell von SharePoint Foundation 2010 bietet ein clientseitiges Framework zum Arbeiten mit den gängigen Objekten in SharePoint Server-Websites. Weitere Informationen finden Sie unter Verwenden des verwalteten Clientobjektmodells von SharePoint Foundation 2010. Mit Anwendungen, die das verwaltete Clientobjektmodell nutzen, können ähnliche Vorgänge wie mit dem serverseitigen Clientobjektmodell ausgeführt werden.

SharePoint-Funktionalität wird in Organisationen immer häufiger verwendet und benötigt, weshalb IT-Teams oft aufgefordert werden, SharePoint-API-Funktionalität außerhalb von Bereitstellungen der SharePoint-Produkte und -Technologien zu unterstützen. Früher wurden dazu SharePoint Server-Webdienste verwendet. Und wenn die erforderliche Funktionalität mit diesen Webdiensten nicht möglich war, wurde ein benutzerdefinierter Webdienst verwendet, der zusammen mit der SharePoint-Bereitstellung ausgeführt wurde, von der das serverseitige Objektmodell verwendet wurde. Das Einrichten dieser Dienste war nicht ganz einfach, und das Verwalten der verschiedenen Endpunkte und die ständige Synchronisierung der Definitionen führten oft zu Problemen. Darüber hinaus kann die Bereitstellung von serverseitigem Code zu Widerständen innerhalb der Organisation führen oder überhaupt nicht in Frage kommen. In SharePoint Foundation 2010 gibt es ein verwaltetes Clientobjektmodell mit ähnlicher Funktionalität, um die Flexibilität von Umgebungen zu verbessern, in denen Sie SharePoint Server-Daten und -Funktionalität verwenden können, um die Anwendungsbereitstellung zu vereinfachen.

Das verwaltete Clientobjektmodell stellt ein allgemeines Framework für die .NET Framework-basierten Anwendungen dar und vermindert dadurch den Druck. Diese Anwendungen basieren nicht auf serverseitigem Code. Deshalb ist das Einrichten, Bereitstellen, Verwalten und Entwickeln dieser Anwendungen einfacher. Das Integrieren des verwalteten Clientobjektmodells in Silverlight-Anwendungen ist einfach und vorhersagbar.

Allgemeine Integrationsszenarien für benutzerdefinierte Silverlight-Anwendungen und SharePoint Server 2010

Es folgt eine Aufstellung von Beispielszenarien:

  1. Präsentieren von Inhalt aus internen SharePoint-Websites mithilfe von Silverlight auf einer öffentlich zugänglichen Website

  2. Erstellen einer Silverlight-Anwendung für Unternehmen, die SharePoint-Produkte und -Technologien für Speicherung, Authentifizierung und Berichterstellung verwendet

  3. Dynamisches Präsentieren von Listendaten in SharePoint-Websites mithilfe von Silverlight

Diese Szenarien zeigen einige primäre Anforderungen und Funktionen auf:

  • Zugriff auf SharePoint-Daten und -Funktionalität

  • Autorisierung

  • Authentifizierung

In diesem Artikel wird beschrieben, wie Sie auf SharePoint-Daten zugreifen und diese nutzen, indem Sie SharePoint-Listendaten aus einer Silverlight 4-Anwendung verwenden.

Übersicht über das Szenario: Kombinieren von Silverlight und SharePoint zum Erstellen eines Dashboards

In diesem Szenario verwendet Contoso Inc., ein Versicherungsunternehmen, Microsoft SharePoint Server 2010 zum Verwalten von Daten und Workflows. Dieses Szenario umfasst die gesamte Lebensdauer eines Versicherungsanspruchs; von der Meldung des Schadensfalls bis zum Genehmigen und Abschließen des Vorgangs. Der Workflow für den Versicherungsanspruch wird in SharePoint Server 2010 verwaltet und kann problemlos aufgerufen werden, wenn Sie den Status eines bestimmten Versicherungsanspruchs überprüfen müssen.

Contoso hat mithilfe von Microsoft SharePoint Server 2010 und Microsoft Office 2010 eine Infrastruktur implementiert, um die Bearbeitung von Schadensfällen zu vereinfachen und zu optimieren. Daran beteiligt sind mehrere Anwendungen, die intern und extern verwendet werden. Außerdem werden unterschiedliche Technologien verwendet, von mobilen Clients bis hin zu Desktopcomputern. Eines ist jedoch bei allen Technologien identisch: SharePoint Server 2010 und das verwaltete Clientobjektmodell von SharePoint Foundation 2010.

In diesem Szenario erstellen wir ein Silverlight-Dashboard für Kundendienstmitarbeiter bei Contoso, mit dem gezeigt werden soll, wie Silverlight-Funktionen auf SharePoint-Daten angewendet werden, um eine schnelle und optimale Benutzerinteraktion zu ermöglichen.

Personen im Silverlight-Szenario

  • Don Funk, Fahrer (Opfer eines Autounfalls) und Kunde von Contoso, Inc.

  • April Regan, Kundendienstmitarbeiterin bei Contoso, Inc.

  • Rob Young, Versicherungsvertreter bei Contoso, Inc.

  • Jeff Ford, Autowerkstattmanager und Partner von Contoso, Inc.

Ereignisablauf

Abbildung 1. Ereignisablauf

Ereignisfluss

In der Wohngegend von Don Funk hat sich ein heftiges Gewitter ereignet. Durch hohe Windgeschwindigkeiten ist ein Baum umgestürzt und auf dem Auto von Don gelandet. Don macht mit seinem Fotohandy Fotos des Schadens und schickt den Versicherungsanspruch inklusive Bildern und einer Schadensmeldung mit seinem Mobiltelefon an das Versicherungsunternehmen.

Die Schadensmeldung geht beim Versicherungsunternehmen ein und wird einer Aufgabenliste hinzugefügt. Die Kundendienstmitarbeiterin April wird benachrichtigt, sie überprüft die Daten, um sicherzustellen, dass alle erforderlichen Informationen vorhanden sind, und übergibt den Schadensfall an den Versicherungsvertreter Rob Young.

Für Rob Young wird eine Aufgabe erstellt, um den Versicherungsanspruch zu überprüfen und ihn entweder zu genehmigen oder abzulehnen. Rob Young überprüft die Schadensmeldung und trifft sich dann mit Don zu einem Ortstermin, um weitere Informationen zu dem Vorfall zu erhalten. Er kommt zu der Schlussfolgerung, dass kein Betrug vorliegt. Deshalb genehmigt er den Versicherungsanspruch und fordert einen Kostenvoranschlag für die Reparaturarbeiten an. Die Rob zugewiesene Aufgabe wird aktualisiert, und vom Autowerkstattmanager Jeff Ford wird ein Kostenvoranschlag für die Reparaturarbeiten angefordert.

Wenn Jeff benachrichtigt wird, dass er für Contoso, Inc. einen Kostenvoranschlag erstellen soll, greift er auf das Extranet von Contoso, Inc. zu und füllt ein Angebotsformular aus. Jeff erhält den Zuschlag für die Reparaturarbeiten und vereinbart mit Don einen Termin zum Ausführen der Arbeiten an Dons Auto.

Nach Abschluss der Reparaturarbeiten schickt Jeff eine Rechnung an Contoso.

Details des Szenarioworkflows

Der Szenarioworkflow wird durch die von Don Funk per Mobiltelefon gesendete Schadensmeldung ausgelöst. In Abbildung 2 sehen Sie den Teil des Workflows, der dieses Dokument betrifft.

Abbildung 2. Workflowdiagramm

Workflowdiagramm

Wenn unser Szenario ausgelöst wird, sendet unser Kunde Don Funk mithilfe der mobilen Anwendung einen Versicherungsanspruch und Details zum Schadensfall. Die mobile Anwendung kommuniziert die Details des Schadensfalls mit einem Windows Communication Foundation (WCF)-Dienst, der zusammen mit der SharePoint Server 2010-Installation ausgeführt wird. Dieser Dienst erstellt wie in der folgenden Abbildung dargestellt ein Listenelement in der Liste mit den Vorfällen.

Abbildung 3. Liste mit Vorfällen

Schadensliste

Wenn in der Liste mit den Vorfällen ein Element erstellt wird, wird von SharePoint automatisch ein benutzerdefinierter Workflow gestartet. Unserer Kundendienstmitarbeiterin April Regan wird eine Aufgabe zugewiesen. Zu diesem Zeitpunkt wird an unsere Kundendienstmitarbeiterin eine E-Mail-Nachricht gesendet, in der sie auf die ihr zugewiesene neue Aufgabe hingewiesen wird. Und unserem Kunden wird eine E-Mail-Nachricht gesendet, in der er darauf hingewiesen wird, dass der Schadensfall empfangen wurde und bearbeitet wird.

Abbildung 4. Liste mit Aufgaben für den Vorfall

Schadensaufgabenliste

Wenn die Kundendienstmitarbeiterin April die E-Mail-Nachricht mit dem Hinweis auf die ihr zugewiesene neue Aufgabe im Zusammenhang mit dem Versicherungsanspruch empfängt, überprüft sie mit dem Incident-Dashboard den Versicherungsanspruch und bearbeitet ihn gemäß dem Workflow.

Erstellen des Incident-Dashboards

Bei dem in unserem Szenario verwendeten Incident-Dashboard (Abbildung 5) handelt es sich um eine mit Microsoft Visual Studio 2010 erstellte Silverlight 4-Anwendung, von der das verwaltete Clientobjektmodell verwendet wird. In diesem Dashboard werden die offenen Versicherungsansprüche sowie die Status der Versicherungsansprüche im Workflowlebenszyklus angezeigt. In diesem Abschnitt wird beschrieben, wie Sie eine Silverlight 4-Anwendung in Visual Studio 2010 erstellen, Verweise auf die Assemblys des verwalteten Clientobjektmodells hinzufügen sowie SharePoint-Daten mithilfe des verwalteten Clientobjektmodells verwenden.

Abbildung 5. Incident-Dashboard

Schadensdashboard

Erstellen der Silverlight 4-Anwendung mithilfe von Visual Studio 2010

Zum Erstellen von Silverlight 4-Anwendungen in Visual Studio 2010 müssen Sie zunächst die Silverlight 4 Tools für Visual Studio 2010 installieren. Informationen zum Herunterladen dieser Tools finden Sie unter Microsoft Silverlight 4 Tools für Visual Studio 2010. Nach der Installation der Silverlight-Tools erstellen Sie mithilfe der Silverlight-Anwendungsvorlage ein Projekt in Visual Studio 2010.

So erstellen Sie mithilfe der Silverlight-Anwendungsvorlage ein Silverlight-Projekt in Visual Studio 2010

  1. Starten Sie Microsoft Visual Studio 2010.

  2. Zeigen Sie im Menü Datei auf Neu, und klicken Sie dann auf Projekt.

  3. Erweitern Sie im Dialogfeld Neues Projekt unter Installierte Vorlagen den Knoten Visual C#, und wählen Sie dann Silverlight aus.

  4. Wählen Sie wie in der folgenden Abbildung dargestellt im mittleren Bereich, in dem die Projekttypen aufgelistet werden, den Eintrag Silverlight-Anwendung aus.

    Abbildung 6. Silverlight-Anwendungsvorlage in Visual Studio 2010

    Silverlight-Anwendungsvorlage

  5. Geben Sie im Textfeld Name einen Projektnamen ein, wie z. B. Contoso.IncidentDashboard.

  6. Geben Sie im Textfeld Speicherort den Pfad des Speicherorts für die Lösungsdateien ein.

  7. Klicken Sie auf OK.

Nachdem Sie einen Projektnamen und einen Speicherort eingegeben haben, werden Sie wie in der folgenden Abbildung dargestellt von Visual Studio aufgefordert, der Lösung ein Websiteprojekt und die Silverlight-Zielversion hinzuzufügen. In diesem Szenario fügen wir wie in der folgenden Abbildung dargestellt ein Websiteprojekt für Silverlight 4 hinzu.

Abbildung 7. Erstellen des Websiteprojekts und Festlegen der Silverlight-Zielversion in Visual Studio 2010

Erstellen des Websiteprojekts

Hinzufügen von Verweisen auf die Assemblys des verwalteten Clientobjektmodells von SharePoint Foundation 2010

Im nächsten Schritt müssen Sie zur Verwendung der Funktionalität im Projekt Verweise auf das verwaltete Clientobjektmodell hinzufügen. Die beiden Assemblys Microsoft.SharePoint.Client.dll und Microsoft.SharePoint.Client.Runtime.dll sind auf dem Computer mit SharePoint Foundation 2010 im folgenden Verzeichnis gespeichert:

%ProgramFiles%\Common Files\Microsoft Shared\web server extensions\14\ISAPI

So fügen Sie Verweise auf die Assemblys des verwalteten Clientobjektmodells in Visual Studio 2010 hinzu

  1. Klicken Sie mit der rechten Maustaste auf das Projekt Contoso.IncidentDashboard.

  2. Klicken Sie auf Verweis hinzufügen.

  3. Klicken Sie auf Durchsuchen.

  4. Navigieren Sie zum Speicherort der Assemblys Microsoft.SharePoint.Client.dll und Microsoft.SharePoint.Client.Runtime.

  5. Wählen Sie die beiden Assemblys aus.

  6. Klicken Sie auf OK.

Nach dem Hinzufügen des erforderlichen Verweises sieht das Projekt wie in der folgenden Abbildung aus.

Abbildung 8. Silverlight-Anwendung mit Verweisen auf die Assemblys des verwalteten Clientobjektmodells in Visual Studio 2010

Silverlight-Anwendung mit Referenzen

Hinzufügen einer Using-Anweisung zum verwalteten Clientobjektmodell

Im nächsten Schritt fügen Sie am Anfang der CS-Datei eine using-Anweisung hinzu. Das Arbeiten mit dem verwalteten Clientobjektmodell ähnelt dem Arbeiten mit dem serverseitigen Objektmodell. Für Benutzer mit Erfahrung im Arbeiten mit dem serverseitigen Objektmodell sind die Objekte und Methoden für das Arbeiten mit diesen Objekten logisch und einfach in der Handhabung.

So fügen Sie dem verwalteten Clientobjektmodell eine Using-Anweisung hinzu

  1. Öffnen Sie die Datei MainPage.xaml.cs.

  2. Fügen Sie die folgende using-Anweisung nach den vorhandenen using-Anweisungen hinzu.

    using Microsoft.SharePoint.Client;

Das Einrichten der Verweise und der using-Anweisungen ermöglicht den Zugriff auf die in der Microsoft.SharePoint.Client-Assembly definierten Objekte.

Abrufen von SharePoint-Listendaten

Das [Microsoft.SharePoint.Client.ClientContext]-Objekt und das [Microsoft.SharePoint.Client.Web]-Objekt stellen die zentralen Komponenten des verwalteten Clientobjektmodells dar. Ohne diese Objekte können die anderen Vorgänge nicht ausgeführt werden. Sie sollten Variablen auf Objektebene verwenden, um die Objekte in asynchronen Aufrufen während der Anwendungsausführung permanent zu speichern.

Wichtiger HinweisWichtig

Von der Verwendung mehrerer ClientContext-Objekte wird abgeraten, da manche clientseitigen Objekte, wie z. B. ListItemCollection-Objekte, speziell für ein bestimmtes ClientContext-Objekt gelten. Der Versuch, ein Objekt mit einem anderen als dem für das Erstellen dieses Objekts zuständigen ClientContext-Objekt zu verwenden, kann zu Problemen führen.

So rufen Sie Listendaten mithilfe von Variablen ab

  1. Fügen Sie dem Objekt nach der Klassendefinition die folgenden Eigenschaften hinzu:

            private ClientContext _context = null;
        private Web _site = null;
        private ListItemCollection _incidentListItems = null;

    Bei den drei Membervariablen im vorherigen Beispiel handelt es sich um ein ClientContext-Objekt, das auf die zu verwendende SharePoint-Website verweist, ein Web-Objekt, das eine SharePoint-Website darstellt, sowie ein ListItemCollection-Objekt zum Abrufen von Elementen in einer SharePoint-Liste mithilfe des verwalteten Clientobjektmodells. Ein Ereignishandler für das Loaded-Ereignis im MainPage-Objekt wird zum Initialisieren der Membervariablen nach dem MainPage-Objekt und zum Initialisieren der untergeordneten Elemente verwendet.

  2. Fügen Sie im MainPage-Konstruktor nach der Methode den folgenden Code hinzu.

            this.Loaded += new RoutedEventHandler(MainPage_Loaded);

  3. Fügen Sie nach dem MainPage-Konstruktor die folgende Methode hinzu.

            void MainPage_Loaded(object sender, RoutedEventArgs e)
        {
            _context = new ClientContext("http://intranet.contoso.com");
            _site = _context.Web;

            List list = _site.Lists.GetByTitle("Incidents");
            CamlQuery query = new CamlQuery();
            query.ViewXml =
                @"<View>
                    <Query>
                        <Where>
                            <Neq>
                                <FieldRef Name='Status' />
                                <Value Type='Choice'>Closed</Value>
                            </Neq>
                        <Where>
                    <Query>
                </View>";

            _incidentListItems = list.GetItems(query);
            _context.Load(_incidents);
            _context.ExecuteQueryAsync(
                onGetIncidentsSucceeded, 
                onGetIncidentsFailed
                );
        }

    Mit diesem Code wird das ClientContext-Objekt initialisiert, wobei die URL der Website, auf die verwiesen werden soll, übergeben wird. Anschließend wird das Web-Objekt aus dem ClientContext-Objekt abgerufen. Beide Objekte werden in Membervariablen gespeichert, um den Verweis auf diese Objekte beizubehalten.

Die folgende Vorgehensweise veranschaulicht das bei Verwendung des verwalteten Clientobjektmodells in Silverlight zu befolgende Muster.

  • Legen Sie einen Verweis auf das zu verwendende logische Objekt fest.

  • Richten Sie die auszuführende Aktion ein.

  • Führen Sie die Aktion aus, wobei es Rückrufmethoden für die erfolgreiche und fehlerhafte Ausführung gibt.

Anhand dieses Musters werden für das vorherige Beispiel die folgenden Schritte ausgeführt:

  • Ein Verweis auf die Liste mit den Vorfällen wird festgelegt.

  • Ein [Microsoft.SharePoint.Client.CamlQuery]-Objekt wird erstellt und die zugehörige Abfrage festgelegt. In diesem Szenario bedeutet dies Elemente in der Liste mit den Vorfällen ohne den Status Closed.

  • Die [Microsoft.SharePoint.Client.List.GetItems]-Methode wird aufgerufen, und das Ergebnis wird in der ListItemCollection-Membervariablen gespeichert. Das [Microsoft.SharePoint.Client.CamlQuery]-Objekt wird für die [Microsoft.SharePoint.Client.List.GetItems]-Methode bereitgestellt. Hiermit werden die von unserem Get-Vorgang erwarteten Ergebnisse definiert.

Asynchrone Vorgänge wurden zuvor kurz erwähnt. Befassen wir uns nun damit, worum es sich dabei handelt und weshalb sie eine wichtige Rolle spielen. Beim Arbeiten in Silverlight darf die Benutzeroberfläche nicht gesperrt werden, während Sie auf die von der Abfrage zurückgegebenen Ergebnisse warten. Wenn Sie darauf warten, dass ein asynchroner Vorgang abgeschlossen wird, müssen Sie dem Benutzer visuelles Feedback liefern, dass etwas passiert und damit die Benutzeroberfläche nicht gesperrt wird. Wenn sich in der Benutzeroberfläche nichts ändert, ist für den Benutzer nicht erkennbar, dass auf dem Back-End etwas passiert. Das Aufrufen der [Microsoft.SharePoint.Client.ClientRunTimeContext.ExecuteQueryAsync]-Methode liefert Ereignishandler mit einem Hinweis auf die erfolgreiche bzw. fehlerhafte Ausführung.

Beim Abrufen der Liste mit den Vorfällen muss wie in Erstellen der Silverlight 4-Anwendung mithilfe von Visual Studio 2010 dargestellt das Dashboard einen Hinweis darauf liefern, wie viele Versicherungsansprüche zu jeder Kategorie gehören. Es muss außerdem auf Vorfälle hingewiesen werden, die zu bestimmten Kategorien in der Liste gehören. Nun wäre ein guter Zeitpunkt, sich mit einer der Implikationen der Ausführung eines asynchronen Vorgangs zu befassen. Rückrufe für asynchrone Vorgänge werden nicht im selben Thread wie die Benutzeroberfläche ausgeführt. Deshalb führt der Versuch, die Benutzeroberfläche innerhalb dieses Rückrufs zu ändern, zu einer Ausnahme. Um dieses Problem zu vermeiden, können Sie wie im folgenden Beispiel veranschaulicht einen benutzerdefinierten Delegaten und eine zusätzliche Methode verwenden. Fügen Sie nach der MainPage_Loaded-Methode den folgenden Code hinzu.

        private void onGetIncidentsSucceeded(
            object sender, 
            ClientRequestSucceededEventArgs args
            )
        {
            UpdateIncidentsSummary();
        }

        private delegate void UpdateIncidentsSummaryDelegate();
        private void UpdateIncidentsSummary()
        {
            if (!this.Dispatcher.CheckAccess())
            {
                this.Dispatcher.BeginInvoke(
                    new UpdateIncidentsSummaryDelegate(UpdateIncidentsSummary)
                    );
                return;
            }

            int newIncidents = 0;
            //... Additional counter variables

            foreach (ListItem listItem in _incidentListItems)
            {
                string status = (string)listItem["Status"];

                switch (status)
                {
                    case "New":
                        newIncidents++;
                        break;
                    //... Additional cases for the different statuses
                }
            }

            this.txtNewIncidentCount.Text = newIncidents.ToString();
            //... Set Additional Count display controls
        }

Im Einzelnen wird in diesem Beispiel von der onGetIncidentsSucceeded-Methode die UpdateIncidentsSummary-Methode aufgerufen. Die UpdateIncidentSummary-Methode überprüft mithilfe der Dispatcher.CheckAccess-Methode, ob sie Zugriff auf die Benutzeroberfläche hat. Falls dies nicht der Fall ist, wird ein Delegat zurück zur UpdateIncidentSummary-Methode erstellt, die im Benutzeroberflächenthread ausgeführt wird.

Diese Überprüfung erfolgt für jede Statusaktualisierung. Nach Abschluss dieses Prozesses wird die aktuelle Anzahl in der Benutzeroberfläche aktualisiert.

Befassen wir uns nun mit der fehlerhaften Ausführung des Ereignishandlers.

Fügen Sie nach der UpdateIncidentSummary-Methode den folgenden Codeabschnitt hinzu.

     private void onGetIncidentsFailed(
            object sender, 
            ClientRequestFailedEventArgs args
            )
        {
            Alert("An Error Occurred Retreiving Incidents. Please refresh the page and try again:\n\n" + args.Exception);
        }

        private delegate void AlertDelegate(string message);
        private void Alert(string message)
        {
            if (!this.Dispatcher.CheckAccess())
            {
                this.Dispatcher.BeginInvoke(new AlertDelegate(Alert), message);
                return;
            }
            MessageBox.Show(message);
        }

Dieses Beispiel weist im Prinzip dasselbe allgemeine Muster auf. Der Ereignishandler ruft eine Methode auf, mit der der Zugriff auf die Benutzeroberfläche überprüft wird. Wenn kein Zugriff möglich ist, wird im Benutzeroberflächenthread ein benutzerdefinierter Delegat aufgerufen. Sie sollten jedoch beachten, dass das ClientRequestFailedEventArgs-Objekt eine Exception-Eigenschaft aufweist. Dieses Objekt enthält eine festgestellte Ausnahme und ist sehr hilfreich zum Nachverfolgen des Grunds für das Aufreten der Ausnahme.

Wenn Sie Ihr eigenes Projekt fortsetzen möchten, drücken SieF5, um das Debuggen zu starten. Es wird dann ein Fehler wie in der folgenden Abbildung angezeigt.

Abbildung 9. Sicherheitsausnahme beim Aktualisieren der Zusammenfassung mit den Vorfällen

Abbildung 9

Diese Ausnahme ist darauf zurückzuführen, dass sich der Debugspeicherort in einer anderen Domäne als der SharePoint-Website befindet. Visual Studio 2010 weist der Instanz des Serverentwicklungscomputers, auf dem ASP.NET ausgeführt wird, automatisch einen Port zu. Im nächsten Abschnitt wird beschrieben, wie Sie dies vermeiden.

Sicherheit und domänenübergreifende Aufrufe

Das Zugreifen auf eine Ressource von unterschiedlichen Domänen aus und die entsprechenden Sicherheitsimplikationen werden als domänenübergreifende Aufrufe bezeichnet. In unserem Beispiel möchten wir von der Debugumgebung aus einen domänenübergreifenden Aufruf für unsere SharePoint-Zielinstanz ausführen. Hierzu verwenden wir eine Richtliniendatei für den domänenübergreifenden Zugriff.

Richtlinien für den domänenübergreifenden Zugriff befassen sich mit Sicherheitsproblemen im Zusammenhang mit dem Zugriff auf unterschiedliche Domänen. Richtlinien für den domänenübergreifenden Zugriff werden mithilfe der XML-Datei clientaccesspolicy.xmlkonfiguriert. Diese Datei ist im Stammverzeichnis des virtuellen Verzeichnisses gespeichert, von dem die Website gehostet wird. Beispielsweise wurde in diesem Szenario die Datei im folgenden Verzeichnis gespeichert:

C:\InetPub\wwwroot\wss\VirtualDirectories\80\

Beim folgenden Codebeispiel handelt es sich um eine sehr einfache Richtliniendatei für den Clientzugriff.

<?xml version="1.0" encoding="utf-8" ?> 
<access-policy> 
    <cross-domain-access> 
        <policy> 
            <allow-from> 
                <domain uri="*"/> 
            </allow-from> 
            <grant-to> 
                <resource include-subpaths="true" path="/"/> 
            </grant-to> 
        </policy> 
    </cross-domain-access> 
</access-policy>

In dieser XML-Datei ist eine Richtlinie eingerichtet, die Anforderungen von allen Domänen erlaubt und allen Ressourcen in der Website die Zugriffsberechtigung erteilt. Diese Richtlinie für einen umfassenden Zugriff ist für eine Produktionsumgebung nicht zu empfehlen, kann aber für die Entwicklungsumgebung sinnvoll sein. Beachten Sie, dass zum Ausführen dieser Schritte Administratorrechte für den Servercomputer mit SharePoint Foundation 2010 erforderlich sind.

So erstellen Sie eine Richtliniendatei für den Clientzugriff für die Entwicklungsumgebung

  1. Erstellen Sie eine Textdatei mit dem Namen clientaccesspolicy.xml.

  2. Fügen Sie der Datei den vorausgehenden XML-Code hinzu.

  3. Speichern Sie die Änderungen, und schließen Sie die Datei.

  4. Kopieren Sie diese Datei in das Stammverzeichnis der Webanwendung.

    Abbildung 10. "ClientAccessPolicy.xml"

    ClientAccessPolicy.xml

    Nachdem Sie diese Datei im entsprechenden Verzeichnis gespeichert haben, starten Sie Microsoft Internetinformationsdienste (Internet Information Services, IIS) neu.

  5. Klicken Sie auf Start.

  6. Erweitern Sie im Startmenü Alle Programme und dann den Ordner Zubehör.

  7. Klicken Sie mit der rechten Maustaste auf Eingabeaufforderung, und klicken Sie dann auf Als Administrator ausführen.

  8. Geben Sie iisreset ein, und drücken Sie wie in der folgenden Abbildung dargestellt dieEINGABETASTE.

    Abbildung 11. Erneutes Starten der Website

    Neustarten der Website

Nach dem Erstellen der Richtliniendatei für den Clientzugriff und dem erneuten Starten von IIS sollten Sie in der Lage sein, die Anwendung zu debuggen, ohne dass dabei Fehler gefunden werden.

Hinzufügen und Aktualisieren von SharePoint-Listendaten

Im Folgenden befassen wir uns kurz mit dem Hinzufügen und Aktualisieren von Listenelementen. Beachten Sie, dass für dieses Beispiel keine erfolgreichen und fehlerhaften Rückrufe angezeigt werden, da Sie weiter oben in diesem Artikel Beispiele hierfür finden. Wie im folgenden Beispiel dargestellt ist das Hinzufügen eines Elements ganz einfach.

        List incidents = _site.Lists.GetByTitle("Incidents");

        ListItemCreationInformation listingListItemCreation = 
            new ListItemCreationInformation();
        ListItem item = incidents.AddItem(listingListItemCreation);
        item["Title"] = (string) . . .
        . . .
        item.Update();
        
        _context.ExecuteQueryAsync(onQuerySucceeded, onQueryFailed);

Bei diesem Beispiel wird das weiter oben behandelte Muster verwendet (Abrufen des gewünschten Objekts, Einrichten der Aktion, Ausführen). Für dieses Beispiel werden die folgenden Aktionen ausgeführt:

  • Abrufen der Liste, der ein Element hinzugefügt werden soll.

  • Einrichten eines ListItemCreationInformation-Objekts und mithilfe dieses Objekts Erstellen eines ListItem-Objekts in der Liste. Nach dem Erstellen des ListItem-Objekts Festlegen der Feldwerte.

  • Ausführen der Abfrage.

Das Aktualisieren der Elementerstellung folgt dem bereits beschriebenen Muster. Aus Gründen der Einfachheit gehen wir davon aus, dass mit dem vorherigen Code Elemente aus der Liste Incidents abgerufen wurden (und die Ergebnisse in _incidentListItems gespeichert werden). Im folgenden Codebeispiel wird der Status von Elementen in der Liste aktualisiert, um den Status Closedanzuzeigen.

        foreach (ListItem incident in _incidents)
        {
            incident["Status"] = "Closed";
            incident.Update();
        }

        _context.ExecuteQueryAsync(onQuerySucceeded, onQueryFailed);

Diese Beispiele zeigen, dass das verwaltete Clientobjektmodell den Entwicklungsprozess vereinfacht und eine umfassende Benutzerfreundlichkeit mithilfe des Silverlight-Frameworks ermöglicht.

Hinzufügen der Unterstützung bestimmter Silverlight 4-Features

Nachdem wir in unserem Szenario den allgemeinen Datenzugriff auf das Kundendienst-Dashboard ermöglicht haben, muss im nächsten Schritt die Unterstützung bestimmter Silverlight 4-Features hinzugefügt werden. In den folgenden Abschnitten wird die Unterstützung für das Drucken, das Rechtsklickfeature und die Zwischenablage hinzugefügt. Darüber hinaus gibt es noch weitere Features. Weitere Informationen zu den Silverlight-Funktionen finden Sie auf der Silverlight.NET-Website.

Aktivieren des Druckens mit Silverlight 4

Neu in Silverlight 4 ist eine API zum Drucken, mit der Sie das Drucken in Ihren Anwendungen aktivieren können. In früheren Versionen von Silverlight fehlte diese Unterstützung, weshalb ein erheblicher Aufwand erforderlich war, um diese Flexibilität zu kompensieren. Die Unterstützung des Druckens in Silverlight 4 ist einfach in der Handhabung und sehr flexibel.

Zum Aktivieren des Druckens verwenden Sie das PrintDocument-Objekt. Im folgenden Beispiel wird die Verwendung des PrintDocument-Objekts zum Drucken gezeigt.

So implementieren Sie das PrintDocument-Objekt von Silverlight 4

  1. Fügen Sie wie folgt der Datei MainPage.xaml ein Schaltflächen-Steuerelement hinzu.

                <Button x:Name="bttnPrint" Content="Print" Click="bttnPrint_Click" />

  2. Fügen Sie in der Datei MainPage.xaml.cs nach der Alert-Methode den folgenden Ereignishandler hinzu.

            private void bttnPrint_Click(object sender, RoutedEventArgs e)
        {
            PrintDocument printDoc = new PrintDocument();
            printDoc.PrintPage += (s, args) =>
            {
                args.PageVisual = LayoutRoot;
            };

            printDoc.Print();
        }

Dies sind die wichtigsten Punkte in diesem Beispiel:

  • Das PrintDocument-Objekt wird erstellt.

  • Ein Ereignishandler (in diesem Fall eine anonyme Methode) wird hinzugefügt, mit der das PrintPageEventArgs-Objekt in Abhängigkeit davon eingerichtet wird, was wie gedruckt werden soll.

  • Die Print-Methode des PrintDocument-Objekts wird aufgerufen.

Alternativ können Sie ein benutzerdefiniertes Drucklayout erstellen, das nicht dem standardmäßigen visuellen Layout der Silverlight-Anwendung entspricht. Für unser Szenario gehen wir davon aus, dass die Elemente aus der Liste Incident in einer Liste mit einem benutzerdefinierten Typ gespeichert sind.

            private List<Incident> _incidents = new List<Incident>();

Im PrintPage-Ereignishandler können Sie die Liste als ItemSource-Objekt für ein DataGrid-Objekt von Silverlight verwenden. Wie im folgenden Codebeispiel veranschaulicht können Sie das DataGrid-Objekt als PageVisual-Objekt für das PrintPageEventArgs-Objekt im PrintPage-Ereignishandler bereitstellen.

            printDoc.PrintPage += (s, args) =>
            {
                DataGrid dataGrid = new DataGrid();
                dataGrid.ItemsSource = _incidents;
                dataGrid.AutoGenerateColumns = true;
                
                args.PageVisual = dataGrid;
            };

In der folgenden Abbildung sind die Ergebnisse dargestellt, wenn Sie den Code durch Drucken in Microsoft OneNote 2010 testen.

Abbildung 12. Testen der Druckergebnisse der Datenrasteransicht in OneNote

Testen von Druckergebnissen

Implementieren der Rechtsklickunterstützung in Silverlight 4

In Silverlight 4 können Rechtsklick-Schaltflächenereignisse überschrieben werden. In früheren Versionen wurde wie in der folgenden Abbildung dargestellt beim Klicken mit der rechten Maustaste ein integriertes Menü angezeigt.

Abbildung 13. Standardmäßiges Silverlight-Kontextmenü

Standardmäßiges Kontextmenü

Die Möglichkeit, dieses Menü zu überschreiben und benutzerdefinierte Ereignisse festzulegen, bietet zusätzliche Optionen zum Anpassen von Benutzeroberflächen und zum Hinzufügen von Funktionalität.

Zum Implementieren von Rechtsklickereignissen müssen im Allgemeinen folgende Schritte ausgeführt werden:

  • Definieren einer Canvas, die Popup-Steuerelement mit dem für Rechtsklick-Schaltflächenereignisse anzuzeigenden Inhalt enthält.

  • Definieren der Reaktion auf die entsprechenden Mausereignisse, um die Sichtbarkeit und Platzierung des Popups zu kontrollieren.

Im folgenden Verfahren werden die einzelnen Schritte beschrieben.

So fügen Sie einer Silverlight-Anwendung benutzerdefinierte Rechtsklickereignisse hinzu

  1. Fügen Sie zunächst wie im folgenden Beispiel dargestellt der Datei MainPage.xaml.cs nach dem LayoutRoot-Steuerelement eine Canvas hinzu, die ein Popup-Steuerelement enthält.

            <Canvas x:Name="pnlPop" 
                Background="Transparent" 
                Visibility="Collapsed">
            <Popup x:Name="popMenu" IsOpen="False">
                <Border Background="LightGray" 
                        CornerRadius="5">
                    <StackPanel Margin="5">
                        <Button Content="Escalate to Supervisor" />
                        <Button Content="Email Customer" />
                    </StackPanel>
                </Border>
            </Popup>
        </Canvas>

    Mit diesem XML-Markup werden Steuerelemente definiert, die aus einem Rahmen mit abgerundeten Ecken und zwei Schaltflächen bestehen.

  2. Fügen Sie anschließend wie im folgenden Beispiel dargestellt dem übergeordneten Steuerelement Ereignishandler für die Ereignisse MouseRightButtonDown, MouseRightButtonUp und MouseLeftButtonDown hinzu.

        <Grid x:Name="LayoutRoot" 
          Background="White" 
          MouseRightButtonDown="LayoutRoot_MouseRightButtonDown" 
          MouseRightButtonUp="LayoutRoot_MouseRightButtonUp" 
          MouseLeftButtonDown="LayoutRoot_MouseLeftButtonDown">

  3. Fügen Sie der Datei MainPage.xaml.cs den Ereignishandler für das MouseRightButtonDown-Ereignis hinzu:

            private void LayoutRoot_MouseRightButtonDown(
            object sender, MouseButtonEventArgs e)
        {
            e.Handled = true;
        }
    Wichtiger HinweisWichtig

    Der Ereignishandler im vorherigen Codebeispiel ist erforderlich, obwohl er scheinbar keine große Funktion hat. Wenn das Steuerelement nicht für das MouseRightButtonDown-Ereignis ausgeführt wird, wird vom Silverlight-Kern nicht das MouseRightButtonUp-Ereignis für Ihre Anwendung ausgelöst.

  4. Fügen Sie den folgenden MouseLeftButtonDown-Ereignishandler der Datei MainPage.xaml.cshinzu.

            private void LayoutRoot_MouseLeftButtonDown(
            object sender, MouseButtonEventArgs e)
        {
            this.pnlPop.Visibility = System.Windows.Visibility.Collapsed;
            this.popMenu.IsOpen = false;
        }

In diesem Codebeispiel wird festgelegt, dass die Canvas reduziert angezeigt wird, und anschließend wird die IsOpen-Eigenschaft des Popup-Steuerelements auf False festgelegt, sodass beide ausgeblendet werden. Wenn der Benutzer nun an einer anderen Stelle in der Anwendung klickt, wird das Popup-Steuerelement ausgeblendet.

Abbildung 14. Popup-Sichtbarkeit bei Rechtsklick.

Popup-Anzeige bei Rechtsklick

Aktivieren von Zwischenablagevorgängen in Silverlight 4

Der Zugriff auf die Zwischenablage ist neu in Silverlight 4. Für den Zugriff auf die Zwischenablage in Silverlight 4 werden die statischen Methoden des Clipboard-Objekts verwendet. Für die Zwischenablage wird nur Text unterstützt. Verwenden Sie die GetText-Methode und die SetText-Methode, um den Text abzurufen bzw. festzulegen. Dies ist besonders hilfreich, um dem Benutzer das Kopieren von festem Text zu ermöglichen. In diesem Szenario fügen Sie mit dem folgenden Code die Unterstützung der Zwischenablage für die Liste Incident hinzu.

            Clipboard.SetText(incident.Customer + " - " +
                incident.Agent + " - " + 
                incident.Status);

Wenn die Silverlight 4-Anwendung mithilfe des Clipboard-Objekts auf die Zwischenablage zuzugreifen versucht, wird der Benutzer aufgefordert, den Zugriff auf die Zwischenablage zuzulassen. Hierbei handelt es sich um eine Sicherheitsabfrage, mit der die böswillige Verwendung der Zwischenablage verhindert werden soll.

Erstellen eines Silverlight-Webparts in SharePoint Foundation 2010

Damit verfügen wir über eine Silverlight 4-Anwendung mit vollem Funktionsumfang, mit der Daten aus einer SharePoint-Liste mithilfe des verwalteten Clientobjektmodells abgerufen werden. Im letzten Schritt wird die Anwendung in der SharePoint-Website bereitgestellt. Dazu verwenden Sie das standardmäßige Silverlight-Webpart. Früher mussten für die Bereitstellung von Silverlight-Anwendungen in SharePoint-Websites benutzerdefinierte Webparts geschrieben und verwaltet werden, von denen die Silverlight-Anwendungen genutzt wurden. Durch das in SharePoint Foundation 2010 enthaltene Silverlight-Webpart wird der Umfang an benutzerdefiniertem Code im Zusammenhang mit dem Bereitstellen von Silverlight-Anwendungen in SharePoint-Websites erheblich reduziert.

Sie müssen die XAP-Silverlight-Datei in einem Speicherort hosten, der für den Servercomputer mit SharePoint 2010 zugänglich ist. In diesem Szenario ist die Datei in einer Dokumentbibliothek gespeichert. Im folgenden Verfahren werden die einzelnen Schritte beschrieben.

So stellen Sie die Silverlight-Anwendung in einer SharePoint 2010-Website bereit

  1. Navigieren Sie zu der SharePoint-Website, in der Sie die Silverlight-Anwendung hosten möchten.

  2. Klicken Sie auf Websiteaktionen, und klicken Sie in der Liste auf Weitere Optionen.

  3. Klicken Sie im Fenster Erstellen unter Seite auf Neue Webpartseite.

  4. Nachdem Sie die Seite erstellt haben, klicken Sie wie in der folgenden Abbildung dargestellt auf der Seite an der Position, an der Sie das Silverlight-Webpart hinzufügen möchten, auf Webpart hinzufügen.

    Abbildung 15. Hinzufügen eines Webparts zur SharePoint-Webparts-Seite

    Hinzufügen eines Webparts

  5. Klicken Sie unter Kategorien auf die Kategorie Medien und Inhalt, und klicken Sie dann auf das Silverlight-Webpart.

  6. Wählen Sie wie in der folgenden Abbildung dargestellt in der Liste Webpart hinzufügen zu die gewünschte Position auf der Seite aus, und klicken Sie dann auf Hinzufügen.

    Abbildung 16. Hinzufügen eines Webparts

    Hinzufügen eines Webparts

  7. Geben Sie im Dialogfeld den Pfad zur XAP-Silverlight-Datei ein, und klicken Sie dann auf OK.

    Abbildung 17. Eingeben des Pfads zur XAP-Silverlight-Datei

    Eingeben des Pfads

    Bearbeiten Sie nach dem Hinzufügen des Silverlight-Webparts die Eigenschaften entsprechend Ihren Anforderungen.

  8. Klicken Sie wie in der folgenden Abbildung dargestellt in der Kopfzeile des Silverlight-Webparts auf den Pfeil nach unten, und wählen Sie Webpart bearbeiten aus, um den Eigenschaftenbereich zu öffnen.

    Abbildung 18. Bearbeiten des Silverlight-Webparts auf der SharePoint-Webparts-Seite

    Bearbeiten des Silverlight-Webparts

  9. Ändern Sie die Eigenschaften bei Bedarf, und klicken Sie dann auf OK.

    Abbildung 19. Konfigurieren der Eigenschaften für das Silverlight-Webpart

    Konfigurieren der Silverlight-Webparteigenschaften

Die Silverlight-Anwendung sollte wie in der folgenden Abbildung dargestellt auf der SharePoint-Webparts-Seite angezeigt werden.

Abbildung 20. Silverlight-Anwendung in einem Webpart auf der SharePoint-Webparts-Seite

Silverlight-Anwendung in einem Webpart

Schlussbemerkung

In diesem Artikel wird gezeigt, wie hilfreich das verwaltete Clientobjektmodell von SharePoint Foundation 2010 ist, um die Flexibilität und Funktionalität erheblich zu erweitern. Das verwaltete Clientobjektmodell vereinfacht die Nutzung von SharePoint-Daten und SharePoint-Funktionalität. In Kombination mit der Leistungsfähigkeit von Silverlight 4 und seiner umfassenden Benutzeroberfläche und dynamischen Benutzererfahrung können die Features von SharePoint und Silverlight optimal genutzt werden. Zusammenfassend lässt sich sagen, dass in diesem Artikel ein Modell für die Verwendung des verwalteten Clientobjektmodells vorgestellt wird, indem Beispiele zum Erstellen, Hinzufügen und Bearbeiten von SharePoint-Listenelementen vorgestellt werden. Anschließend wurde die Verwendungsweise neuer Features in Silverlight 4 beschrieben: Unterstützung des Druckens, die Rechtsklickunterstützung und der Zugriff auf die Zwischenablage. Schließlich wurden die Schritte zum Bereitstellen der Silverlight-Anwendungen mithilfe des neuen Silverlight-Webparts in SharePoint Foundation 2010 behandelt. Diese neuen Funktionen bieten ein erhebliches Potenzial für neue und flexiblere Verwendungsmöglichkeiten von SharePoint Foundation 2010, und zwar ohne den Aufwand, der bisher beim Entwickeln von Clientanwendungen für SharePoint-Produkte und -Technologien angefallen ist.

Weitere Ressourcen

Informationen zum Autor

Casey Margell entwickelt seit fast einem Jahrzehnt benutzerdefinierte Software und nutzt dazu eine Reihe von Technologien. In letzter Zeit hat er sich mit Silverlight und SharePoint und der Integration verschiedener Technologien und Systeme befasst. Casey hat einen Hochschulabschluss (Bachelor) in "Computing and Software Systems" von der University of Washington, Bothell Campus.