Vérifier si une Colonne de Liste Existe à l'aide de SharePoint Modèle Objet Client?

En utilisant le Modèle Objet Client (C#) dans SharePoint 2010, comment puis-je déterminer si une colonne (champ), le nom dans une Liste donnée?

Merci, MagicAndi.

OriginalL'auteur MagicAndi | 2010-12-09

12

Viens de trouver ce alors que la recherche de la même chose, mais il semble que Sharepoint 2010 a quelque chose de construit dans pour cela, au moins pour le modèle de Serveur: list.Fields.ContainsField("fieldName");

Ne sais pas si elle existe pour le côté Client. Pensé que ce serait un bon endroit pour stocker cette information.

OriginalL'auteur

Modèle Objet Serveur

string siteUrl = "http://mysite";
using (SPSite site = new SPSite(siteUrl))
{
    using (SPWeb web = site.OpenWeb())
    {
        SPList list = web.Lists["my forum"];
        for (int i = 0; i < list.Fields.Count; i++)
        {
            if (list.Fields[i].Title == "xyz")
            {
                -
                -
            }
        }
    }
}

Modèle Objet Client

string siteUrl = "http://MyServer/sites/MySiteCollection";
ClientContext clientContext = new ClientContext(siteUrl);
SP.List List = clientContext.Web.Lists.GetByTitle("my forum");
for (int i = 0; i < list.Fields.Count; i++)
{
    if (list.Fields[i].Title == "xyz")
    {
        -
        -
    }
}

C'est le modèle objet serveur dans votre exemple
n'y a pas beaucoup de différence dans les deux codes, sauf le contexte client
Ashutosh, merci pour votre réponse. +1
Ashutosh, vous pouvez supprimer beaucoup de code réutilisable ci-dessus à l'aide d'un opérateur lambda à la requête de la collection de champs.
Que modèle objet client code ne fonctionne pas comme il est écrit que rien n'est chargé par le contexte.load() et le contexte.executequery() avant son utilisation.

OriginalL'auteur Ashutosh Singh-MVP SharePoint

Voici un code d'extension (otite chronique) pour la liste sharepoint

    public static bool DoesFieldExist(this List list, ClientContext clientContext, string internalFieldname)
    {
        bool exists = false;

        clientContext.Load(list.Fields, fCol => fCol.Include(
                f => f.InternalName
            ).Where(field => field.InternalName == internalFieldname));
        clientContext.ExecuteQuery();

        if (list.Fields != null && list.Fields.Count > 0)
        {
            exists = true;
        }

        return exists;
    }

utilisation

List targetList = this.Context.Web.Lists.GetById(<ListID>);
targetList.DoesFieldExist(<ClientContext>, <Field internal Name>)

profiter 🙂

OriginalL'auteur Mitya Kours

La méthode suivante montre comment déterminer si une colonne spécifiée existe dans un List à l'aide de otite chronique:

static class FieldCollectionExtensions
{
    public static bool ContainsField(this List list,string fieldName)
    {
        var ctx = list.Context;
        var result = ctx.LoadQuery(list.Fields.Where(f => f.InternalName == fieldName));
        ctx.ExecuteQuery();
        return result.Any();
    }
}

Utilisation

using(var ctx = new ClientContext(webUrl))
{
    var list = ctx.Web.Lists.GetByTitle(listTitle);
    if(list.ContainsField("Title")){
       //...
    }
}

OriginalL'auteur Vadim Gremyachev

J'ai fini par récupérer le détail de la liste des champs de la avant mon opération, et de les enregistrer dans une liste générique de structures (contenant les détails de chaque champ). J'ai ensuite cette requête (génériques) dans la liste pour voir si le champ existe réellement dans la donnée (SharePoint) de la liste.

//Retrieve detail sof all fields in specified list
using (ClientContext clientContext = new ClientContext(SharePointSiteUrl))
{
    List list = clientContext.Web.Lists.GetByTitle(listName);
    _listFieldDetails = new List<SPFieldDetails>();

    //get fields name and their types
    ClientObjectPrototype allFields = list.Fields.RetrieveItems();
    allFields.Retrieve( FieldPropertyNames.Title, 
                        FieldPropertyNames.InternalName,
                        FieldPropertyNames.FieldTypeKind,
                        FieldPropertyNames.Id,
                        FieldPropertyNames.ReadOnlyField);
    clientContext.ExecuteQuery();

    foreach (Field field in list.Fields)
    {
        SPFieldDetails fieldDetails = new SPFieldDetails();
        fieldDetails.Title = field.Title;
        fieldDetails.InternalName = field.InternalName;
        fieldDetails.Type = field.FieldTypeKind;
        fieldDetails.ID = field.Id;
        fieldDetails.ReadOnly = field.ReadOnlyField;
        listFieldDetails.Add(fieldDetails);
    }
}

//Check if field name exists
_listFieldDetails.Exists(field => field.Title == fieldName);

 //Struct to hold details of the field
public struct SPFieldDetails
{
    public string Title { get; set; }
    public string InternalName { get; set; }
    public Guid ID { get; set; }
    public FieldType Type { get; set; }
    public bool ReadOnly { get; set; }
}

OriginalL'auteur MagicAndi

Quelques bonnes réponses ci-dessus. Personnellement, j'ai utilisé celui-ci:

            List list = ctx.Web.Lists.GetByTitle("Some list");
            FieldCollection fields = list.Fields;
            IEnumerable<Field> fieldsColl = ctx.LoadQuery(fields.Include(f => f.InternalName));
            ctx.ExecuteQuery();

            bool fieldMissing = fieldsColl.Any(f => f.InternalName != "Internal_Name");

Vous pouvez également utiliser 'Où' après il y a la méthode et de vérifier si l'article est renvoyé de la collection/le champ est null. C'est à propos de la préférence personnelle, parce que les deux options sont interrogeant sur le côté client.

OriginalL'auteur Diomos

0

Je préfère le SharePoint en Plus de la Bibliothèque comme il est vraiment propre:
http://aymkdn.github.io/SharepointPlus/symbols/%24SP%28%29.list.html
```
$SP().list("My List").get({
  fields:"Title",
  where:"Author = '[Me]'"
},function getData(row) {
  console.log(row[0].getAttribute("Title"));
});
```
Vous pourriez utiliser une boucle for pour parcourir la ligne et de vérifier si la colonne que vous cherchez existe.

OriginalL'auteur Bhetzie

Un coupé et une version simplifiée de Mitya de la méthode d'extension:

 public static bool FieldExists(this List list, string internalFieldname)
    {
        using (ClientContext clientContext = list.Context as ClientContext)
        {
            clientContext.Load(list.Fields, fCol => fCol.Include(
                    f => f.InternalName
                ).Where(field => field.InternalName == internalFieldname));
            clientContext.ExecuteQuery();

            return (list.Fields != null) && (list.Fields.Count > 0);
        }
    }

Il n'y a pas besoin de passer dans un autre contexte client paramètre lorsque vous pouvez déjà utiliser le contexte qui vient dans la liste.

OriginalL'auteur Colin Gardner

-2

à beaucoup de code à utiliser ce

charge Champs d'abord, puis

 bool exists= clientContext2.Site.RootWeb.Fields.Any(o => o.Id.ToString() == a.Id.ToString());

OriginalL'auteur David

Vous devez vous connecter pour publier un commentaire.