Partager via

Vue d'ensemble de la récupération des données

  • Article

Dernière modification : jeudi 18 novembre 2010

S’applique à : SharePoint Foundation 2010

Dans cet article
Syntaxe de requête et syntaxe de méthode
Utilisation des chaînes de requête dans ECMAScript
Chargement sur place et chargement requêtable
Comment récupérer des objets
Comment mettre à jour des objets
Comment récupérer des éléments de liste
Comment mettre à jour des éléments de liste
Traitement asynchrone

Disponible dans SharePoint Online

Vous pouvez utiliser le modèle objet client pour récupérer des propriétés pour un objet client SharePoint spécifique (ClientObject, ou dans ECMAScript (JavaScript, JScript), ClientObject), pour récupérer des objets enfants et leurs propriétés associées ou pour récupérer des éléments enfants dans une collection. Le modèle enfant utilise une sémantique de récupération de données explicite que vous devez suivre pour récupérer les données de fonctionnement. Les modèles objet client ne persistent pas les données qui sont extraites localement sur le client.

L'exécution de la récupération des données implique la procédure suivante :

  1. Retourner le contexte pour une demande du client en utilisant le constructeur ClientContext() (JavaScript: ClientContext(serverRelativeUrl)).

  2. Utiliser le modèle objet pour spécifier un objet à récupérer ou à partir duquel récupérer des données.

  3. Charger l'objet ou la collection, via un chargement sur place qui utilise la méthode Load<T>(T, []) (JavaScript: load(clientObject)) pour retourner un objet, une collection ou des données spécifiques ou via un chargement interrogeable qui utilise la méthode LoadQuery() (JavaScript: loadQuery(clientObjectCollection, exp)) pour retourner une collection d'objets énumérable.

  4. Exécutez la requête en appelant la méthode synchrone ExecuteQuery() dans la version .NET managée du modèle objet client, ou quand, dans la version Silverlight, le code s'exécute à partir des threads qui ne modifient pas l'interface utilisateur. Dans la version JavaScript du modèle objet, ou quand la version Silverlight modifie l'interface utilisateur, la récupération des données utilise un modèle de rappel asynchrone et vous devez appeler la méthode ExecuteQueryAsync(ClientRequestSucceededEventHandler, ClientRequestFailedEventHandler) (JavaScript: executeQueryAsync(succeededCallback, failedCallback)), qui inclut les paramètres des méthodes de gestion du succès ou de l'échec de la demande. Quand l'appel de méthode d'exécution de la requête s'exécute (de façon synchrone ou asynchrone), vous pouvez accéder aux résultats de la requête sur les objets à partir desquels vous avez lancé la requête.

Syntaxe de requête et syntaxe de méthode

Les deux formes de la syntaxe LINQ (Language-Integrated Query)--syntaxe de requête et syntaxe de méthode--peuvent être utilisées dans le modèle objet client managé pour charger des objets individuels, des propriétés d'objet spécifiques ou des collections d'objets énumérables.

Notes

Il existe deux points à ne pas oublier lorsque vous utilisez LINQ pour créer des requêtes sur le modèle objet client :

  • Quand vous utilisez LINQ pour créer des requêtes sur le modèle objet client, vous utilisez LINQ to Objects, et non pas le fournisseur LINQ to SharePoint, qui peut seulement être utilisé quand vous écrivez du code par rapport au modèle objet client.

  • Lorsque votre requête est conçue de sorte à retourner un sous-ensemble d'éléments de liste d'une liste, il s'avère plus efficace d'utiliser une requête CAML qu'une requête LINQ. En effet, tous les éléments de liste sont envoyés à partir de la base de données de contenu vers le serveur Web frontal, puis chargés en mémoire. Ce n'est qu'à ce moment-là que le filtre LINQ est appliqué. Avec une requête CAML, le filtrage s'effectue sur le serveur de la base de données. Cette différence s'applique uniquement aux requêtes qui filtrent les éléments d'une liste. Les autres types de requêtes LINQ, tels que le retour d'un sous-ensemble de listes d'un site Web, sont plus efficaces.

La syntaxe de requête peut seulement être utilisée dans la méthode LoadQuery() et nécessite deux étapes : définir l'expression de requête et extraire le résultat de la requête. Ce processus est illustré dans l'exemple de code suivant, qui retourne toutes les listes du site Web actuel qui ont un titre défini.

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()

La syntaxe de méthode peut être utilisée avec la méthode Load<T>(T, []) ou LoadQuery() et utilise des expressions lambda. L'exemple suivant utilise la syntaxe de méthode pour définir la même requête pour les listes qui ont un titre.

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()

L'exemple précédent illustre comment utiliser la méthode Include<TSource>(IQueryable<TSource>, []) pour limiter les propriétés qui sont retournées à partir d'une collection d'objets, ce qui améliore les performances. La requête retourne uniquement les titres des listes qui ont un titre.

L'exemple suivant utilise la syntaxe de requête pour récupérer les champs filtrables d'une liste qui ne sont pas masqués.

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()

L'exemple suivant exécute la même requête que la précédente requête, mais utilise la syntaxe de méthode dans la méthode Load<T>(T, []).

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()

Utilisation des chaînes de requête dans ECMAScript

Les méthodes JavaScript de récupération des objets et des données n'acceptent pas la syntaxe LINQ, mais vous pouvez utiliser une expression chaîne pour définir une requête de base. L'exemple suivant utilise la méthode load(clientObject) pour extraire uniquement le titre et l'ID d'une liste spécifique.

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

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

Quand vous utilisez une collection de sites, spécifiez Include pour retourner seulement le titre et l'ID de chaque liste, comme illustré dans l'exemple suivant.

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

Vous pouvez également utiliser des champs de la classe *PropertyNames qui est associée à l'objet ou à la collection pour spécifier les propriétés à retourner, comme illustré dans l'exemple suivant :

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

vous pouvez aussi imbriquer le mot-clé Include dans la chaîne de requête que vous passez. L'exemple suivant utilise la méthode loadQuery(clientObjectCollection, exp) pour récupérer les titres de toutes les listes, ainsi que les titres et les descriptions de tous les champs dans toutes les listes.

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

Chargement sur place et chargement requêtable

Il existe deux façons d'utiliser les requêtes basées sur LINQ avec le modèle objet client : via un chargement sur place ou un chargement requêtable. Un chargement requêtable retourne des données dans un autre tableau de résultats, alors que le chargement sur place retourne les données dans l'objet lui-même.

Un chargement sur place effectue une demande de chargement d'objets et de leurs données et maintient une identité d'objet par le biais de plusieurs demandes. Vous effectuez des chargements sur place via la méthode Load<T>(T, []) d'un contexte client. L'exemple client charge toutes les listes du site Web actuel et toutes leurs propriétés par défaut. Après l'exécution de la requête, le code a accès à toute la collection de listes et les propriétés de liste par défaut :

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

Dans un chargement requêtable, la requête est distincte des résultats retournés. Contrairement à un chargement sur place, dans un chargement requêtable l'identité de l'objet n'est pas conservée, ce qui fait que votre code doit lui-même maintenir les objets qui sont retournés. L'exemple suivant utilise la syntaxe de requête pour retourner toutes les listes du site Web.

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()

Cet exemple remplit le result avec une interface IEnumerable<T> d'objets List que votre code peut utiliser et doit gérer tout seul. Notez que context.Web.Lists reste vide et retourne toujours un nombre 0 ; pour obtenir le nombre de la liste, vous devez utiliser Count() de votre interface IEnumerable<T>.

Comment récupérer des objets

L'exemple suivant montre comment charger un objet pour accéder à ses propriétés. Dans la mesure où l'objet est chargé sur place, toutes les propriétés par défaut sont accessibles.

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

Certaines propriétés ne sont pas disponibles par défaut car quand vous récupérez certains objets et pour accéder à ces propriétés, vous devez explicitement charger les propriétés. Le précédent exemple charge un objet de liste spécifique et peut accéder aux deux propriétés car elles sont disponibles par défaut sur l'objet. Cependant, si l'exemple tente d'accéder à des propriétés qui ne sont pas disponibles par défaut, telles que OnQuickLaunch (JavaScript: onQuickLaunch), un PropertyOrFieldNotInitializedException est retourné. Le tableau suivant répertorie les propriétés qui ne sont pas disponibles par défaut lorsque vous récupérez l'objet.

Objet

Propriétés

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)

Outre les propriétés recensées dans le tableau précédent, les objets parents ou enfants accessibles via les propriétés d'un objet ne sont pas disponibles par défaut. Par conséquent, l'ajout de oList.Items.Count dans l'exemple précédent affiche 0 à la console, à la place du nombre effectif d'éléments le cas échéant, car la collection d'éléments de liste n'est pas demandée de manière spécifique dans la méthode Load<T>(T, []) (JavaScript: load(clientObject)).

Pour accéder à des propriétés qui ne sont pas accessibles par défaut quand vous retournez un objet, vous devez explicitement demander des propriétés. La révision suivante du précédent appel de méthode Load<T>(T, []) (JavaScript: load(clientObject)) rend OnQuickLaunch (JavaScript: onQuickLaunch) disponible.

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');

Dans l'objet modèle managé ou Silverlight, si vous utilisez une collection d'objet, utilisez la méthode IncludeWithDefaultProperties<TSource>(IQueryable<TSource>, []) pour inclure des propriétés qui ne sont pas disponibles par défaut sur chaque liste qui est chargée.

Notes

Le modèle objet JavaScript n'a pas vraiment l'équivalent d'une méthode IncludeWithDefaultProperties<TSource>(IQueryable<TSource>, []).

L'exemple suivant affiche les mêmes informations que l'exemple précédent pour chaque liste dans le site Web.

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

Comment mettre à jour des objets

Pour modifier un objet via le modèle objet client, procédez comme pour modifiez un objet via le modèle objet serveur. Dans les deux cas, vous devez appeler une méthode Update. Cependant, avec le modèle objet client, les modifications ne prennent effet qu'une fois que l'objet est chargé et ExecuteQuery() ou ExecuteQueryAsync(ClientRequestSucceededEventHandler, ClientRequestFailedEventHandler) (JavaScript: executeQueryAsync(succeededCallback, failedCallback)) appelé. L'exemple suivant modifie la description de la liste qui est chargée.

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

Notez que dans l'exemple précédent, le fait de modifier un objet ne nécessite pas le chargement de l'objet sur le client.

Comment récupérer des éléments de liste

Pour récupérer de nombreux éléments de liste, il est plus efficace d'utiliser une requête dans Collaborative Application Markup Language (CAML) pour spécifier quels éléments retourner. Utilisez la classe CamlQuery (JavaScript: CamlQuery) pour définir la requête, et passer la requête à la méthode GetItems(CamlQuery) (JavaScript: getItems(query)).

L'exemple suivant utilise la classe CamlQuery class (JavaScript: CamlQuery) pour retourner les 50 premiers éléments dans une liste dont l'ID est inférieur à 100. La méthode spécifie Load<T>(T, [])IncludeWithDefaultProperties<TSource>(IQueryable<TSource>, []) pour inclure la récupération de DisplayName.

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

Dans la mesure où le modèle objet JavaScript n'a pas une méthode IncludeWithDefaultProperties<TSource>(IQueryable<TSource>, []), l'exemple suivant utilise Include avec la méthodeload(clientObject) pour spécifier la récupération de l'ID et le nom d'affichage de chaque élément de liste.

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

Comment mettre à jour des éléments de liste

Pour modifier un élément de liste, vous pouvez spécifier la valeur de colonne à modifier via un indexeur, et comme pour d'autres objets, appelez Update() (JavaScript: update()) avant d'appeler ExecuteQuery() ou ExecuteQueryAsync(ClientRequestSucceededEventHandler, ClientRequestFailedEventHandler) (JavaScript: executeQueryAsync(succeededCallback, failedCallback)). L'exemple suivant modifie le titre de l'élément qui a l'ID spécifié.

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

Traitement asynchrone

La version du modèle objet JavaScript et la version Silverlight version (quand elle modifie l'interface utilisateur) utilisent toutes deux un traitement asynchrone. Par conséquent, la méthode ExecuteQueryAsync(ClientRequestSucceededEventHandler, ClientRequestFailedEventHandler) (JavaScript: executeQueryAsync(succeededCallback, failedCallback)) inclut la passation de délégués pour les méthodes de rappel pour gérer le succès et l'échec de la requête. Quand cette méthode asynchrone termine le traitement, la méthode de rappel spécifié est appelée, et le client récupère les données du serveur. Pour exécuter une requête à l'aide de l'objet modèle client JavaScript ou Silverlight, définissez un délégué qui a la même signature qu'une méthode de rappel, et étendez le chemin de l'appel en passant le délégué en tant que paramètre dans ExecuteQueryAsync(ClientRequestSucceededEventHandler, ClientRequestFailedEventHandler) (JavaScript: executeQueryAsync(succeededCallback, failedCallback)).

L'exemple suivant illustre un traitement asynchrone dans JavaScript et Silverlight. La première méthode , retrieveWebsite, obtient un objet pour le site Web actuel, qui devient disponible à la méthode de rappel spécifiée, onQuerySucceeded, pour laquelle le délégué est passé dans le ExecuteQueryAsync(ClientRequestSucceededEventHandler, ClientRequestFailedEventHandler) (JavaScript: executeQueryAsync(succeededCallback, failedCallback)). La méthode de rappel obtient et définit le titre de l'objet site Web récupéré, et appelle la méthode d'exécution de la requête une deuxième fois pour que la mise à jour prenne effet.

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

L'exemple suivant montre comment définir le titre du site Web de la même façon en utilisant le modèle objet Silverlight.

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

Les deux exemples JavaScript et Silverlight utilisent la propriété Current (JavaScript: current) du contexte client pour spécifier le contexte de la demande actuelle, au lieu d'utiliser le constructeur ClientContext(String) (JavaScript: ClientContext(serverRelativeUrl)) et spécifier une URL.

Pour d'autres exemples et informations sur la récupération des données dans le contexte de l'objet modèle SharePoint Foundation Silverlight, consultez Utilisation du modèle objet Silverlight.

Voir aussi

Concepts

Procédure : travailler avec des sites Web

Procédure : récupérer des listes

Procédure : récupérer des éléments de liste

Procédure : utiliser des utilisateurs et des groupes

Contexte de client en tant qu’objet central

Objets clients, objets de valeur et propriétés scalaires

Création d’objet client

Directive du modèle objet client

Différences entre les modèles objets managés et les modèles objets ECMAScript

Tâches courantes de programmation

Autres ressources

Bibliothèque de classes Client

Bibliothèque de classes ECMAScript

Utilisation du modèle objet de client géré SharePoint Foundation 2010

Centre de ressources pour le modèle objet client (éventuellement en anglais)