Onlangs kwam ik een mooie post tegen op een blog. Dit ging over het gebruiken van Linq op de items van een Sharepoint lijst. Het origineel is hier te vinden: https://asadewa.wordpress.com/2008/01/03/direct-linq-to-splistitemcollection/

Volgens de post is het standaard niet mogelijk, maar heeft hij heeft er wel een leuke work-around voor gevonden. Zelf heb ik het nog niet uitgeprobeerd, omdat ik nog niet een goede toepassing heb gevonden/bedacht.
Het komt er in het kort op neer dat je een wrapper schrijft om de SPListItemCollection en daar de item collectie in stopt. De wrapper ziet er ongeveer zo uit:

public class SPListItemCollectionAdapter : List 
{ 
	private SPListItemCollection _listItemCollection; 
	public SPListItemCollectionAdapter(SPListItemCollection listItemCollection) 
	{ 
		_listItemCollection = listItemCollection; Refresh(); 
	} 
	private void Refresh() 
	{ 
		this.Clear(); 
		foreach (SPListItem item in _listItemCollection) 
		{ 
			this.Add(item); 
		} 
	} 
}

Zoals te zien wordt deze wrapper afgeleid van de List, waardoor je er dus Linq-queries op uit kunt voeren.

In de constructor wordt dan de itemcollectie toegevoegd en kan er dus mee worden gewerkt. Door deze wrapper kun je nu dus met Linq werken op een Sharepoint lijst item collectie. Dit kan er zo ongeveer uit komen te zien:

//De items ophalen vanuit de lijst 
SPListItemCollection itemcol = mossWeb.Lists[listname].Items; 
//De opgehaalde item collectie in de adapter stoppen. 
SPListItemCollectionAdapter itemsAdapter = new SPListItemCollectionAdapter(itemcol); 
//Een Linq-query uitvoeren met het wrapper object 
var result = itemsAdapter.Max(x => x[fieldname]);

Om eerlijk te zijn vind ik dit wel een stuk mooier dan gebruik maken van CAML-queries.

Het is naar mijn mening namelijk niet echt van deze tijd om ‘dynamische’ queries in de code-behind te stoppen. Of Linq nu een goede vervanging is, is ook discutabel, maar persoonlijk vind ik het dus wel mooier werken. Mocht ik in de nabije toekomst dus weer tegen zoiets aanlopen dan zal ik proberen om dit nuttig te kunnen implementeren.

Als we trouwens de performance ook mee gaan rekenen denk ik niet dat dit een echt goede oplossing is om te gebruiken. Zoals je kunt zien moeten eerst alle items worden opgehaald vanuit de lijst en in de itemcollectie worden geplaatst en daarna wordt er in de wrapper nog een foreach-loop gedaan om al die items in het object te stoppen.
Wanneer je dus met grote lijsten aan het werk bent (of hoge performance enorm belangrijk is in je oplossing), lijkt me het dus beter om toch gebruik te maken van CAML. Wanneer het niet veel uit maakt, is dit een mooiere oplossing naar me dunkt.