Codeausschnitt: Abrufen von Elementdaten aus einer externen Liste auf dem Client
Letzte Änderung: Montag, 19. April 2010
Gilt für: SharePoint Server 2010
Inhalt dieses Artikels
Beschreibung
Voraussetzungen
So verwenden Sie dieses Beispiel
Beschreibung
Der folgende Codeausschnitt zeigt, wie Sie mit dem SharePoint-Clientobjektmodell Listenelementdaten aus einer externen Liste auf dem Clientcomputer abrufen.
.gif "Wichtiger Hinweis") Wichtig |
|---|
Wenn Sie die ClientContext.Load-Methode mit dem Standardwert zum Abrufen von ListItem-Daten aus einer externen Liste verwenden, wird die folgende Fehlermeldung angezeigt: "Der angegebene Schlüssel war nicht im Wörterbuch angegeben". Stattdessen müssen Sie die gewünschten Felder explizit für CamlQuery und die ClientContext.Load-Methode angeben. |
Voraussetzungen
Microsoft SharePoint Server 2010 oder Microsoft SharePoint Foundation 2010 auf dem Server
Mindestens eine externe Liste auf dem Server
Microsoft Office Professional Plus 2010 und Microsoft .NET Framework 3.5 auf dem Clientcomputer
Microsoft Visual Studio
So verwenden Sie dieses Beispiel
Starten Sie Visual Studio auf dem Clientcomputer, und erstellen Sie ein C#-Konsolenanwendungsprojekt. Wählen Sie beim Erstellen des Projekts .NET Framework 3.5 aus.
Klicken Sie im Menü Ansicht auf Eigenschaftenseiten, um die Projekteigenschaften aufzurufen.
Wählen Sie auf der Registerkarte Erstellen unter Zielplattform die Option Any CPU aus.
Schließen Sie das Fenster mit den Projekteigenschaften.
Entfernen Sie im Projektmappen-Explorer unter Verweise sämtliche Projektverweise bis auf System und System.Core.
Fügen Sie dem Projekt die folgenden Verweise hinzu:
Microsoft.SharePoint.Client
Microsoft.SharePoint.Client.Runtime
System.Data.Linq
System.XML
Ersetzen Sie den automatisch generierten Code in Program.cs durch den Code am Ende dieser Prozedur.
Ersetzen Sie die Werte von <TargetSiteUrl> und <TargetListName> durch gültige Werte.
Speichern Sie das Projekt.
Kompilieren Sie das Projekt, und führen Sie es aus.
using System;
using Microsoft.SharePoint.Client;
using System.Linq.Expressions;
using System.Collections.Generic;
using System.Xml;
using System.IO;
using System.Text;
using System.Globalization;
namespace Microsoft.SDK.Sharepoint.Samples
{
/// <summary>
/// This example shows how to retrieve list item data
/// from an external list.
///
/// You'll need to explicitly specify the field data in both
/// the CAML query and also ClientContext.Load.
/// </summary>
class Program
{
// Note: Replace these with your actual Site URL and List name.
private static string TargetSiteUrl = "<TargetSiteUrl>";
private static string TargetListName = "<TargetListName>";
/// <summary>
/// Example to show using CSOM to retrieve external List data.
/// </summary>
static void Main(string[] args)
{
ClientContext clientContext = new ClientContext(TargetSiteUrl);
List externalList = clientContext.Web.Lists.GetByTitle(
TargetListName);
// To properly construct the CamlQuery and
// ClientContext.LoadQuery,
// we need some View data of the Virtual List.
// In particular, the View will give us the CamlQuery
// Method and Fields.
clientContext.Load(
externalList.Views,
viewCollection => viewCollection.Include(
view => view.ViewFields,
view => view.HtmlSchemaXml));
// This tells us how many list items we can retrieve.
clientContext.Load(clientContext.Site,
s => s.MaxItemsPerThrottledOperation);
clientContext.ExecuteQuery();
// Let's just pick the first View.
View targetView = externalList.Views[0];
string method = ReadMethodFromViewXml(
targetView.HtmlSchemaXml);
ViewFieldCollection viewFields = targetView.ViewFields;
CamlQuery vlQuery = CreateCamlQuery(
clientContext.Site.MaxItemsPerThrottledOperation,
method,
viewFields);
Expression<Func<ListItem, object>>[] listItemExpressions =
CreateListItemLoadExpressions(viewFields);
ListItemCollection listItemCollection =
externalList.GetItems(vlQuery);
// Note: Due to limitation, you currently cannot use
// ClientContext.Load.
// (you'll get InvalidQueryExpressionException)
IEnumerable<ListItem> resultData = clientContext.LoadQuery(
listItemCollection.Include(listItemExpressions));
clientContext.ExecuteQuery();
foreach (ListItem li in resultData)
{
// Now you can use the ListItem data!
// Note: In the CamlQuery, we specified RowLimit of
// MaxItemsPerThrottledOperation.
// You may want to check whether there are other rows
// not yet retrieved.
}
}
/// <summary>
/// Parses the viewXml and returns the Method value.
/// </summary>
private static string ReadMethodFromViewXml(string viewXml)
{
XmlReaderSettings readerSettings = new XmlReaderSettings();
readerSettings.ConformanceLevel = ConformanceLevel.Fragment;
XmlReader xmlReader = XmlReader.Create(
new StringReader(viewXml), readerSettings);
while (xmlReader.Read())
{
switch (xmlReader.NodeType)
{
case XmlNodeType.Element:
if (xmlReader.Name == "Method")
{
while (xmlReader.MoveToNextAttribute())
{
if (xmlReader.Name == "Name")
{
return xmlReader.Value;
}
}
}
break;
}
}
throw new Exception("Unable to find Method in View XML");
}
/// <summary>
/// Creates a CamlQuery based on the inputs.
/// </summary>
private static CamlQuery CreateCamlQuery(
uint rowLimit, string method, ViewFieldCollection viewFields)
{
CamlQuery query = new CamlQuery();
XmlWriterSettings xmlSettings = new XmlWriterSettings();
xmlSettings.OmitXmlDeclaration = true;
StringBuilder stringBuilder = new StringBuilder();
XmlWriter writer = XmlWriter.Create(
stringBuilder, xmlSettings);
writer.WriteStartElement("View");
// Specifies we want all items, regardless of folder level.
writer.WriteAttributeString("Scope", "RecursiveAll");
writer.WriteStartElement("Method");
writer.WriteAttributeString("Name", method);
writer.WriteEndElement(); // Method
if (viewFields.Count > 0)
{
writer.WriteStartElement("ViewFields");
foreach (string viewField in viewFields)
{
if (!string.IsNullOrEmpty(viewField))
{
writer.WriteStartElement("FieldRef");
writer.WriteAttributeString("Name", viewField);
writer.WriteEndElement(); // FieldRef
}
}
writer.WriteEndElement(); // ViewFields
}
writer.WriteElementString(
"RowLimit", rowLimit.ToString(CultureInfo.InvariantCulture));
writer.WriteEndElement(); // View
writer.Close();
query.ViewXml = stringBuilder.ToString();
return query;
}
/// <summary>
/// Returns an array of Expression used in
/// ClientContext.LoadQuery to retrieve
/// the specified field data from a ListItem.
/// </summary>
private static Expression<Func<ListItem, object>>[]
CreateListItemLoadExpressions(
ViewFieldCollection viewFields)
{
List<Expression<Func<ListItem, object>>> expressions =
new List<Expression<Func<ListItem, object>>>();
foreach (string viewFieldEntry in viewFields)
{
// Note: While this may look unimportant,
// and something we can skip, in actuality,
// we need this step. The expression should
// be built with local variable.
string fieldInternalName = viewFieldEntry;
Expression<Func<ListItem, object>>
retrieveFieldDataExpression =
listItem => listItem[fieldInternalName];
expressions.Add(retrieveFieldDataExpression);
}
return expressions.ToArray();
}
}
}