Übersicht über den Datenabruf

Artikel
09/24/2014

Letzte Änderung: Donnerstag, 18. November 2010

Gilt für: SharePoint Foundation 2010

Inhalt dieses Artikels
Abfragesyntax im Gegensatz zu Methodensyntax
Verwenden von Abfragezeichenfolgen in "ECMAScript"
Direkter Ladevorgang im Gegensatz zu abfragbarem Ladevorgang
So rufen Sie Objekte ab
So aktualisieren Sie Objekte
So rufen Sie Listenelemente ab
So aktualisieren Sie Listenelemente
Asynchrone Verarbeitung

Verfügbar in SharePoint Online

Sie können das neue Clientobjektmodell zum Abrufen von Eigenschaften für ein bestimmtes SharePoint-Clientobjekt (ClientObject, oder in ECMAScript (JavaScript, JScript)ClientObject), zum Abrufen von untergeordneten Objekten und ihren verbundenen Eigenschaften oder zum Abrufen von untergeordneten Elementen in einer Auflistung verwenden. Im Objektmodell wird explizite Datenabrufsemantik verwendet, die zum Abrufen von funktionsfähigen Daten befolgt werden muss. Von den Clientobjektmodellen werden keine abgerufenen Daten dauerhaft lokal auf dem Client gespeichert.

Das Durchführen eines Datenabrufs umfasst das folgende Verfahren:

Zurückgeben des Kontexts für eine Clientanforderung durch Verwenden des ClientContext()-Konstruktors (JavaScript: ClientContext(serverRelativeUrl)).
Verwenden des Objektmodells zum Angeben eines abzurufenden Objekts oder eines Objekts, von dem Daten abgerufen werden sollen.
Laden des Objekts oder der Auflistung über einen direkten Ladevorgang, der die Load<T>(T, []) (JavaScript: load(clientObject))-Methode zum Zurückgeben eines bestimmten Objekts, einer Auflistung oder Daten verwendet, oder über einen abfragbaren Ladevorgang, der die LoadQuery() (JavaScript: loadQuery(clientObjectCollection, exp))-Methode zum Zurückgeben einer auflistbaren Sammlung von Objekten verwendet.
Ausführen der Abfrage durch Aufrufen der synchronen ExecuteQuery()-Methode in der verwalteten .NET-Version des Clientobjektmodells oder wenn, in der Silverlight-Version, Code von Threads ausgeführt wird, von denen die Benutzeroberfläche (User Interface, UI) nicht geändert wird. In der JavaScript-Version des Objektmodells oder beim Ändern der Benutzeroberfläche durch die Silverlight-Version verwendet der Datenabruf eine asynchrone Rückrufmodell, und Sie müssen die ExecuteQueryAsync(ClientRequestSucceededEventHandler, ClientRequestFailedEventHandler)-Methode (JavaScript: executeQueryAsync(succeededCallback, failedCallback)) aufrufen, die Parameter für Methoden enthält, die den Erfolg oder Fehler der Anforderung behandeln. Wenn der Methodenaufruf zum Ausführen der Abfrage zurückgegeben wird (entweder synchron oder asynchron), können Sie auf die Ergebnisse der Abfrage in dem Objekt zugreifen, von dem aus die Abfrage initiiert wurde.

Abfragesyntax im Gegensatz zu Methodensyntax

Beide Formen der LINQ-Syntax (Language-Integrated Query) - Abfragesyntax und Methodensyntax - können im verwalteten Clientobjektmodell zum Laden einzelner Objekte, spezifischer Objekteigenschaften oder auflistbaren Objektsammlungen verwendet werden.

Hinweis
Bei der Verwendung von LINQ-Abfragen im Clientobjektmodell sollten zwei Aspekte berücksichtigt werden: Wenn Sie LINQ zum Erstellen von Abfragen im Clientobjektmodell verwenden, verwenden Sie LINQ to Objects, nicht den LINQ to SharePoint-Anbieter, der nur verwendet werden kann, wenn Sie Code für das Serverobjektmodell schreiben. Wenn Ihre Abfrage so konzipiert ist, dass eine Teilmenge der Listenelemente aus einer Liste zurückgegeben werden sollen, ist die Verwendung einer CAML-Abfrage anstelle einer LINQ-Abfrage effizienter. Grund dafür ist, dass alle Listenelemente von der Inhaltsdatenbank an den Front-End-Webserver gesendet und in den Arbeitsspeicher geladen werden. Nur dann wird der LINQ-Filter angewendet. Bei einer CAM-Abfrage wird auf dem Datenbankserver gefiltert. Dieser Faktor ist nur für Abfragen von Bedeutung, die die Elemente in einer Liste filtern. Andere Arten von LINQ-Abfragen, wie z. B. die Rückgabe einer Teilmenge der Listen von einer Website, sind effizienter.

Bei der Verwendung von LINQ-Abfragen im Clientobjektmodell sollten zwei Aspekte berücksichtigt werden:

Wenn Sie LINQ zum Erstellen von Abfragen im Clientobjektmodell verwenden, verwenden Sie LINQ to Objects, nicht den LINQ to SharePoint-Anbieter, der nur verwendet werden kann, wenn Sie Code für das Serverobjektmodell schreiben.
Wenn Ihre Abfrage so konzipiert ist, dass eine Teilmenge der Listenelemente aus einer Liste zurückgegeben werden sollen, ist die Verwendung einer CAML-Abfrage anstelle einer LINQ-Abfrage effizienter. Grund dafür ist, dass alle Listenelemente von der Inhaltsdatenbank an den Front-End-Webserver gesendet und in den Arbeitsspeicher geladen werden. Nur dann wird der LINQ-Filter angewendet. Bei einer CAM-Abfrage wird auf dem Datenbankserver gefiltert. Dieser Faktor ist nur für Abfragen von Bedeutung, die die Elemente in einer Liste filtern. Andere Arten von LINQ-Abfragen, wie z. B. die Rückgabe einer Teilmenge der Listen von einer Website, sind effizienter.

Abfragesyntax kann nur in der LoadQuery()-Methode verwendet werden. Hierzu sind zwei Schritte erforderlich: das Definieren des Abfrageausdrucks und das Abrufen des Abfrageergebnisses. Dieser Prozess wird im folgenden Codebeispiel gezeigt, in dem alle Listen der aktuellen Website zurückgegeben werden, die einen definierten Titel besitzen.

var query = from list 
    in clientContext.Web.Lists
    where list.Title != null
    select list;

var result = clientContext.LoadQuery(query);
clientContext.ExecuteQuery();

Dim query = From list In clientContext.Web.Lists _ 
    Where list.Title IsNot Nothing _ 
    Select list

Dim result = clientContext.LoadQuery(query)
clientContext.ExecuteQuery()

Die Methodensyntax kann sowohl mit der Load<T>(T, [])- als auch mit der LoadQuery()-Methode verwendet werden. Sie verwendet Lambdaausdrücke. Im folgenden Beispiel wird die Methodensyntax zum Definieren derselben Abfrage nach Listen mit einem Titel verwendet.

clientContext.Load(clientContext.Web, 
    website => website.Lists.Include(
        list => list.Title).Where(
            list => list.Title != null));

clientContext.ExecuteQuery();

clientContext.Load(clientContext.Web, _
    Function(website) website.Lists.Include( _
    Function(list) list.Title).Where( _
    Function(list) list.Title IsNot Nothing))

    clientContext.ExecuteQuery()

Im vorherigen Beispiel wird die Verwendung der Include<TSource>(IQueryable<TSource>, [])-Methode zum Einschränken der Eigenschaften gezeigt, die von einer Objektsammlung zurückgegeben wird. Dadurch wird die Leistung verbessert. Von der Abfrage werden nur die Titel der Listen zurückgegeben, die einen Titel besitzen.

Im folgenden Beispiel wird die Abfragesyntax zum Abrufen von filterbaren Feldern einer Liste verwendet, die nicht ausgeblendet sind.

FieldCollection collField = oList.Fields;

var query = from field
        in collField
        where field.Hidden == false
        && field.Filterable == true
        select field;

var result = clientContext.LoadQuery(query);

clientContext.ExecuteQuery();

Dim collField As FieldCollection = oList.Fields

Dim query = From field In collField _ 
    Where field.Hidden = False AndAlso field.Filterable = True _ 
    Select field

Dim result = clientContext.LoadQuery(query)

clientContext.ExecuteQuery()

Im folgenden Beispiel wird dieselbe Abfrage wie im vorherigen Beispiel ausgeführt, hier wird jedoch die Methodensyntax in der Load<T>(T, [])-Methode verwendet.

clientContext.Load(oList,
    list => list.Fields.Where(
    field => field.Hidden == false
        && field.Filterable == true));

    clientContext.ExecuteQuery();

clientContext.Load(oList, Function(list) list.Fields.Where( _
    Function(field) field.Hidden = False _
    AndAlso field.Filterable = True))

    clientContext.ExecuteQuery()

Verwenden von Abfragezeichenfolgen in "ECMAScript"

Die JavaScript-Methoden zum Abrufen von Objekten und Daten akzeptieren keine LINQ-Syntax, Sie können jedoch einen Zeichenfolgenausdruck zum Definieren einer Standardabfrage verwenden. Im folgenden Beispiel wird die load(clientObject)-Methode zum Abrufen des Titels und der ID einer bestimmten Liste verwendet.

clientContext.load(oList, 'Title' ,'Id');

clientContext.executeQueryAsync(Function.createDelegate(this, this.onQuerySucceeded), Function.createDelegate(this, this.onQueryFailed));

Geben Sie bei Verwendung einer Listenauflistung Include an, um nur den Titel und die ID für jede Liste zurückzugeben, wie im folgenden Beispiel zu sehen.

clientContext.load(collList, 'Include(Title, Id)');

Alternativ können Sie Felder der *PropertyNames-Klasse verwenden, die mit dem Objekt oder der Auflistung verbunden ist, um anzugeben, welche Eigenschaften zurückgegeben werden sollen, wie im folgenden Beispiel zu sehen:

var propTitle = SP.ListPropertyNames.title;
var propId = SP.ListPropertyNames.id;
clientContext.load(collList, 'Include(' + propTitle + ', ' + propId + ')');

Sie können auch das Include-Schlüsselwort in die übergebene Abfragezeichenfolge schachteln. Im folgenden Beispiel wird die loadQuery(clientObjectCollection, exp)-Methode zum Abrufen der Titel aller Listen sowie der Titel und Beschreibungen aller Felder in allen Listen verwendet.

myListArray = clientContext.loadQuery(collList, 
    'Include(Title,Fields.Include(Title,Description))');

Direkter Ladevorgang im Gegensatz zu abfragbarem Ladevorgang

LINQ-basierte Abfragen im Clientobjektmodell können auf zwei Arten verwendet werden: über einen direkten Ladevorgang und über einen abfragbaren Ladevorgang. Von einem abfragbaren Ladevorgang werden Daten in einem weiteren Ergebnisarray zurückgegeben, während die Daten bei einem direkten Ladevorgang im Objekt selbst zurückgegeben werden.

Bei einem direkten Ladevorgang wird eine Anforderung zum Laden von Objekten und ihren Daten ausgeführt, und die Objektidentität bleibt über mehrere Anforderungen erhalten. Direkte Ladevorgänge werden über die Load<T>(T, [])-Methode eines Clientkontexts ausgeführt. Im folgenden Beispiel werden alle Listen der aktuellen Website sowie alle ihre Standardeigenschaften geladen. Nach Ausführung der Abfrage besitzt der Code Zugriff auf die gesamte Auflistung und die Standardlisteneigenschaften:

clientContext.Load(clientContext.Web.Lists); 
clientContext.ExecuteQuery();

In einem abfragbaren Ladevorgang ist die Abfrage von den zurückgegebenen Ergebnissen getrennt. Anders als bei einem direkten Ladevorgang bleibt die Objektidentität in einem abfragbaren Ladevorgang nicht beibehalten, sodass die zurückgegebenen Objekte vom Code selbst verwaltet werden müssen. Im folgenden Beispiel wird Abfragesyntax zum Zurückgeben aller Listen der Website verwendet.

var query = from list 
    in clientContext.Web.Lists 
    select list;

var result = clientContext.LoadQuery(query);

clientContext.ExecuteQuery();

Dim query = From list In clientContext.Web.Lists _ 
    Select list

Dim result = clientContext.LoadQuery(query)

clientContext.ExecuteQuery()

In diesem Beispiel wird result mit einer IEnumerable<T>-Schnittstelle von List-Objekten gefüllt, die der Code verwenden kann und selbst verwalten muss. Beachten Sie, dass context.Web.Lists leer bleibt und weiterhin die Anzahl 0 zurückgibt. Wenn Sie die Listenanzahl abfragen möchten, müssen Sie Count() der IEnumerable<T>-Schnittstelle verwenden.

So rufen Sie Objekte ab

Im folgenden Beispiel wird das Laden eines Objekts zum Zugriff auf seine Eigenschaften gezeigt. Da das Listenobjekt direkt geladen wird, kann auf alle Standardeigenschaften der Liste zugegriffen werden.

ClientContext clientContext =  new ClientContext("http://MyServer/sites/MySiteCollection");
Web oWebsite = clientContext.Web;
ListCollection collList = oWebsite.Lists;

List oList = collList.GetByTitle("Announcements");

clientContext.Load(oList);

clientContext.ExecuteQuery();

Console.WriteLine("Title: {0} Created: {1}", oList.Title, oList.Created);

Dim clientContext As New ClientContext("http://MyServer/sites/MySiteCollection")
Dim oWebsite As Web = clientContext.Web
Dim collList As ListCollection = oWebsite.Lists

Dim oList As List = collList.GetByTitle("Announcements")

clientContext.Load(oList)

clientContext.ExecuteQuery()

Console.WriteLine("Title: {0} Created: {1}", oList.Title, oList.Created)

function retrieveWebSite() {
    var clientContext = new SP.ClientContext('/sites/MySiteCollection');
    var oWebsite = clientContext.get_web();
    var collList = oWebsite.get_lists();

    this.oList = collList.getByTitle('Announcements');
    clientContext.load(oList);

    clientContext.executeQueryAsync(Function.createDelegate(this, this.onQuerySucceeded), Function.createDelegate(this, this.onQueryFailed));
}

function onQuerySucceeded(sender, args) {
    alert('Title: ' + oList.get_title() + ' Created: ' + oList.get_created());
}

function onQueryFailed(sender, args) {
    alert('Request failed. ' + args.get_message() + '\n' + args.get_stackTrace());
}

Einige Eigenschaften sind beim Abrufen bestimmter Objekte standardmäßig nicht verfügbar, und zum Zugreifen auf diese Eigenschaften müssen diese explizit geladen werden. Im vorherigen Beispiel wird ein bestimmtes Listenobjekt geladen, und es kann auf beide Eigenschaften zugegriffen werden, da sie standardmäßig im Objekt verfügbar sind. Falls jedoch versucht wird, auf Eigenschaften zuzugreifen, die nicht standardmäßig verfügbar sind, z. B. OnQuickLaunch (JavaScript: onQuickLaunch), wird eine Ausnahme vom Typ PropertyOrFieldNotInitializedException zurückgegeben. In der folgenden Tabelle sind Eigenschaften aufgeführt, die beim Abrufen des Objekts nicht standardmäßig verfügbar sind.

Objekt	Eigenschaften
Folder	ContentTypeOrder (JavaScript: contentTypeOrder), UniqueContentTypeOrder (JavaScript: uniqueContentTypeOrder)
List	BrowserFileHandling (JavaScript: browserFileHandling), DataSource (JavaScript: dataSource), EffectiveBasePermissions (JavaScript: effectiveBasePermissions), HasUniqueRoleAssignments (JavaScript: hasUniqueRoleAssignments), IsSiteAssetsLibrary (JavaScript: isSiteAssetsLibrary), OnQuickLaunch (JavaScript: onQuickLaunch), RoleAssignments (JavaScript: roleAssignments), SchemaXml (JavaScript: schemaXml), ValidationFormula (JavaScript: validationFormula), ValidationMessage (JavaScript: validationMessage)
ListItem	DisplayName (JavaScript: displayName), EffectiveBasePermissions (JavaScript: effectiveBasePermissions), HasUniqueRoleAssignments (JavaScript: hasUniqueRoleAssignments), RoleAssignments (JavaScript: roleAssignments)
SecurableObject	HasUniqueRoleAssignments (JavaScript: hasUniqueRoleAssignments), RoleAssignments (JavaScript: roleAssignments)
Site	Usage (JavaScript: usage)
Web	EffectiveBasePermissions (JavaScript: effectiveBasePermissions), HasUniqueRoleAssignments (JavaScript: hasUniqueRoleAssignments), RoleAssignments (JavaScript: roleAssignments)

Zusätzlich zu den in der vorherigen Tabelle aufgeführten Eigenschaften stehen auch übergeordnete oder untergeordnete Objekte, auf die über die Eigenschaften eines Objekts zugegriffen werden kann, nicht standardmäßig zur Verfügung. Daher wird beim Hinzufügen von oList.Items.Count im vorherigen Beispiel immer 0 in der Konsole angezeigt anstatt der tatsächlichen Anzahl von Elementen, falls welche vorhanden sind. Der Grund hierfür liegt darin, dass die Listenelementauflistung nicht speziell in der Load<T>(T, [])-Methode (JavaScript: load(clientObject)) angefordert wird.

Wenn Sie auf Eigenschaften zugreifen möchten, die beim Zurückgeben eines Objekts nicht standardmäßig verfügbar sind, müssen Sie diese Eigenschaften explizit anfordern. Die folgende Bearbeitung des vorherigen Load<T>(T, []) (JavaScript: load(clientObject))-Methodenaufrufs macht OnQuickLaunch (JavaScript: onQuickLaunch) verfügbar.

clientContext.Load(oList,
    list => list.Title,
    list => list.Created,
    list => list.OnQuickLaunch);

clientContext.Load(oList, _
    Function(list) list.Title, _
    Function(list) list.Created, _
    Function(list) list.OnQuickLaunch)

clientContext.load(oList, 'Title', 'Created', 'OnQuickLaunch');

Im verwalteten oder Silverlight-Objektmodell gilt Folgendes: Wenn Sie mit einer Objektsammlung arbeiten, verwenden Sie die IncludeWithDefaultProperties<TSource>(IQueryable<TSource>, [])-Methode in jeder geladenen Liste, um Eigenschaften einzuschließen, die nicht standardmäßig verfügbar sind.

Hinweis
Das JavaScript-Objektmodell besitzt keine Entsprechung zu einer IncludeWithDefaultProperties<TSource>(IQueryable<TSource>, [])-Methode.

Im folgenden Beispiel werden dieselben Informationen wie im vorherigen Beispiel für jede Liste der Website angezeigt.

ClientContext clientContext =  new ClientContext("http://MyServer/sites/MySiteCollection");
Web oWebsite = clientContext.Web;
ListCollection collList = oWebsite.Lists;

clientContext.Load(collList,
    lists => lists.IncludeWithDefaultProperties(
        list => list.OnQuickLaunch));

clientContext.ExecuteQuery();

foreach (List oList in collList)
{
    Console.WriteLine("Title: {0} Created: {1} QuickLaunch: {2}", oList.Title, oList.Created, oList.OnQuickLaunch);
}

Dim clientContext As New ClientContext("http://MyServer/sites/MySiteCollection")
Dim oWebsite As Web = clientContext.Web
Dim collList As ListCollection = oWebsite.Lists

clientContext.Load(collList, _
    Function(lists) lists.IncludeWithDefaultProperties( _
        Function(list) list.OnQuickLaunch))

clientContext.ExecuteQuery()

Dim oList As List
For Each oList In collList
    Console.WriteLine("Title: {0} Created: {1} QuickLaunch: {2}", oList.Title, oList.Created, oList.OnQuickLaunch)
Next oList

So aktualisieren Sie Objekte

Das Ändern eines Objekts über das Clientobjektmodell ist vergleichbar mit dem Ändern eines Objekts über das Serverobjektmodell. In beiden Fällen muss eine Update-Methode aufgerufen werden. Beim Clientobjektmodell werden die Änderungen jedoch erst übernommen, wenn das Objekt geladen wurde und ExecuteQuery() oder ExecuteQueryAsync(ClientRequestSucceededEventHandler, ClientRequestFailedEventHandler) (JavaScript: executeQueryAsync(succeededCallback, failedCallback)) aufgerufen wird. Im folgenden Beispiel wird die Beschreibung der geladenen Liste geändert.

ClientContext clientContext =  new ClientContext("http://MyServer/sites/MySiteCollection");
Web oWebsite = clientContext.Web;
ListCollection collList = oWebsite.Lists;

List oList = collList.GetByTitle("My List");

oList.Description = "Changed description...";

oList.Update();

clientContext.ExecuteQuery();

Dim clientContext As New ClientContext("http://MyServer/sites/MySiteCollection")
Dim oWebsite As Web = clientContext.Web
Dim collList As ListCollection = oWebsite.Lists

Dim oList As List = collList.GetByTitle("My List")

oList.Description = "Changed description..."

oList.Update()

clientContext.ExecuteQuery()

function updateList() {
    var clientContext = new SP.ClientContext('/sites/MySiteCollection');
    var oWebsite = clientContext.get_web();
    var collList = oWebsite.get_lists();

    this.oList = collList.getByTitle('My List');

    oList.set_title('Changed description...');

    oList.update();

    clientContext.load(oList);

    clientContext.executeQueryAsync(Function.createDelegate(this, this.onQuerySucceeded), Function.createDelegate(this, this.onQueryFailed));
}

function onQuerySucceeded() {
    alert(oList.get_title() + ' created.');
}

function onQueryFailed(sender, args) {
    alert('Request failed. ' + args.get_message() + '\n' + args.get_stackTrace());
}

Beachten Sie, dass im vorherigen Beispiel zum Ändern eines Objekts das Objekt nicht auf dem Client geladen werden muss.

So rufen Sie Listenelemente ab

Das Abrufen zahlreicher Listenelemente erfolgt am effizientesten mithilfe einer Abfrage in Collaborative Application Markup Language (CAML), um die zurückzugebenden Elemente anzugeben. Verwenden Sie die CamlQuery-Klasse (JavaScript: CamlQuery), um die Abfrage zu definieren, und übergeben Sie die Abfrage an die GetItems(CamlQuery)-Methode (JavaScript: getItems(query)).

Im folgenden Beispiel wird die CamlQuery-Klasse (JavaScript: CamlQuery) verwendet, um die ersten 50 Elemente in der Liste zurückzugeben, deren ID kleiner ist als 100. Mit der Load<T>(T, [])-Methode wird IncludeWithDefaultProperties<TSource>(IQueryable<TSource>, []) angegeben, um das Abrufen von DisplayName einzuschließen.

ClientContext clientContext =  new ClientContext("http://MyServer/sites/MySiteCollection");
Web oWebsite = clientContext.Web;
ListCollection collList = oWebsite.Lists;

List oList = collList.GetByTitle("My List");

CamlQuery camlQuery = new CamlQuery();
camlQuery.ViewXml = "<View><Query><Where><Leq>" +
    "<FieldRef Name='ID'/><Value Type='Number'>100</Value>" +
    "</Leq></Where></Query><RowLimit>50</RowLimit></View>";

ListItemCollection collListItem = oList.GetItems(camlQuery);

clientContext.Load(collListItem,
    items => items.IncludeWithDefaultProperties(
    item=>item.DisplayName));

clientContext.ExecuteQuery();

foreach (ListItem oListItem in collListItem)
{
    Console.WriteLine("ID: {0} Display name: {1}", oListItem.Id, oListItem.DisplayName);
}

Dim clientContext As New ClientContext("http://MyServer/sites/MySiteCollection")
Dim oWebsite As Web = clientContext.Web
Dim collList As ListCollection = oWebsite.Lists

Dim oList As List = collList.GetByTitle("My List")

Dim camlQuery As New CamlQuery()
camlQuery.ViewXml = "<View><Query><Where><Leq>" + _
    "<FieldRef Name='ID'/><Value Type='Number'>100</Value>" + _
    "</Leq></Where></Query><RowLimit>50</RowLimit></View>"

Dim collListItem As ListItemCollection = oList.GetItems(camlQuery)

clientContext.Load(collListItem, _
    Function(items) items.IncludeWithDefaultProperties( _
        Function(item) item.DisplayName))

clientContext.ExecuteQuery()

Dim oListItem As ListItem
For Each oListItem In collListItem
    Console.WriteLine("ID: {0} Display name: {1}", oListItem.Id, oListItem.DisplayName)
Next oItem

Da das JavaScript-Objektmodell keine IncludeWithDefaultProperties<TSource>(IQueryable<TSource>, [])-Methode besitzt, wird im folgenden Beispiel Include mit der load(clientObject)-Methode verwendet, um das Abrufen der ID und des Anzeigenamens für jedes Listenelement anzugeben.

function retrieveListItems() {

    var clientContext = new SP.ClientContext('/sites/MySiteCollection');
    var oList = clientContext.get_web().get_lists().getByTitle('My List');
        
    var camlQuery = new SP.CamlQuery();
    camlQuery.set_viewXml('<View><Query><Where><Leq>' + 
        '<FieldRef Name=\'ID\'/><Value Type=\'Number\'>100</Value>' + 
        '</Leq></Where></Query><RowLimit>50</RowLimit></View>');

    this.collListItem = oList.getItems(camlQuery);
        
    clientContext.load(collListItem, 'Include(Id, DisplayName)');
        
    clientContext.executeQueryAsync(Function.createDelegate(this, this.onQuerySucceeded), Function.createDelegate(this, this.onQueryFailed));        
        
}

function onQuerySucceeded(sender, args) {

    var listItemInfo = '';

    var listItemEnumerator = collListItem.getEnumerator();
        
    while (listItemEnumerator.moveNext()) {
        var oListItem = listItemEnumerator.get_current();
        listItemInfo += '\nID: ' + oListItem.get_id() + 
            '\nDisplay name: ' + oListItem.get_displayName();
    }

    alert(listItemInfo.toString());
}

function onQueryFailed(sender, args) {

    alert('Request failed. ' + args.get_message() + '\n' + args.get_stackTrace());
}

So aktualisieren Sie Listenelemente

Zum Ändern eines Listenelements können Sie den zu ändernden Spaltenwert über einen Indexer angeben und wie für andere Objekte auch Update() (JavaScript: update()) aufrufen, bevor ExecuteQuery() oder ExecuteQueryAsync(ClientRequestSucceededEventHandler, ClientRequestFailedEventHandler) (JavaScript: executeQueryAsync(succeededCallback, failedCallback)) aufgerufen werden. Im folgenden Beispiel wird der Titel des Elements geändert, das die angegebene ID besitzt.

ClientContext clientContext =  new ClientContext("http://MyServer/sites/MySiteCollection");
Web oWebsite = clientContext.Web;
ListCollection collList = oWebsite.Lists;

List oList = collList.GetByTitle("My List");
ListItem oItem = oList.GetItemById(5);
oItem["Title"] = "Hello World";
oItem.Update();

clientContext.ExecuteQuery();

Dim clientContext As New ClientContext("http://MyServer/sites/MySiteCollection")
Dim oWebsite As Web = clientContext.Web
Dim collList As ListCollection = oWebsite.Lists

Dim oList As List = collList.GetByTitle("My List")

Dim oItem As ListItem = oList.GetItemById(5)
oItem("Title") = "Hello World"
oItem.Update()

clientContext.ExecuteQuery()

function updateListItem() {

    var clientContext = new SP.ClientContext('sites/MySiteCollection');
    var oList = clientContext.get_web().get_lists().getByTitle('My List');

    this.oListItem = oList.getItemById(5);
    oListItem.set_item('Title', 'Hello World');
    oListItem.update();

    clientContext.executeQueryAsync(Function.createDelegate(this, this.onQuerySucceeded), Function.createDelegate(this, this.onQueryFailed));
}

function onQuerySucceeded() {

    alert('Item updated.');
}

function onQueryFailed(sender, args) {

    alert('Request failed. ' + args.get_message() + '\n' + args.get_stackTrace());
}

Asynchrone Verarbeitung

Sowohl die JavaScript-Version des Objektmodells als auch die Silverlight-Version (bei Änderung der Benutzeroberfläche) verwenden die asynchrone Verarbeitung. Daher schließt die ExecuteQueryAsync(ClientRequestSucceededEventHandler, ClientRequestFailedEventHandler)-Methode (JavaScript: executeQueryAsync(succeededCallback, failedCallback)) das Übergeben von Delegaten für Rückrufmethoden ein, um den Erfolg und Fehler der Abfrage zu behandeln. Wenn die Verarbeitung dieser asynchronen Methode abgeschlossen ist, wird die angegebene Rückrufmethode aufgerufen, und der Client ruft Daten vom Server ab. Definieren Sie zum Ausführen einer Abfrage mithilfe des JavaScript- oder Silverlight-Objektmodells einen Delegat mit derselben Signatur wie eine Rückrufmethode, und erweitern Sie den Aufrufpfad, indem Sie den Delegat als Parameter in ExecuteQueryAsync(ClientRequestSucceededEventHandler, ClientRequestFailedEventHandler) (JavaScript: executeQueryAsync(succeededCallback, failedCallback)) übergeben.

Im folgenden Beispiel wird die asynchrone Verarbeitung in JavaScript und Silverlight gezeigt. Die erste Methode, retrieveWebsite, ruft ein Objekt der aktuellen Website ab, die für die angegebene Rückrufmethode, onQuerySucceeded, verfügbar gemacht wird, für die der Delegat in ExecuteQueryAsync(ClientRequestSucceededEventHandler, ClientRequestFailedEventHandler) (JavaScript: executeQueryAsync(succeededCallback, failedCallback)) übergeben wird. Die Rückrufmethode ruft den Titel des abgerufenen Websiteobjekts ab und legt diesen fest und ruft die Abfrageausführungsmethode ein zweites Mal ab, damit die Aktualisierung übernommen wird.

var oWebsite;
var clientContext;

function retrieveWebsite()
{
   clientContext = SP.ClientContext.get_current();
   oWebsite = clientContext.get_web();
   clientContext.load(oWebsite);
   clientContext.executeQueryAsync(Function.createDelegate(this, this.onQuerySucceeded), Function.createDelegate(this, this.onQueryFailed);
} 
 
function onQuerySucceeded()
{
   oWebsite.set_title(oWebsite.get_title() + " changed in ECMAScript.");
   oWebsite.update();
   clientContext.executeQueryAsync();
}

Im folgenden Beispiel wird das Festlegen des Websitetitels auf ähnliche Weise bei Verwendung des Silverlight-Objektmodells gezeigt.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;
using Microsoft.SharePoint.Client;

namespace Microsoft.SDK.SharePointServices.Samples
{
    public partial class MainPage : UserControl
    {
        ClientContext clientContext;
        Web oWebsite;

        public MainPage()
        {
            InitializeComponent();
        }

        private void Button_Click(object sender, RoutedEventArgs e)
        {
            clientContext = ClientContext.Current;
            oWebsite = clientContext.Web;

            clientContext.Load(oWebsite,
                website=>website.Title);

            clientContext.ExecuteQueryAsync(onQuerySucceeded, onQueryFailed);
        }

        private void onQuerySucceeded(object sender, ClientRequestSucceededEventArgs args)
        {
            UpdateUIMethod updateUI = ChangeTitle;
            this.Dispatcher.BeginInvoke(updateUI);
        }

        private void ChangeTitle()
        {
            oWebsite.Title = oWebsite.Title + " changed in Silverlight.";
            oWebsite.Update();

            clientContext.ExecuteQueryAsync(onTitleChanged, onQueryFailed);
        }

        private void onTitleChanged(object sender, ClientRequestSucceededEventArgs args)
        {
            UpdateUIMethod updateUI = DisplayTitle;
            this.Dispatcher.BeginInvoke(updateUI);
        }

        private void DisplayTitle()
        {
            MessageBox.Show("Title changed to " + oWebsite.Title);
        }

        private void onQueryFailed(object sender, ClientRequestFailedEventArgs args)
        {
            MessageBox.Show("Request failed. " + args.Message + "\n" + args.StackTrace);
        }

        private delegate void UpdateUIMethod();
    }
}

Sowohl im JavaScript- als auch im Silverlight-Beispiel wird die Current-Eigenschaft (JavaScript: current) des Clientkontexts zum Angeben des aktuellen Anforderungskontexts verwendet, anstatt den ClientContext(String)-Konstruktor (JavaScript: ClientContext(serverRelativeUrl)) zu verwenden und eine URL anzugeben.

Andere Beispiele und weitere Informationen zum Datenabruf im Kontext des SharePoint Foundation Silverlight-Objektmodells finden Sie unter Verwenden des Silverlight-Objektmodells.