The SPWebCollection.WebsInfo property

Recently, while browsing some MSDN docs, I came across the WebsInfo property of the SPWebCollection class. This property is a collection of the SPWebInfo class which contains metadata about each web in the given web collection.

Methods and properties such as SPWeb.GetSubWebsForCurrentUser,  SPSite.AllWebs and SPWeb.Webs, all return an object of the SPWebCollection class and the WebsInfo property can be used as a wrapper on some basic information about each web.

The properties available in the WebInfo class are:

1.  Configuration
2. CustomMasterUrl
3. Description
4. Id
5. Language
6. LastItemModifiedDate
7. MasterUrl .
8. ServerRelativeUrl
9. Title
10. UIVersion
11. UIVersionConfigurationEnabled
12. WebTemplateId

So when working with the returned collection of webs, if you refer to any of the above mentioned properties, then there is no further need to open an expensive SPWeb object of that web. The value of the property is simply returned from the SPWebInfo object. Here is some code which demonstrates how to use the WebsInfo property.

	SPSite site = SPContext.Current.Site;
	SPWebCollection subWebs = site.AllWebs;
	foreach (SPWebInfo webInfo in subWebs.WebsInfo)
	{
	//Code used only for testing.
	var result = webInfo.Title +
	webInfo.ServerRelativeUrl +
	webInfo.Description +
	webInfo.Id +
	webInfo.Language +
	webInfo.LastItemModifiedDate +
	webInfo.WebTemplateId +
	webInfo.Configuration +
	webInfo.UIVersionConfigurationEnabled +
	webInfo.UIVersion +
	webInfo.MasterUrl +
	webInfo.CustomMasterUrl;
	}

view raw websinfo.cs hosted with ❤ by GitHub

Now here is where it gets interesting. After deploying the above code, I switched on my Developer Dashboard to confirm that referring to any of the properties is indeed as non-expensive as claimed. And here is what my Developer Dashboard had to say regarding the call:

So only 1 database query was made with the procedure proc_ListAllWebsOfSite. After opening this procedure in the Content Database, it contained this piece of code:

	BEGIN
	SELECT
	A.FullUrl,
	A.Id,
	ISNULL(B.FullUrl, A.FullUrl),
	A.Language,
	ISNULL(A.Title, ''),
	A.UIVersion,
	A.Flags,
	A.WebTemplate,
	A.ProvisionConfig,
	A.MasterUrl,
	A.CustomMasterUrl
	FROM
	TVF_Webs_NoLock_SiteId(@SiteId) AS A
	OUTER APPLY
	TVF_Webs_NoLock_Id(A.ParentWebId) AS B
	WHERE
	(B.SiteId IS NULL OR B.SiteId = @SiteId)
	END

view raw allwebs.sql hosted with ❤ by GitHub

In fact, if you want to refer to any of these properties directly from the SPWeb objects of the returned webs, then also no additional call will be made to the database to fetch the properties. Here is the code to demonstrate that:

	SPSite site = SPContext.Current.Site;
	SPWebCollection subWebs = site.AllWebs;
	foreach (SPWeb web in subWebs)
	{
	//Code for demo purpose only.
	var result = web.Title +
	web.ServerRelativeUrl +
	web.ID +
	web.Language +
	web.WebTemplateId +
	web.Configuration +
	web.UIVersionConfigurationEnabled +
	web.UIVersion +
	web.MasterUrl +
	web.CustomMasterUrl;
	}

view raw spweb.cs hosted with ❤ by GitHub

As far as you access only these properties from the SPWeb object, there will be no need to make any more calls to the database.

Now, If you want to refer to any of the other properties of the SPWeb object, things are going to get expensive. For example, if you want to refer to the SPWeb.SiteLogoUrl property, you will get the following result in the Developer Dashboard:

So as you can see SharePoint has to call the proc_GetTpWebMetaDataAndListMetaData procedure for each SPWeb object in order to return the SiteLogoUrl property.

If you use reflector or ILSpy and open the SPWeb Class in the Microsoft.SharePoint.dll , you will see that there are 2 internal methods called InitWeb( ) and InitWebPublic( ) which are responsible for initializing most of the properties of the SPWeb object. These methods in turn call the SPWeb.Request.OpenWebInternal( ) method which actually does the job of calling unmanaged code to open the expensive SPWeb object.

This was indeed a valuable learning for me as it would hugely impact the performance of my code. I hope it was a good learning for you too!

PowerShell Scripts for SharePoint 2010

I was working with Large Lists recently and needed to create huge amount of test data. I had to work with about 2,000 Sub Sites, 2,000 Lists, 6,000 documents and about 20,000 list items. So naturally the all so powerful PowerShell was the only answer for creating such an amount of test data with so much flexibility and ease of use. So I thought to write down here some of my scripts which someone might find useful:

1) Index Fields:

	Add-PsSnapin Microsoft.SharePoint.PowerShell -ErrorAction SilentlyContinue
	function IndexField($fieldName, $spList)
	{
	$spField = $spList.Fields[$fieldName]
	$spField.Indexed = $true
	$spField.Update()
	$spList.FieldIndexes.Add($spField)
	$spList.Update()
	Write-Host "$fieldName Indexed"
	}
	try
	{
	$SiteUrl = "http://spsa00:6000/"
	$web = Get-SPWeb $SiteUrl
	$spList = $web.Lists["Tasks"]
	IndexField "Assigned To" $spList
	IndexField "Status" $spList
	$web.Dispose()
	}
	Catch [system.exception]
	{
	$error[0]
	}

view raw indexfields.ps1 hosted with ❤ by GitHub

2) Delete Site:

	Add-PsSnapin Microsoft.SharePoint.PowerShell -ErrorAction SilentlyContinue
	$SiteUrl = "http://spsa00:6000/"
	$web = Get-SPWeb $SiteUrl
	$web.Delete()
	Write-Host "$SiteUrl Deleted"

view raw deletesite.ps1 hosted with ❤ by GitHub

3) Upload Document:

	Add-PsSnapin Microsoft.SharePoint.PowerShell -ErrorAction SilentlyContinue
	function UploadFile($Web, $DocLibName, $FilePath)
	{
	$List = $Web.GetFolder($DocLibName)
	$Files = $List.Files
	$FileName = $FilePath.Substring($FilePath.LastIndexOf("\")+1)
	$File= Get-ChildItem $FilePath
	$Files.Add($DocLibName +"/" + $FileName,$File.OpenRead(),$false)
	}
	$SiteUrl = "http://spsa00:6000/"
	$Web = Get-SPWeb $SiteUrl
	UploadFile $Web "Shared Documents" "C:\Users\IA\SliderRCwebsite1.docx"
	Write-Host "Documents Uploaded to $SiteUrl"
	$web.Dispose()

view raw uploaddocument.ps1 hosted with ❤ by GitHub

4)Add New Group to Site:

	Add-PsSnapin Microsoft.SharePoint.PowerShell -ErrorAction SilentlyContinue
	$SiteUrl = "http://spsa00:6000/"
	$web = Get-SPWeb $SiteUrl
	$user = Get-SPUser -Identity "spsa\vrd" -Web $web
	$web.SiteGroups.Add("$web Group", $user, $user, “Group Description”)
	$group = $web.SiteGroups["$web Group"]
	$group.AllowMembersEditMembership = $true
	$group.Update()
	$groupAssignment = new-object Microsoft.SharePoint.SPRoleAssignment($group)
	#Full Control,Design, Contribute, Read
	$groupRoleDefinition = $web.Site.RootWeb.RoleDefinitions["Full Control"]
	$groupAssignment.RoleDefinitionBindings.Add($groupRoleDefinition)
	$web.RoleAssignments.Add($groupAssignment)
	$web.Update()
	$web.Dispose()
	Write-Host "$SiteUrl Updated"

view raw newgroup.ps1 hosted with ❤ by GitHub

5) Create New Site:

	Add-PsSnapin Microsoft.SharePoint.PowerShell -ErrorAction SilentlyContinue
	$SiteUrl = "http://spsa00:6000/"
	$SiteTemplate = "STS#2"
	$SiteLanguage = 1033
	$web = New-SPWeb $SiteUrl -Template $SiteTemplate -Name $Name -UniquePermissions -UseParentTopNav -Language $SiteLanguage
	$web.Dispose()
	Write-Host "Site Created for $SiteUrl"

view raw createsite.ps1 hosted with ❤ by GitHub

6) Add User to Site:

	Add-PsSnapin Microsoft.SharePoint.PowerShell -ErrorAction SilentlyContinue
	$SiteUrl = "http://spsa00:7766/"
	$web = Get-SPWeb $SiteUrl
	$group = $web.SiteGroups["Group Name"]
	$user = Get-SPUser -Identity "spsa\vrd" -Web $SiteUrl
	$group.AddUser($user)
	$group.Update()
	$web.Update()
	Write-Host "Added to $SiteUrl"

view raw addusertosite.ps1 hosted with ❤ by GitHub

7) Clear Object Cache on All Web Front Ends

	Add-PsSnapin Microsoft.SharePoint.PowerShell -ErrorAction SilentlyContinue
	$site = Get-SPSite "http://spsa00:7766/"
	$cache = New-Object Microsoft.SharePoint.Publishing.SiteCacheSettingsWriter $site
	$cache.SetFarmCacheFlushFlag()
	$cache.Update()
	Write-Host "Object Cache Cleared"

view raw clearobjectcache.ps1 hosted with ❤ by GitHub

8) Enable the Developer Dashboard

	Add-PsSnapin Microsoft.SharePoint.PowerShell -ErrorAction SilentlyContinue
	$ddb = [Microsoft.SharePoint.Administration.SPWebService]::ContentService.DeveloperDashboardSettings
	#On, Off, OnDemand
	$ddb.DisplayLevel = [Microsoft.SharePoint.Administration.SPDeveloperDashboardLevel]::OnDemand
	$ddb.RequiredPermissions = 'EmptyMask'
	$ddb.TraceEnabled = $true
	$ddb.Update()
	Write-Host "Developer Dashboard Enabled"

view raw ddb.ps1 hosted with ❤ by GitHub

Hope you find them useful!

Caching Options in SharePoint 2010

So recently we had to look up options for caching data in our project and I took the responsibility of doing some research on the various options available for caching in SharePoint 2010. The basic motive behind implementing caching was to reduce the calls to the database and hence improve the performance.
Here are some of my findings:

1) BLOB Cache

Binary Large Object cache or BLOB cache is a disk based cache in SharePoint. This means that the data is stored on the Hard-Disk of the Web Front End Server.
Initially for the first call, data is fetched from the database and stored on the WFE. Any further calls to the same data are responded with the cached version hence avoiding a call to the database.

It can be used to store data in a variety of format including images, audio, video etc. Furthermore, you can configure it to store files based on extension types to suite your environment. (Eg: jpg, js, css etc)

The BLOB cache is turned off by default. You will have to enable it from the web.config file of your web application if you want to use it.

To enable it, open the relevant web.config file and find the following line:

<BlobCache location="C:\blobCache" path="\.(gif|jpg|png|css|js)$" maxSize="10" enabled="false"/>

change that line to:

<BlobCache location="C:\blobCache" path="\.(gif|jpg|png|css|js)$" maxSize="10" max-age="86400" enabled="true" />

a. location is the location on the hard disk where your cache will be stored.
b. path is the regular expression used to determine the type of data to be stored
c. maxSize is the size in GB of the cache
d. max-age specifies the maximum amount of time (in seconds) that the client browser caches files. If the downloaded items have not expired since the last download, the same items are not requested again when the page is requested. The max-age attribute is set by default to 86400 seconds (that is, 24 hours), but it can be set to a time period of 0 or greater.
e. enabled turns the caching on if true and turns it off if false.

2) Page Output Cache

SharePoint also uses ASP.NET output cache to store page output. This requires the publishing features to be enabled on the Site Collection and hence it is only available in SharePoint Server 2010 and not SharePoint Foundation. This cache is stored in the Memory of the Web Front End and hence is reset when the application pool recycles.

SharePoint supports something called as cache profiles in the output cache. This means that different profiles of the page are created for groups with different levels of access to the page. The page is rendered initially when the first request is made and cached. Now if another user with the same access rights loads the page, then it is served from the cache. This is done for each group with different set of permissions. Find more information about the Page output cache here.

3) Object Cache

Object Cache can be said as the most popular of the SharePoint caches. It is a Memory based cache. This means that the data is stored in the RAM of the Web Front End Server. As a result of this, this cache is reset if the application pool of the web app is recycled.

The publishing features of a Site Collection need to be enabled for this cache to become available. And due to this, it is available only in SharePoint Server 2010 and not SharePoint 2010 Foundation.

A variety of functionality in SharePoint 2010 uses the object cache internally. Mostly it is used to store data retrieved from Cross List Queries. Classes such as the PortalSiteMapProvider and CrossQueryListIfo use the object cache internally to store information returned. Other elements of SharePoint such as the Content Query WebPart and the Navigation also use the object cache for storing retrieved data.

Once the Publishing Features are enabled, you can configure the object cache from Site Actions-> Site Settings -> Site Collection Object Cache.

The default size of the object cache is set to 100 MB and the expiry time is set to 60 Seconds. You can adjust these values to suite your environment after careful consideration and testing. Ideally it should not be kept under 3 MB otherwise it will start affecting the performance.

4) Web Storage of the Browser

And last but not the least, we have the Web Storage of the Browser itself. This is not a SharePoint specific cache but it can be used effectively with SharePoint none the less. It contains about 10 MB of space allocated on the Client Side. So even the request to the Web Front End does not have to be made as the data is already present on the client side. Some JavaScript plugins like jStorage wrap around the Web Storage and provide an excellent interface to access it. Find more about the Web Storage here.