I have been doing a lot of work with the SharePoint Client
Object Model (COM) and wanted to share some of my experiences. The COM is going to be more important as we
start building more mobile applications and think about building SharePoint
apps.
First off, I did not start with the SharePoint COM; I
thought I would be able to build my site using the SharePoint REST web
services. One of my requirements though
was to be able to use Anonymous access and that just doesn’t seem to be
possible with the REST web services in 2010.
Although, if anybody knows how to do this, I would love to know. So I ended up with the COM as it supports
both authenticated and anonymous users (assuming of course that your Site
Collection has been properly setup to allow anonymous users). Overall the COM and REST web services do
pretty much the same thing, although the COM does have this neat feature of
being able to put together multiple actions into a single request. All and all I may have been forced into the
correct method after all.
The basic usage of the COM is very similar to the Object
Model. For example here is the code to
get all the list items from a list:
using (ClientContext sharePoint = new ClientContext(_strSPURL))
{
Web
web = sharePoint.Web;
ListCollection
spLists = web.Lists;
List
spList = spLists.GetByTitle("Pages");
CamlQuery
camlQuery = new CamlQuery();
camlQuery.ViewXml = @"<View>
<ViewFields>
<FieldRef Name='ID'/>
<FieldRef
Name='AudienceTaxHTField0' />
<FieldRef Name='ServiceTaxHTField0'
/>
<FieldRef Name='Title' />
<FieldRef Name='ContentTypeId' />
</ViewFields>
<Query>
<OrderBy>
<FieldRef Name='Modified' Ascending='False'/>
</OrderBy>
</Query>
</View>";
Microsoft.SharePoint.Client.ListItemCollection spListItems = spList.GetItems(camlQuery);
sharePoint.Load(spListItems, items =>
items.Include(
item => item["ID"],
item => item["AudienceTaxHTField0"],
item => item["ServiceTaxHTField0"],
item => item["Title"],
item => item["ContentTypeId"]));
sharePoint.ExecuteQuery();
return
spListItems;
}
As you can see, it is pretty much the same as you do
now. The ClientContext is like opening a
SPSite object. After that we open a
SPWeb object, get the list, run a CAML query and return the items. The other thing you may notice is that I
explicitly tell SharePoint which fields to return. This ensures SharePoint only returns the data
I’m interested, the smallest package possible; as a side note you should also
be doing this when using the Object Model…I mean have you seen all the crap
SharePoint returns if you don’t do this?
Some gotcha’s
You can only use this against a Site Collection. You have no access to anything higher.
The biggest gotchas I ran into where with the Taxonomy
fields. In the 2010 COM there are no
Taxonomy Field objects (they are in the 2013 COM). This means when trying to get data from
Taxonomy fields you will have to reference the hidden Taxonomy field that is
associated to the field you are interested.
You’ll noticed in the above example I’m referencing AudienceTaxHTField0
and not Audience which is the field you would see when using the site. The other piece is the value coming back from
this field will be the raw form, meaning that you will need to massage it a bit
for it to be useful, unless of course you love GUIDs.
The other thing to keep in mind is performance. Since your application will be making web service
calls to SharePoint, using the COM, each request will have a minimum round trip
time. When coding try to limit the
amount of round trips as much as possible and if possible think of using asynchronous
methods so that the page doesn’t have to wait for all the data before it starts
rendering. Remember, it will be quicker
to get a bunch of data and massage it in your app/site rather then make several
little calls…to a point as if you ask for too much data this will also have a
negative impact on the round trip time…you’ll need to find a balance.
References:
