1. There is no definite checklist for deploying SharePoint for the Internet. Every project is different and there are no silver bullets. In fact, it is not even a real checklist (just a list of items I’d like to consider on every internet project).

2. This is my checklist based on experiences with past projects, your mileage may (and will) vary  

3. There are so many options and configurations possible, it is not just about enabling/disabling features and options to achieve your goal. Every option should be investigated thoroughly and remember: ‘Just because you can, doesn’t mean you should’. 

Since there many options to consider, I divided them in three main categories and three separate blog posts:

• Part 1: Performance (this post)
• Part 2: Security
• Part 3: Customization and usability

Performance

Big topic for internet facing websites. While SharePoint 2010 performs a lot better compared to previous versions, performance will (and should) always be on your list.

#1: Reduce page load

• Remove the “Name Active X Control”. This control is used by SharePoint to show presence information (the little icon next to author names, etc.) and has no meaning on public (anonymous) web sites. You can do this through Central Administration (Web Application General Settings:

• Remove the reference to the SharePoint Workspace ActiveX from the master page (present if based on the OOTB master pages).
• Limit the use of Content Query Web Parts on landing pages. While this is a beautiful Web Part, it adds significantly to the page load time especially initially with uncached data. As a workaround you could use custom developed web parts or user controls to achieve your data query goals. This way you have good control of the rendered HTML and avoid the XSLT query processing part. But make sure you have some kind of caching in place.
• Remove the Ribbon for anonymous users. There are a couple of ways to do this, these are the most obvious ones:

• Minify jQuery and other 3rd party JavaScript libraries. Use a CDN if applicable for the libraries since this facilitates caching by browser, proxy server, etc. Remember to enable local fail-over copies.

#2: Monitor Page Requests

• Use a network monitor or traffic inspector (like Fiddler2) to monitor the HTTP request and response associated with a page request. These type of tools make optimizing page loads a whole lot easier.
• Use the SharePoint Developer Dashboard to monitor processing and render times of individual components.

#3: Adjust IIS Dynamic Compression

• By default SharePoint Web Servers have static and dynamic file compression enabled, but the compression level for dynamic files is set to “0”. This means that dynamic files don’t get compressed at all. You can adjust the compression level and the CPU threshold settings, for more information see Technet. It is not just about enabling this, you will have to monitor performance and Web Server CPU for tuning adjustments.

#4: Caching

SharePoint 2010 and the underlying ASP.NET offer several different methods for caching. Again no silver bullets here, and my advice: develop a caching strategy! The way you configure the different caching options totally depends on the type of content served (static versus dynamic), the audience, intended web site usage and so on. Make a note on what type of cache you configure, how you configure it and what results you expect. Once you start monitoring your site’s performance you can easily check and adjust where needed.

More info on this topic, see Technet.

• The BLOB cache. BLOB stands for Binary Large OBject and is a disk based storage. Files initially retrieved from the SharePoint Content Database are stored on disk and served to clients on subsequent requests. You need to think about what type of files to store, where to store them (on the web server) and what client cache life time to configure (max-age).
• The Object cache. If you are using SharePoint’s publishing feature (and you probably are on internet facing sites), you can configure this cache. The cache stores SharePoint objects (lists, page layouts, etc.) in-memory to speed up queries on them. They require the correct configuration of what is called the “Object Cache User Accounts”, again see Technet for more information.
• Output cache. Based on ASP.NET Output Caching, but with added features (which also require the SharePoint publishing feature). Usually the least popular of the three, probably because it is a little bit harder to configure correctly. There are a couple of considerations to make, so definitely take a look at the Technet article.

Please, feel free to comment on this topic, more coming soon.

More info on the Lockdown feature on this MSDN blog (MOSS 2007, but still applicable. By Ryan Duguid)

As we all know, SharePoint 2010 includes the Health Analyzer. This component uses a bunch of rules to check the farm for predefined issues and report on any found:

Fortunately, the rule set is extensible and we can add our custom ones. This is not a difficult task and a good candidate for our feature check!

To start we need to create a class that inherits from either the SPHealthAnalysisRule or SPRepairableHealthAnalysisRule. From these abstract classes we need to implement some string properties “Summary”, “Explanation” and “Remedy” (for explaining the issues found) and the “Category” and “ErrorLevel” properties. The “Check()” method performs the actual analysis so must be implemented too. If you want users to be able to execute a repair right from the Central Administration interface, the SPRepairableHealthAnalysisRule includes a “Repair()” method just for that. Finally we can implement the “AutomaticExecutionParameters” property to enable automatic Timer Job execution for our rule and in this case we do.

More detailed info on this on MSDN.

1. We start with an Empty SharePoint Project, and deploy it as a Farm Solution. We add our Central Administration web as our Site Url.

2. Next we add the class that inherits from SPHealthAnalysisRule and add the necessary using statements. After implementing the abstract class our rule looks like this:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.SharePoint;
using Microsoft.SharePoint.Administration;
using Microsoft.SharePoint.Administration.Health;

namespace Blog.Examples.HealthAnalysisRule
{
     public sealed class ViewFormPagesLockDown : SPHealthAnalysisRule
    {
        public override SPHealthCategory Category
        {
            get { throw new NotImplementedException(); }
        }

        public override SPHealthCheckStatus Check()
        {
            throw new NotImplementedException();
        }

        public override SPHealthCheckErrorLevel ErrorLevel
        {
            get { throw new NotImplementedException(); }
        }

        public override string Explanation
        {
            get { throw new NotImplementedException(); }
        }

        public override string Remedy
        {
            get { throw new NotImplementedException(); }
        }

        public override string Summary
        {
            get { throw new NotImplementedException(); }
        }
    }
}

3. Next we add our logic to the Check() method to do the actual testing. This method uses two helper functions, both included in the downloadable solution:

• isAnonymousEnabled: checks if the Web Application has Anonymous Access turned on.
• isFeatureActivated: checks if the FormPagesLockDown feature is activated.

The method itself stores any failing Web Application and a counter which we can use for reporting the issues.

public override SPHealthCheckStatus Check()
{
            SPHealthCheckStatus ret = SPHealthCheckStatus.Passed;
            SPFarm farm = SPFarm.Local;
            foreach (SPService service in farm.Services)
            {
                if (service is SPWebService)
                {
                    SPWebService webService = (SPWebService)service;
                    foreach (SPWebApplication webApp in webService.WebApplications)
                    {
                        if (isAnonymousEnabled(webApp))
                        {
                            foreach (SPSite site in webApp.Sites)
                            {
                                try
                                {
                                    if (!isFeatureActivated(site, new Guid(FEATUREGUID)))
                                    {
                                        //Anonymous Access is enabled on the Web Application, but the ViewFormsLockDown feature was not found.
                                        this.failingWebApplications.Add(webApp.Name, +1);
                                    }
                                }
                                finally
                                {
                                    if (site != null)
                                    {
                                        site.Dispose();
                                    }
                                }
                            }
                        }
                    }
                }
            }
            if (this.failingWebApplications.Count == 0)
            {
                ret = SPHealthCheckStatus.Passed;
            }
            else
            {
                ret = SPHealthCheckStatus.Failed;
            }
            return ret;
 }

4. Finally implement the property “SPHealthAnalysisRuleAutomaticExecutionParameters” to enable automatic Timer Job schedules.

public override SPHealthAnalysisRuleAutomaticExecutionParameters AutomaticExecutionParameters
{
            get
            {
                SPHealthAnalysisRuleAutomaticExecutionParameters retval = new SPHealthAnalysisRuleAutomaticExecutionParameters();
                retval.Schedule = SPHealthCheckSchedule.Daily;
                retval.Scope = SPHealthCheckScope.All;
                retval.ServiceType = typeof(SPTimerService);
                retval.RepairAutomatically = false;
                return retval;
            }
 }     

5. We now could build and deploy, but we would have to register the custom Health Analyzer rules through PowerShell. This process can be automated through SharePoint’s feature framework.

 public override void FeatureInstalled(SPFeatureReceiverProperties properties)
 {
            try
            {
                Assembly currentAssembly = Assembly.GetExecutingAssembly();
                IDictionary exceptions = SPHealthAnalyzer.RegisterRules(currentAssembly);
            }
            catch (Exception ex)
            {
                throw new Exception("There was an error registering the Health Analysis rules: " + ex.Message); 
            }
}

If we compile and deploy, we can see our rule in action.

If you want the rule to report any errors, make sure you enable anonymous access on a Web Application and disable the (hidden) feature. Of course we should use PowerShell for this:

Disable-SPFeature -Identity ViewFormPagesLockDown -Url http://public.demo.loc

Download the complete solution here.

By default this score is calculated using two performance counters: Memory/Available Mbytes and ASP.NET/Requests Current. A value “0” indicates everything is fine, while a value of “10” indicates SharePoint will start throttling requests (if enabled). There is quite some info around explaining the workings and configuration. This blog post for instance: http://blogs.msdn.com/b/besidethepoint/archive/2010/09/13/http-request-throttling-in-sharepoint-2010.aspx (by Josh Gavant).

Since this header is added to every response it can be used for different purposes, from monitoring to load balancing. I wanted to create a small “tool” to report the score without having to use a network monitor or HTTP sniffer like Fiddler. And what better way than to use PowerShell for this task?

The script uses a simple PowerShell function with a System.Net.WebClient object connecting to a SharePoint site and retrieving the header:

function ReadHealthScore()
{
	param([string]$url,[System.Net.NetworkCredential]$cred=$null)
	
	$wc = New-Object Net.WebClient
	
	# Include the IE9 User Agent
	$wc.Headers.Add("user-agent", "Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Trident/5.0;)")

	if($cred -eq $null)
	{
		$cred = [System.Net.CredentialCache]::DefaultCredentials;
	}
	$wc.credentials = $cred;
	$page = $wc.DownloadString($url);
	
	# This header holds the Health Score
	return $wc.ResponseHeaders.Item("X-SharePointHealthScore")
}

Combined with some logic to calculate average, minimum and maximum:

# Wait in number of seconds
$wait = 1
$times = 5
$score = @()

# Set the URL to a page to avoid redirection errors
$url = "http://portal.demo.loc/Pages/Default.aspx"

for ($i=1; $i -lt $times+1; $i++) {
 	$score = $score + (ReadHealthScore($url))
	Write-Progress -Activity "Reading HealthScore" -PercentComplete (($i/$times)*100) -Status "Working"
  	Start-Sleep -Seconds $wait
}

$calc = $score | Measure-Object -Average -Maximum -Minimum
Write-Host (Get-Date -f o) "Average:"$calc.Average " High:"$calc.Maximum " Low:"$calc.Minimum

We get the following output:

With a little modification you can output to xml or CSV. Schedule it using Task Scheduler and you will have a nice little health reporter.

Download the script here.

Note: since this script doesn’t use any specific SharePoint cmdlets, you can use standard Windows PowerShell.

SharePoint 2010 Enterprise Search uses ranking models to determine how data is weighed and results are ranked. Out of the box SharePoint 2010 provides different models, but you can also create your own. Creating your own ranking model allows you to tailor the results your query returns by:

• assigning different weights to metadata properties.
• include hits on custom managed properties in general search (as opposed to searching them through advanced search exclusively).

There are several nice blogs out there that describe in detail how you can add your own custom ranking model. For instance this excellent blog post, which describes the process quite clear: http://calvisblog.wordpress.com/2010/06/21/custom-ranking-models-with-sharepoint-2010-background-value-and-administrative-overview/ (by Shaun O’Callaghan).

Applying your custom ranking model requires you to look up the GUID, export the standard OOB Core Results Web Part, modifying a web part property and uploading it again (see this previous post). Now, that works of course, but I wanted a true end-user solution where you can configure the ranking model through the web part properties. Something like this:

Extending the Core Results Web Part

Note: we need to develop a SharePoint Farm Solution, because the Microsoft.SharePoint.WebPartPages.DataFormWebPart class (referenced
by the CoreResultsWebPart) is not available in sandbox solutions.

To start, we create a new web part deriving from the Core Results Web Part. The web part includes a property that allows setting the RankingModelID. It also inherits from IWebEditable needed for implementing an EditorPart (see further down).

public class EnhancedCoreResults : CoreResultsWebPart, IWebEditable
{
     [WebBrowsable(false)]
     [Personalizable(PersonalizationScope.Shared)]
     public string rankingModelID { get; set; }


 }

I want the web part properties to show the available Ranking Models so the user can select them from a dropdown list. For this to work, we cannot use regular properties and have to implement an EditorPart. The reason for this, is that regular properties don’t allow you to dynamically load values through code behind and I don’t want to hardcode the values for the dropdown list.

Next, create the EditorPart:

The EditorPart needs to get the names and values of the available ranking models. For this to work, we need to connect to our Search Service Application and fetch the available models:

class EnhancedCoreResultsEditorPart:EditorPart
    {
        private DropDownList rankingModelList = new DropDownList(); 

        protected override void CreateChildControls()
        {
            base.CreateChildControls();

            RankingModelCollection rankingModels = null;

            SPServiceContext context = SPServiceContext.GetContext(SPContext.Current.Site);
            SearchServiceApplicationProxy searchApplicationProxy = context.GetDefaultProxy(typeof(SearchServiceApplicationProxy)) as SearchServiceApplicationProxy;
            SearchServiceApplicationInfo searchApplictionInfo = searchApplicationProxy.GetSearchServiceApplicationInfo();
            Guid searchApplicationID = searchApplictionInfo.SearchServiceApplicationId;
            SearchServiceApplication searchApplication = SearchService.Service.SearchApplications.GetValue<SearchServiceApplication>(searchApplicationID);

            Ranking ranking = new Ranking(searchApplication);
            rankingModels = ranking.RankingModels;

            foreach (RankingModel rankingModel in rankingModels)
            {
                ListItem item = new ListItem();
                item.Text = rankingModel.Name;
                item.Value = rankingModel.ID.ToString();
                rankingModelList.Items.Add(item);
            }

            this.Controls.Add(new LiteralControl("<div class=\"UserSectionHead\">Ranking Model</div>"));
            this.Controls.Add(new LiteralControl("<div class=\"UserSectionBody\">"));
            this.Controls.Add(rankingModelList);
            this.Controls.Add(new LiteralControl("<br/><br/></div>"));

            this.ChildControlsCreated = true;
        }
}

The EditorPart sets the web part RankingModelID using the value from our dropdown list.

     public override bool ApplyChanges()
        {
            EnsureChildControls();

            EnhancedCoreResults enhancedCoreResultsWebPart = (EnhancedCoreResults)this.WebPartToEdit;
            if (enhancedCoreResultsWebPart != null)
            {
                enhancedCoreResultsWebPart.rankingModelID = rankingModelList.SelectedValue; 
            }
            else
            {
                return false;
            }
            return true;
        }

        public override void SyncChanges()
        {
            EnsureChildControls();

            EnhancedCoreResults enhancedCoreResultsWebPart = (EnhancedCoreResults)this.WebPartToEdit;
            if (enhancedCoreResultsWebPart != null)
            {
                rankingModelList.SelectedValue = enhancedCoreResultsWebPart.rankingModelID;
            }
        }

Wire up the EditorPart in our custom Core Results class:

        EditorPartCollection IWebEditable.CreateEditorParts()
        {
            List<EditorPart> editors = new List<EditorPart>();
            EnhancedCoreResultsEditorPart editorPart = new EnhancedCoreResultsEditorPart();
            editorPart.ID = "EnhancedCoreResults_editorPart";
            editors.Add(editorPart);
            return new EditorPartCollection(editors);
        }

        object IWebEditable.WebBrowsableObject
        {
            get { return this; }
        }

Create the logic that actually sets the RankingModelID by overriding the ConfigureDataSourceProperties() method:

     protected override void ConfigureDataSourceProperties()
        {
            if (this.ShowSearchResults)
            {
                base.ConfigureDataSourceProperties();

                if (!string.IsNullOrEmpty(rankingModelID))
                {
                    CoreResultsDatasource dataSource = this.DataSource as CoreResultsDatasource;
                    dataSource.RankingModelID = rankingModelID;
                }
            }

        }

Note: I found several articles on the web showing similar functionality by overriding the GetXPathNavigator() method and setting the ranking model through the SharedQueryManager instance. Somehow I couldn’t get this to work the way I wanted to so I decided to do it differently.

That’s it, build, package and deploy.

You can download the Visual Studio solution here.

To fix this, you need to edit the ItemStyle.xsl (preferably a custom one, see this post). You would just have to add the following command to the part outputting the HTML:

<xsl:value-of disable-output-escaping="yes" select="$blah"/>

One other thing to watch out for, is when creating summary descriptions from these rich text fields. Say you have this text:

<h1 class=”ms-rteElement-H1″>Cras porta pharetra magna eget consectetur. </h1> <p class=”ms-rteElement-H1″> </p> <p>Etiam eget nibh eu libero dictum congue. Etiam tempor auctor lectus, at porta dolor molestie vitae.</p>

And you want to create a summary of 150 characters with a “Read More” link. You would cut off the output rendering and potentially leave open HTML tags! And that could really screw up the user experience. So another option would be to strip all html from your output. This way you will loose the rich text markup (H1, bolds and so on), but ensure valid html output.

To accomplish this, you would also need to edit the ItemStyle.xsl (again preferably a custom one) and include some kind of HTML stripping function.

<xsl:template name="Functions.RemoveHtml">
    <xsl:param name="String"/>
    <xsl:choose>
      <xsl:when test="contains($String, '&lt;')">
        <xsl:value-of select="substring-before($String, '&lt;')"/>
        <xsl:call-template name="Functions.RemoveHtml">
          <xsl:with-param name="String"
            select="substring-after($String, '&gt;')"/>
        </xsl:call-template>
      </xsl:when>
      <xsl:otherwise>
        <xsl:value-of select="$String"/>
      </xsl:otherwise>
    </xsl:choose>
</xsl:template>

 Get-SPEnterpriseSearchRankingModel -SearchApplication "Search
 Service Application"

The default Core Results Web Part uses the MainResultsDefaultRankingModel and the People Results Web Part uses the MainPeopleModel. To try the different models, you can just append the search results querystring with &rm=<guid>

So …/Pages/peopleresults.aspx?k=john&s=People&rm=0bba4d7d-4f2c-4086-975a-8f9d2b6c6d53 would return people results using the NameModel.

If you want to permanently alter the used ranking model, you have to adjust the Results Web Part. Follow these steps to modify the normal search:

1. Export the Core Results Web Part.
2. Add or modify the following property, for instance:
   <property name=”DefaultRankingModelID” type=”string”>0bba4d7d-4f2c-4086-975a-8f9d2b6c6d53</property>.
3. Import and re-add the web part.

For people search, this unfortunately does not work very well. The People Core Results Web Part will reset your DefaultRankingModelID back to use the MainPeopleModel once you upload your web part. Just add a (hidden) Core Results Web Part to your page and configure the property that way.

Here are a couple of things you could do to speed things up a bit.

1. Fast hardware

Of course the most important part. Be sure to have a lot of RAM in your development machine, at least 4 GB. With the 64-bit OS requirement for SharePoint 2010 we can address more than 3 GB so make sure it is available. Even current generation laptops can handle 8 GB of RAM, no excuses anymore (apart from budget that is).

Because you probably run all required software on one machine, fast disks are equally important. This component improves the overall experience, but MSSQL Server benefits the most. If you are running virtuals, you can go for fast external disks using eSata (or maybe USB 3.0). If you are more like me (and don’t like the external disk hassle) be sure to examine the disk specs when shopping for new hardware.

2. The right OS

I tried running Windows 7 Ultimate with SharePoint 2010 installed locally. Yes it works, but it is still a desktop OS. And you really can’t run things like domain controllers and stuff like that locally. If you really want things to go fast, you boot a regular server OS, say Windows Server 2008 R2. It handles server software far better than any desktop OS. And if you can, just install all needed components on one server (i.e. MSSQL Server, SharePoint 2010, Visual Studio, Office, Domain Controller, DNS, etc.). And Windows 7 VHD boot makes dual booting a breeze!

If you do need more than one server, think about installing Windows Server 2008 R2 with the Hyper-V role. And run your servers on top of that! You will probably need at least 8GB (host + 2 guests), but will give you ultimate flexibility.

3. Tweak your OS and server software

Same old story:

• Don’t run unneeded services or components. No, you don’t need Adobe Auto Updater or the Windows Media Player Online Subscription blah blah. Check the Windows Services and registry “run” keys.
• If you run MSSQL Server (and you probably do), be sure to maximize its memory to a value you consider adequate. This way, it won’t hog up your machine. Also if you have more than one disk, store the “tempdb” on a different disk than the content or configuration database. Other “production” performance tweaks also apply of course.
• Regarding SharePoint IIS configuration, I normally run most parts on the same Application Pool. This saves valuable memory, but makes recycling take a bit longer. If you run many Web Applications but only develop in one, dedicate one AppPool to your development application and share the rest.
• Keep your content databases lean. There is normally no need to develop against a 50+ GB database. Just use a default empty one or with limited content. You can of course switch later on if you need to test your solution.

4. Be smart

When deploying and debugging SharePoint solutions, Application Pool recycles are a pain! Be smart when laying out your Visual Studio projects and decide which parts must be farm solutions and which parts sandbox solutions. Remember: farm solutions require a IIS recycle where as sandbox solutions do not (see earlier post about Sandbox solutions). You can always merge them later when heading towards production state.

If you are developing loads of Web Parts or User Controls (used by Visual Web Parts), there is another thing you could do. Since most of them are plain ASP.NET components, you can stick them on a simple ASPX page and develop them using IIS. Especially handy during the early stages and you can add them to your SharePoint project when they need a SharePoint environment.

5. Time savers

You probably already have the “CKS: Development Tools Edition” installed. If not, please do. They also contain several time savers regarding deployment, like Quick Deploy, Copy Assemblies and Copy Files. There is even a feature that warms up your site after a IIS recycle!

You probably have other tricks up your sleeve, but I thought I’d share mine.

Other parts:

• Part 1, the Validating Email Field.

So here is part 2, the custom Content Query Web Part Item Style

Aaahh, the Content Query Web Part, or CQWP for short. The Swiss Army Knife no real SharePoint solution architect can do without. If you are not familiar with the Content Query Web Part in SharePoint, here is a small introduction. I won’t go in depth on all the different advanced options you might have configuring the CQWP, because there are lots of good articles about that out there. I do focus on how you would package and deploy such a customization using Visual Studio 2010.

Introduction

The Content Query Web Part (CQWP) was first introduced in SharePoint MOSS 2007. It allows for querying and presenting SharePoint data in a very flexible and customizable way and is considered one of the most important Web Parts in SharePoint. It can roll up SharePoint items:

• Throughout your site collection.
• In one specific site and all of its sub sites.
• In one specific list.

As an example, say you want to do an aggregation (“roll up”) of all news articles from your news site and show the latest 3 with a thumbnail image on your home page? Easy with the help of the CQWP:

You start with configuring the CQWP through the settings in the Web Part toolbox.

The Query part determines where you will get your items from:

• Source: the scope of the query.
• List Type: choose the list type your items are in. In this case we pick Pages Library because our news articles are based on Publishing Pages stored in the default Pages library.
• Content Type: we only want to return Article Pages and not Web Part pages.

The Presentation part determines how the items will be presented on the page:

• Grouping and Sorting: speaks for itself. We pick 3 items, sorted by Article Date Descending.
• Styles: the group style is used when we group the items and is not used in this example. The Item style is the most interesting part and controls how the items are rendered. There are several options, so be sure to check them all out. For now we pick the default “Image on left”.

Fields to display:

This part is a new feature of the CQWP in SharePoint 2010. These fields are called “Slots” and are used to bind item fields to XSL properties. Every item style template can have its own set of configurable fields.

Customization

This post is about configuring and customizing the CQWP if you are not *that* happy with the standard behavior of the available Item Styles. My most requested style for instance, is not available out of the box:

• the title on top
• the image on the left, just beneath the title
• the byline to the right of the image
• the first 200 characters of the article content, beneath the byline
• a read more link

The standard CQWP gets its configuration from files in the Site Collection Style Library. These files are shared among all default Content Query Web Parts in your site. Let’s take a closer look at these files and the best way to do this is using SharePoint Designer. Just open up your site and navigate to the All Files section. Here you will find the Style Library with the XSL Style Sheets:

The file we are interested in is the ItemStyle.xsl. If you take a peek at the contents of this file, you will find several <xsl:template> elements which correspond to the different Style options you see configuring the CQWP. The names of the template should mostly speak for themselves. One exception, the “Image Left” is called “Default”.

Important:If you are not familiar with XSL you might want to read up on the subject. We keep our customization fairly simple, so you will just need a basic understanding.

We could of course modify the OOTB file using SharePoint Designer and create our customization that way. And that is a perfectly supported scenario, but with three major downsides:

• This is an OOTB file and if it is modified it is saved to the content database. If someone chooses to reset it to the site definition all your changes would be lost.
• Coexistence with other applications could be hard since you would have to share the default ItemStyle.xsl among them.
• If you mess up the default ItemStyle.xsl it could affect other Content Query Web Parts in the Site Collection.

So the best way around these issues is to supply our own style sheet with our Web Part.

To start, create a Visual Studio 2010 Empty SharePoint solution. Since we don’t have an assembly that needs Full Trust (see my earlier post about Sandbox solutions), we select a sandboxed solution.

Add a SharePoint module:

After the module is added to the project, delete the Sample.txt

Next we add the XSLT Style Sheet: Add New Item/ Data / Style Sheet. Remember to give it a .xsl extension instead of .xslt to be in line with OOTB SharePoint files.

Your Solution should now look like this:

My next step is to copy the content of the OOTB file in my new file to start off with.

Open the default file in SharePoint Designer and answer “No” to the question if you want to check the file out (see downside no. 1). Copy and Paste the contents in your new file in Visual Studio, clearing the current contents of the file.

You now effectively made a copy of the OOTB file and are ready to create your own rendering template (the actual CQWP Item Style customization).

To give yourself a head start, it is easiest to copy a similar one. In this case that would be “Image Left”, which is called “Default” in the ItemStyle.xsl. Just copy and paste the complete template (everything between and including the <xsl:template name=”Default” match=”*” mode=”itemstyle”> and </xsl:template> tags).

Rename our template to something like “ImageWithArticleContent” and replace the wildcard match (“*”) with our specific style.

<xsl:template name=”ImageWithArticleContent” match=”Row[@Style='ImageWithArticleContent']” mode=”itemstyle”>

The next step is to reorganize the template to match our requested design. Basically it just starts with the title and the image and finally the Byline (“description”). We then add a new property “Content” and display the first 200 characters and the Read More link. Because we add a property a new slot will be created in the CQWP toolbox as we’ll see later.

<xsl:template name="ImageWithArticleContent" match="Row[@Style='ImageWithArticleContent']" mode="itemstyle">
    <xsl:variable name="SafeLinkUrl">
      <xsl:call-template name="OuterTemplate.GetSafeLink">
        <xsl:with-param name="UrlColumnName" select="'LinkUrl'"/>
      </xsl:call-template>
    </xsl:variable>
    <xsl:variable name="SafeImageUrl">
      <xsl:call-template name="OuterTemplate.GetSafeStaticUrl">
        <xsl:with-param name="UrlColumnName" select="'ImageUrl'"/>
      </xsl:call-template>
    </xsl:variable>
    <xsl:variable name="DisplayTitle">
      <xsl:call-template name="OuterTemplate.GetTitle">
        <xsl:with-param name="Title" select="@Title"/>
        <xsl:with-param name="UrlColumnName" select="'LinkUrl'"/>
      </xsl:call-template>
    </xsl:variable>
    <div class="item">
      <div class="link-item">
        <xsl:call-template name="OuterTemplate.CallPresenceStatusIconTemplate"/>
        <a href="{$SafeLinkUrl}" title="{@LinkToolTip}">
          <xsl:if test="$ItemsHaveStreams = 'True'">
            <xsl:attribute name="onclick">
              <xsl:value-of select="@OnClickForWebRendering"/>
            </xsl:attribute>
          </xsl:if>
          <xsl:if test="$ItemsHaveStreams != 'True' and @OpenInNewWindow = 'True'">
            <xsl:attribute name="onclick">
              <xsl:value-of disable-output-escaping="yes" select="$OnClickTargetAttribute"/>
            </xsl:attribute>
          </xsl:if>
          <xsl:value-of select="$DisplayTitle"/>
        </a>
      </div>
      <xsl:if test="string-length($SafeImageUrl) != 0">
        <div class="image-area-left">
          <a href="{$SafeLinkUrl}">
            <xsl:if test="$ItemsHaveStreams = 'True'">
              <xsl:attribute name="onclick">
                <xsl:value-of select="@OnClickForWebRendering"/>
              </xsl:attribute>
            </xsl:if>
            <xsl:if test="$ItemsHaveStreams != 'True' and @OpenInNewWindow = 'True'">
              <xsl:attribute name="onclick">
                <xsl:value-of disable-output-escaping="yes" select="$OnClickTargetAttribute"/>
              </xsl:attribute>
            </xsl:if>
            <img class="image" src="{$SafeImageUrl}" title="{@ImageUrlAltText}">
              <xsl:if test="$ImageWidth != ''">
                <xsl:attribute name="width">
                  <xsl:value-of select="$ImageWidth" />
                </xsl:attribute>
              </xsl:if>
              <xsl:if test="$ImageHeight != ''">
                <xsl:attribute name="height">
                  <xsl:value-of select="$ImageHeight" />
                </xsl:attribute>
              </xsl:if>
            </img>
          </a>
        </div>
      </xsl:if>
      <div class="description">
        <xsl:value-of select="@Description" />
      </div>
      <div class="content">
        <xsl:value-of select="substring(@Content, 0, 200)" disable-output-escaping="yes"/>
        <a href="{$SafeLinkUrl}">...Read More</a>
      </div>
    </div>
  </xsl:template>
  

Important: Because we are cutting off the output rendering we potentially leave open HTML tags! See this post about a solution.

Unfortunately, there is no SharePoint GUI way to link our custom Item Style to the Content Query Web Part. The way around this, is to deploy a pre-configured Web Part file with our solution.

Add a Web Part to our project:

Delete the Web Part class file, since we are only interested in the .webpart file.

Add an empty (unconfigured) CQWP to your SharePoint Page and export this Web Part.

Open the exported file in notepad or Visual Studio and copy the contents.

Paste this in the .webpart file in our Visual Studio project.

• Set the Title and Description to the required values.
• Set the ItemLimit to 3

Modify the ItemXslLink property to link our custom style sheet:

<property name="ItemXslLink" type="string" >/Style%20Library/Xsl/CustomItemStyle.xsl</property>

Modify the ItemStyle property to match our custom style:

<property name="ItemStyle" type="string">ImageWithArticleContent</property>

Save the file.

Important: since our solution doesn’t need an assembly, we need to exclude it from the package. Select your project and set the “Include Assembly In Package” to false.

We can now deploy our solution and test our work.

You can download the Visual Studio 2010 solution here.

Couple of deployment errors Visual Studio might throw at you at this stage:

This list is by no means complete and I will extend it as I encounter other issues, hopefully not too many .

Running in “God-mode”

Important: Not recommended in production environments. Since you are deploying with Visual Studio, this is obviously not the case.

Update 1: if you are a local admin on your dev box (and most of us are), make sure you test your solutions using lesser priviliged accounts!

To enable easy access on your development machine, make sure the following is true

• Disable User Account Control (in Windows 2008 R2 this means lowering the setting to “Never notify”).

• Microsoft Visual Studio runs as Administrator (see title bar).

• You are a member of the local Administrators group
• You are a member of the local WSS_ADMIN_WPG group
• You are database owner (dbo) of both content databases and the SharePoint_Config database
• You are Farm Administrator
• You are Site Collection Administrator

Update 2: this post needs revising, since this can be done with fewer permissions than mentioned here.

Because of the limited context, only a subset of the SharePoint Server Object Model is available. To quickly figure out, if a Sandboxed solution is possible (or even required), I created a small chart. The chart and information is not even close to complete and I will probably update these regularly.

For extensive information about the Sandbox in SharePoint 2010: http://msdn.microsoft.com/en-us/magazine/ee335711.aspx

Oh, one more thing: Microsoft recommends Sandbox Solutions by default. So only use those Farm solutions if you really need to.

The following Microsoft.SharePoint subset can be used with sandboxed solutions:

The following items can not be deployed using a sandboxed solution:

• Site Definition
• Application Pages
• Farm and Web Application scoped features
• Custom Actions Group
• Custom Fields
• Visual Studio Visual Web Part
• Workflows with code
• HideCustomAction
• SharePoint Timer Jobs
• Feature Receivers for Farm and Web scoped features