Applying the Concepts of the SharePoint App Model to SharePoint 2010
Legacy Code Is Still Out There
The SharePoint 2016 Preview was released in August and many companies are already moving toward the cloud and SharePoint Online. However, a good number of enterprises still have SharePoint 2010 (and perhaps older) farms hanging around. It’s likely those on premise 2010 farms host highly-customized SharePoint solutions and perhaps require occasional enhancements. This is the case in our organization.
Our development team was approached and asked to enhance a SharePoint 2010 solution so that our site could display news feeds from an external vendor. The site must cache feeds so that the page displays correctly even if the remote site is unavailable at the time of page load. Naturally, we asked our SharePoint 2010 developer to devise a solution to this problem. A short while later the developer delivered a technical approach that is steeped in SharePoint tradition.
The SharePoint Way of Doing Things can be Expensive, Time Consuming and Disruptive
The solution proposes to provision content types, site columns, and lists during in the usual way, via feature activation. These two lists would hold the remote URL (feed) and the fetched content from the remote feed. A timer job would read from the feed configuration list and fetch the data storing the results into a second SharePoint list. Lastly, a custom (server side) web part would be created to read and display the contents of the retrieved news feeds list on the page with all the appropriate sorting, formatting, and style our users expect.
On the surface, this seems like a perfectly reasonable solution for the task at hand. The use of a full-trust deployed solution to create needed plumbing such as content-types and lists was how it should be done in those heady, salad days of SharePoint 2010. The proposed solution can confidently claim that it adheres to the best practices of SharePoint 2010.
However, there are drawbacks to going with a traditional SharePoint-based solution. Before the advent of the sand-boxed solution in 2010 it was very easy for a poorly written SharePoint solution to adversely affect the farm on which it was installed. Custom code has caused many a SharePoint admin sleepless nights. We don’t want to introduce new code to the farm if it’s not completely necessary.
Our team employs both SharePoint developers as well as .NET developers. Our contract SharePoint developers command a higher hourly rate than our “run of the mill” .NET developers. As our industry is extremely cost sensitive right now it would be great if we could avoid the use of specialized SharePoint developers for this one off project.
This last bit could be unique to our organization and may not be applicable to yours. We have a stringent process for SharePoint deployments. Suffice it to say, from the first request to have code promoted to test that a minimum of two weeks must pass before the code is deployed to production. Content updates, such as adding web parts and editing pages is not subject to this testing period. The ideal solutions would avoid an “formal” SharePoint development.
Why the SharePoint App Model is Cool!
The SharePoint app model was introduced with Office and Sharepoint 2013. With the app model, Microsoft no longer recommended that developers create solutions that are deployed directly on the SharePoint farm. Rather, developers create “apps” that are centrally deployed from an app catalog and run in isolation from SharePoint processes. SharePoint App Model code runs entirely on the client (browser) or in a separate web application on a remote server. Apps’ access to SharePoint internals are funneled to a restricted and constricted RESTful API.
The app model prevents even the worst behaving application from affecting the SharePoint farm. This means the farm is more stable. Additionally, applications written using the App Model do not require a deployment to the farm or not the type of deployment that would necessitate taking farm into maintenance or resetting IIS. Under the App Model SharePoint remains up even as new applications are made available. Customers are happy you can quickly pound out their requests and make them available and admins are happy because your custom code isn’t taking down their farm (allegedly).
Sadly, the app model doesn’t exist for SharePoint 2010, or does it? While specific aspects of the App Model do not exist in SharePoint 2010 you can still embrace the spirit of the App Model! The very heart of the SharePoint App Model concept is running custom code in isolation away from SharePoint. In our case we really only need to interact with SharePoint at the list level. Fortunately, SharePoint 2010 provides a REST API for reading and writing to lists.
Let’s re-imagine our solution and apply App Model-centric concepts in place of traditional SharePoint dogma.
First let’s use PowerShell scripts to create our Site Columns, Content Types, and lists rather than having a solution provision these objects on feature activation.
Next, let’s replace the SharePoint timer job with a simple windows console application that can be scheduled as a Windows scheduled task or kicked off by an agent such as Control-M. This console app will read a SharePoint list using the REST API, then run out to fetch the content from the Internet writing the results back to a second list using the REST API.
By cobbling together a set of non-SharePoint components we have, essentially, created an App Model-like solution for SharePoint 2010; a poor-man’s App Model if you will.
In my opinion, this solution is superior to the SharePoint way of doing things in the following ways:
- Ease of Maintenance / Confidence – Using PowerShell to create columns, content-types, and list is better because scripts can be tested and debugged easily. Deployments that provision sites are more complicated and time consuming. From the perspective of a SharePoint admin PowerShell is likely a known entity. Admins can examine exactly what this code will be doing to their farm for themselves and perhaps gain a highly level of confidence in the new software being deployed.
- Lower Development Cost / Ease of Maintenance A Windows console app is superior to a timer job because you don’t need to pay an expensive SharePoint developer to create or support a solution on a depreciated platform (SP 2010). Maintaining a console application requires no specific SharePoint experience or knowledge. In our case, we have an entire team that ensures timed jobs have run successfully and can alert on failure as needed.
- Reliability / Availability – There is no custom code running within the SharePoint process. This means there is NO chance of unintended consequences of misbehaving code created for this solution affecting your Farm.
- No Deployment Outage – This solution can be implemented without taking down the SharePoint farm for a deployment. Adding a simple content editor web part does not interrupt business operations.
- Ease of Portability / Migration – Our solution, using a console app, HTML, and Javacript works just as well on SharePoint 2013 and Office 365 as it will with SharePoint 2013. Whereas a traditional SharePoint solution cannot be directly ported to the cloud.
There is a lot of legacy SharePoint 2010 out there, especially in large enterprises where the adoption and migration to newer platforms can take years. Occasionally, these older solutions need enhancements and support. However, you want to spend as little time and money as possible on supporting outdated platforms.
We needed a solution that had the following characteristics:
- We didn’t want to continue to write new server-side code for SharePoint 2010.
- We wanted a solution that didn’t require an experienced SharePoint developer to create and maintain.
- We wanted code that was modular and easily migrated to Office 365.
- We wanted to avoid a formal SharePoint deployment and its associated outage.
A traditional SharePoint solution was not going to get us there. Therefore, we took the best parts of the SharePoint App Model (isolation, unobtrusive client side code, and RESTful interfaces to SharePoint) and created a holistic solution that fulfilled the customers’ expectations.
I am a senior software developer and development team lead in Houston Texas. I am passionate about the “art” of software development. I am particularly interested in software design patterns and the principles of SOLID object-oriented code. I am an evangelist for test driven development. I love to think and write about my day-to-day experiences in the trenches of enterprise IT. I relish the opportunity to share my experiences with others.