SharePoint Client Object Model

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:

SharePoint 2010 Client Object Model: http://msdn.microsoft.com/en-ca/library/ee537247(v=office.14).aspx

Using the SharePoint 2010 Managed Client Object Model: http://blogs.msdn.com/b/ericwhite/archive/2009/11/20/using-the-sharepoint-2010-managed-client-object-model.aspx