Fragmento de código: obtención de datos de elemento de una lista externa en el cliente

  • Artículo

Última modificación: lunes, 19 de abril de 2010

Hace referencia a: SharePoint Server 2010

En este artículo
Descripción
Requisitos previos
Para usar este ejemplo

Descripción

El fragmento de código siguiente muestra cómo recuperar datos de elemento de lista de una lista externa desde el equipo cliente que usa el modelo de objetos de cliente de SharePoint.

Nota importanteImportante

Si intenta usar un ClientContext.Load "predeterminado" de datos de ListItem de una lista externa, obtendrá un error que indica que la clave proporcionada no se encontró en el diccionario. En su lugar, deberá especificar explícitamente los campos que desee en CamlQuery, así como en el método ClientContext.Load.

Requisitos previos

  • Microsoft SharePoint Server 2010 o Microsoft SharePoint Foundation 2010 en el servidor.

  • Al menos una lista externa en el servidor.

  • Microsoft Office Professional Plus 2010 y Microsoft .NET Framework 3.5 en el equipo cliente.

  • Microsoft Visual Studio.

Para usar este ejemplo

  1. Inicie Visual Studio en el equipo cliente y cree un proyecto de aplicación de consola de C#. Seleccione .NET Framework 3.5 cuando cree el proyecto.

  2. En el menú Ver, haga clic en Páginas de propiedades para que aparezcan las propiedades del proyecto.

  3. En la ficha Compilación, para el Destino de la plataforma, seleccione Cualquier CPU.

  4. Cierre la ventana de propiedades del proyecto.

  5. En el Explorador de soluciones, en Referencias, quite todas las referencias del proyecto excepto System y System.Core.

  6. Agregue las siguientes referencias al proyecto:

    1. Microsoft.SharePoint.Client

    2. Microsoft.SharePoint.Client.Runtime

    3. System.Data.Linq

    4. System.XML

  7. Reemplace el código generado automáticamente en Program.cs por el código que aparece al final de este procedimiento.

  8. Reemplace los valores de <TargetSiteUrl> y <TargetListName> por valores válidos.

  9. Guarde el proyecto.

  10. Compile y ejecute el proyecto.

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