Introducción a la recuperación de datos

Artículo
09/24/2014

Última modificación: jueves, 18 de noviembre de 2010

Hace referencia a: SharePoint Foundation 2010

En este artículo
Sintaxis de consulta frente a sintaxis de método
Usar cadenas de consulta en ECMAScript
La carga en contexto frente a la carga consultable
Procedimiento para recuperar objetos
Procedimiento para actualizar objetos
Procedimiento para recuperar elementos de lista
Procedimiento para actualizar elementos de lista
Procesamiento asincrónico

Disponible en SharePoint Online

Puede usar el nuevo modelo de objetos cliente para recuperar propiedades de un objeto cliente específico de SharePoint (ClientObject o en ECMAScript (JavaScript, JScript), ClientObject), para recuperar objetos secundarios y sus propiedades asociadas o para recuperar elementos secundarios en una colección. El modelo de objetos usa una semántica explícita de recuperación de datos que debe seguirse para recuperar datos que funcionen.

Para realizar la recuperación de datos es necesario el procedimiento siguiente:

Devuelva el contexto de una solicitud de cliente mediante el constructor ClientContext() (JavaScript: ClientContext(serverRelativeUrl)).
Use el modelo de objetos para especificar un objeto que recupere datos o desde el que se recuperarán datos.
Cargue el objeto o la colección mediante una carga en contexto que usa el método Load<T>(T, []) (JavaScript: load(clientObject)) para devolver un objeto, una colección o datos específicos o mediante una carga que se pueda consultar y use el método LoadQuery() (JavaScript: loadQuery(clientObjectCollection, exp)) para devolver una colección enumerable de objetos.
Para ejecutar la consulta, llame al método sincrónico ExecuteQuery() en la versión .NET administrada del modelo de objetos cliente o cuando, en la versión Silverlight, el código se ejecuta desde subprocesos que no modifican la interfaz de usuario (UI). En la versión JavaScript del modelo de objetos o cuando la versión Silverlight modifica la UI, la recuperación de datos usa un modelo asincrónico de devolución de llamada y se debe llamar al método ExecuteQueryAsync(ClientRequestSucceededEventHandler, ClientRequestFailedEventHandler) (JavaScript: executeQueryAsync(succeededCallback, failedCallback)), que incluye parámetros para que los métodos controlen que la solicitud se realice correctamente o no. Cuando la llamada de método para ejecutar la consulta devuelve un resultado (sincrónica o asincrónicamente), es posible obtener acceso a los resultados de la consulta sobre el objeto desde el que se inició la consulta.

Sintaxis de consulta frente a sintaxis de método

Ambas formas de sintaxis de Language-Integrated Query (LINQ), la sintaxis de consulta y la sintaxis de método, pueden usarse en el modelo de objetos cliente administrado para cargar objetos específicos, determinar las propiedades de los objetos o realizar colecciones de objetos que se puedan enumerar.

Nota

Dos puntos que se deben tener en cuenta al usar LINQ para consultas en el modelo de objetos cliente:

Al usar LINQ para crear consultas respecto del modelo de objetos cliente, se usa LINQ to Objects, en lugar del proveedor LINQ to SharePoint, que únicamente puede usarse cuando se escribe código respecto del modelo de objetos servidor.
Cuando la consulta está diseñada para devolver un subconjunto de elementos de lista de una lista, es más eficaz usar una consulta CAML que una consulta LINQ. Esto se debe a que todos los elementos de lista se envían desde la base de datos de contenido al servidor front-end web y se cargan en la memoria. Es solamente en este momento cuando se aplica el filtro LINQ. Con una consulta CAML, el filtrado se realiza en el servidor de bases de datos. Este punto se aplica sólo a las consultas que filtran los elementos de una lista. Otros tipos de consultas LINQ, como la devolución de un subconjunto de listas desde un sitio web, son más eficaces.

La sintaxis de consulta únicamente puede usarse en el método LoadQuery() y requiere dos pasos: definir la expresión de consulta y recuperar el resultado de la consulta. Este proceso se ilustra en el siguiente ejemplo de código, que devuelve todas las listas del sitio web actual que tienen un título definido.

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 sintaxis de método puede usarse tanto con el método Load<T>(T, []) como con el método LoadQuery() y usa expresiones de lambda. El ejemplo siguiente usa sintaxis de método para definir la misma consulta para las listas que tienen título.

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

El ejemplo anterior ilustra cómo usar el método Include<TSource>(IQueryable<TSource>, []) para limitar las propiedades que se devuelven desde una colección de objetos, lo que mejora el rendimiento. La consulta devuelve únicamente los títulos de las listas que tienen título.

El próximo ejemplo usa sintaxis de consulta para recuperar campos filtrables de una lista que no están ocultos.

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

El ejemplo siguiente realiza la misma consulta que el anterior pero, en contraposición, usa la sintaxis de método en el método 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()

Usar cadenas de consulta en ECMAScript

Los métodos de JavaScript para recuperar objetos y datos no aceptan la sintaxis de LINQ pero es posible usar una expresión de cadena para definir una consulta básica. En el ejemplo siguiente se usa el método load(clientObject) para recuperar únicamente el título y el identificador de una lista específica.

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

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

Al trabajar con una colección de listas, especifique Include para devolver únicamente el título y el identificador de cada lista, como se puede apreciar en el ejemplo siguiente.

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

De forma alternativa, puede usar los campos de la clase *PropertyNames asociada con el objeto o la colección para especificar las propiedades que se devolverán, como se puede apreciar en el ejemplo siguiente:

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

También puede anidar la palabra clave Include dentro de la cadena de consulta que pasa. En el ejemplo siguiente se usa el método loadQuery(clientObjectCollection, exp) para recuperar los títulos de todas las listas y, además, los títulos y las descripciones de todos los campos de todas las listas.

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

La carga en contexto frente a la carga consultable

Hay dos maneras de usar consultas basadas en LINQ con el modelo de objetos cliente: mediante una carga en contexto y mediante una carga consultable. Una carga consultable devuelve datos en otra matriz de resultados, mientras que una carga en contexto devuelve datos en el objeto en sí.

Una carga en contexto realiza una solicitud para cargar objetos y sus datos y mantiene la identidad de los objetos mediante varias solicitudes. Las cargas en contexto se realizan mediante el método Load<T>(T, []) de un contexto cliente. El ejemplo siguiente carga todas las listas del sitio web actual y todas sus propiedades predeterminadas. Después de la ejecución de la consulta, el código tiene acceso a toda la colección de la lista y a las propiedades predeterminadas de la lista:

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

En una carga consultable, la consulta está separada de los resultados devueltos. A diferencia de una carga en contexto, en una carga consultable no se conserva la identidad de los objetos, por lo tanto el código debe mantener por su cuenta los objetos que se devuelven. En el ejemplo siguiente se usa sintaxis de consulta para devolver todas las listas del sitio 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()

Este ejemplo rellena result con una interfaz IEnumerable<T> de objetos List con los que puede trabajar el código y debe mantener por cuenta propia. Observe que context.Web.Lists permanece vacío y aún devuelve un recuento de 0; para obtener el recuento de lista, debe usar Count() de la interfaz IEnumerable<T>.

Procedimiento para recuperar objetos

En el ejemplo siguiente se muestra cómo cargar un objeto para obtener acceso a todas sus propiedades. Debido a que el objeto de lista se carga en contexto, es posible obtener acceso a todas las propiedades predeterminadas de la lista.

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

Algunas propiedades no están disponibles de forma predeterminada al recuperar algunos objetos específicos. Para obtener acceso a estas propiedades, éstas deben cargarse explícitamente. En el ejemplo anterior se carga un objeto de lista específico y se puede obtener acceso a ambas propiedades porque están disponibles en el objeto de forma predeterminada. Sin embargo, si el ejemplo intenta obtener acceso a propiedades que no están disponibles de forma predeterminada, como OnQuickLaunch (JavaScript: onQuickLaunch), se devuelve una PropertyOrFieldNotInitializedException. En la tabla siguiente se detallan las propiedades que no están disponibles de forma predeterminada al recuperar el objeto.

Nombre	Propiedades
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)

Además de las propiedades que se detallan en la tabla anterior, los objetos primarios o secundarios a los que puede obtenerse acceso mediante las propiedades de un objeto no están disponibles de forma predeterminada. En consecuencia, al agregarse oList.Items.Count en el ejemplo anterior siempre se muestra 0 en la consola, en lugar de la cantidad real de elementos, de haberlos, porque la colección de elementos de lista no se solicita específicamente en el método Load<T>(T, []) (JavaScript: load(clientObject)).

Para obtener acceso a las propiedades que no están disponibles de forma predeterminada al devolver un objeto, se deben solicitar explícitamente las propiedades. La siguiente revisión de la llamada del método Load<T>(T, []) (JavaScript: load(clientObject)) anterior hace que OnQuickLaunch (JavaScript: onQuickLaunch) esté 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');

En el modelo de objetos administrado o Silverlight, si trabaja con una colección de objetos, use el método IncludeWithDefaultProperties<TSource>(IQueryable<TSource>, []) para incluir propiedades que no están disponibles de forma predeterminada en cada lista que se carga.

Nota

El modelo de objetos de JavaScript no tiene el equivalente de un método IncludeWithDefaultProperties<TSource>(IQueryable<TSource>, []).

En el ejemplo siguiente se muestra la misma información que en el ejemplo anterior para todas las listas del sitio 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

Procedimiento para actualizar objetos

La modificación de un objeto mediante el modelo de objetos cliente funciona de manera similar a la modificación de un objeto mediante el modelo de objetos servidor. En ambos casos es necesario llamar a un método Update. Sin embargo, con el modelo de objetos cliente, los cambios no se llevan a cabo hasta que se carga el objeto y se llama a ExecuteQuery() o ExecuteQueryAsync(ClientRequestSucceededEventHandler, ClientRequestFailedEventHandler) (JavaScript: executeQueryAsync(succeededCallback, failedCallback)). En el ejemplo siguiente se cambia la descripción de la lista que se carga.

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

Observe que en el ejemplo anterior, la modificación de un objeto no requiere que se cargue el objeto en el cliente.

Procedimiento para recuperar elementos de lista

Para recuperar muchos elementos de lista, lo más eficiente es usar una consulta en el lenguaje de marcado de aplicaciones de colaboración (CAML) para especificar qué elementos se devolverán. Use la clase CamlQuery (JavaScript: CamlQuery) para definir la consulta y pase la consulta al método GetItems(CamlQuery) (JavaScript: getItems(query)).

En el ejemplo siguiente se usa la clase CamlQuery (JavaScript: CamlQuery) para devolver los primeros 50 elementos de una lista cuyo identificador es menor que 100. El método Load<T>(T, []) especifica IncludeWithDefaultProperties<TSource>(IQueryable<TSource>, []) para incluir la recuperación 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

Debido a que el modelo de objetos de JavaScript no tiene un método IncludeWithDefaultProperties<TSource>(IQueryable<TSource>, []), en el ejemplo siguiente se usa Include con el método load(clientObject) para especificar la recuperación del identificador y el nombre para mostrar de cada elemento de lista.

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

Procedimiento para actualizar elementos de lista

Para modificar un elemento de lista, puede especificar el valor de columna que se cambiará mediante un indizador y, de la misma manera que con los demás objetos, llamar a Update() (JavaScript: update()) antes de llamar a ExecuteQuery() o ExecuteQueryAsync(ClientRequestSucceededEventHandler, ClientRequestFailedEventHandler) (JavaScript: executeQueryAsync(succeededCallback, failedCallback)). En el ejemplo siguiente se cambia el título del elemento que tiene el identificador especificado.

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

Procesamiento asincrónico

Tanto la versión de JavaScript del modelo de objetos como la versión Silverlight (cuando modifica la UI) usan procesamiento asincrónico. En consecuencia, el método ExecuteQueryAsync(ClientRequestSucceededEventHandler, ClientRequestFailedEventHandler) (JavaScript: executeQueryAsync(succeededCallback, failedCallback)) incluye que se pasen delegados para que los métodos de devolución de llamada controlen que las consultas se realicen correctamente o no. Cuando este método asincrónico completa el procesamiento, se llama al método especificado de devolución de llamada y el cliente recupera datos del servidor. Para ejecutar una consulta con el modelo de objetos de JavaScript o Silverlight, defina un delegado con la misma firma que un método de devolución de llamada y extienda la ruta de llamada al pasar el delegado como parámetro en ExecuteQueryAsync(ClientRequestSucceededEventHandler, ClientRequestFailedEventHandler) (JavaScript: executeQueryAsync(succeededCallback, failedCallback)).

En el ejemplo siguiente se muestra el procesamiento asincrónico en JavaScript y Silverlight. El primer método, retrieveWebsite, obtiene un objeto para el sitio web actual, que se convierte en disponible para el método de devolución de llamada especificado, onQuerySucceeded, para el que se pasa el delegado en ExecuteQueryAsync(ClientRequestSucceededEventHandler, ClientRequestFailedEventHandler) (JavaScript: executeQueryAsync(succeededCallback, failedCallback)). El método de devolución de llamada obtiene y establece el título del objeto de sitio web recuperado y llama al método de ejecución de consultas una segunda vez para que se lleve a cabo la actualización.

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

En el ejemplo siguiente se muestra cómo establecer el título del sitio web de manera similar mediante el modelo de objetos 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();
    }
}

Tanto el ejemplo de JavaScript como el de Silverlight usan la propiedad Current (JavaScript: current) del contexto cliente para especificar el contexto de la solicitud actual, en lugar de usar el constructor ClientContext(String) (JavaScript: ClientContext(serverRelativeUrl)) y especificar una dirección URL.

Para obtener otros ejemplos y obtener información acerca de la recuperación de datos en el contexto del modelo de objetos Silverlight de SharePoint Foundation, vea Uso del modelo de objetos Silverlight.