Weblog Danny de Haas [Macaw]

Using LINQ to get filenames from a directory structure using multiple include and exclude patterns

2010-03-30T23:01:00.002+02:00

This example shows how to get list of file names from a directory (including subdirectories) using multiple include- and exclude patterns.

The buildin method System.IO.Directory.GetFiles can handle only one include pattern and no exclude pattern and multiple patterns a definitely out of the question.

So I had to write a little helper method using LINQ to do the trick!

/// <summary>
/// Get the files from the specified path, including subdirectories, which match the specified pattern.
/// Note: To specified multiple patterns, separate them by a semicolumn (;)
/// </summary>
/// <param name="path">The path.</param>
/// <param name="includePatterns">An array of include patterns. Using wildcards.</param>
/// <param name="excludePatterns">An array of exclude patterns. Using Regular expressions.</param>
/// <returns>Returns an array of filenames.</returns>
public static string[] GetFiles(string path, string[] includePatterns, string[] excludePatterns)
{
 if (string.IsNullOrEmpty(path))
 {
  throw new ArgumentNullException("path", "Argument should not be NULL or an empty string.");
 }
 if (includePatterns == null)
 {
  includePatterns = new string[0];
 }
 if (excludePatterns == null)
 {
  excludePatterns = new string[0];
 }

 var files = from includePattern in includePatterns
    from includeFile in Directory.GetFiles(path, includePattern, SearchOption.AllDirectories)
    from excludePattern in excludePatterns.DefaultIfEmpty()
    where excludePattern == null || !Regex.IsMatch(includeFile, excludePattern, RegexOptions.IgnoreCase)
    select includeFile;

 return files.ToArray();
}

The following example gets all files that match the wildcard patterns 'DdH.*.Helpers.dll' & 'DdH.*.exe' from the c:\temp directory, but will exclude all files that match the regular expression 'Tests\.dll'.

string[] fileNames = GetFiles(@"c:\temp", new string[] { "DdH.Helpers.*.dll", "DdH.*.exe" }, new string[] { "Tests\.dll" });

Agile Poker Cards For Windows Mobile

2010-02-07T22:47:00.000+01:00

I just release my first Windows Mobile Application on CodePlex. :-)

It’s use is to display poker cards during a planning session.

During a scrum or other agile processes, you have to estimate the size of a user story during a planning session.
With this little program there is no need for using real cards anymore!

Tools I used to develop this little application:

Microsoft Visual Studio 2008
.NET Compact Framework 3.5
Windows Mobile 6 Professional and Standard SDK Refresh
Windows Mobile 6.5 Developer Tool Kit
Paint.NET
IcoFX

The program works really simple...
Just press a button and it will display the symbol in full screen. (nothing more, nothing less)

To download or read more, go to the projectsite: Agile Poker Cards

What’s new with SharePoint Server 2010 Web Content Management

2009-10-19T20:30:00.002+02:00

I’ve been waiting for this information like this since Microsoft announced a new version of SharePoint!

There are a lot of blog posts out on the web which are about new features in SharePoint Server 2010, but only a small few contain some information about SharePoint Web Content Management (WCM). Now Andrew Connell wrote three very interesting blog posts only about this subject. :-)

Part 1 – Improvements to the Core SharePoint platform

Cleaner Markup
Server Ribbon
Reduced Postbacks during the authoring process

Part 2 - Improvements to WCM

Improved Content Query WebPart
Authoring
Content Deployment
Large Page Libraries
Publishing Improvements

Part 3 – What’s new in WCM

Content Organiser
Page Ratings
Metadata Everywhere
Web Analytics
More Video and Rich Media Support

For more information read the posts of Andrew Connell

Programmatically Adding a Control Adapter

2009-08-29T19:29:00.010+02:00

I have a Control Adapter I use frequently and every time I start a new SharePoint WCM project, I have to rethink about how to use it to my Web Application and how to deploy the compat.browser modifications. After some research on the net I came up with two solutions to add Control Adapters programmatically, so no browser.compat modifications are necessary any more.

Add a Control Adapter to the current HttpContext.
Add a Control Adapter to a particular Control.

I created some helper functions that can do the binding of the Control Adapter to a Control or Control-Type. In both cases the functions are used from within a custom (master)page class.

The first solution is using strate forward .NET code, but for the second I had to use some Reflection. (so beware!)

1. Adding a Control Adapter to the current HttpContext

You can use the Global.asax file or a masterpage to add Control Adapters to the current HttpContext.

In the global.asax implement the code in the Application_Start event to bind the Control Adapter.

<script runat="server">
    void Application_Start(Object sender, EventArgs e)
    {
        AddControlAdapterToType<Unive.Foundation.UI.ControlAdapters.SharePointWebPartZoneControlAdapter>(typeof(Microsoft.SharePoint.WebPartPages.WebPartZone));
    }

    private static void AddControlAdapterToType<T>(Type controlType) where T : ControlAdapter, new()
    {
        if (controlType == null)
        {
            throw new ArgumentNullException("controlType", "This argument can not be null!");
        }

        IDictionary adapters = HttpContext.Current.Request.Browser.Adapters;
        string key = controlType.AssemblyQualifiedName;
        if (!adapters.Contains(key))
        {
            string adapter = typeof(T).AssemblyQualifiedName;
            adapters.Add(key, adapter);
        }
    }
</script>

In a masterpage you must implement code in the constructor to bind the Control Adapter. This is necessary so the page will use the Control Adapter in the first run. Doing the binding in the OnInit or later is to late and all the child controls in the markup will already be instantiated.

using System;
using System.Web;
using System.Web.UI.Adapters;

public class MyMasterPage : System.Web.UI.MasterPage
{
    public MyMasterPage()
    {
        AddControlAdapterToType<SharePointWebPartZoneControlAdapter>(typeof(Microsoft.SharePoint.WebPartPages.WebPartZone));
    }

    private static void AddControlAdapterToType<T>(Type controlType) where T : ControlAdapter, new()
    {
        if (controlType == null)
        {
            throw new ArgumentNullException("controlType", "This argument can not be null!");
        }

        IDictionary adapters = HttpContext.Current.Request.Browser.Adapters;
        string key = controlType.AssemblyQualifiedName;
        if (!adapters.Contains(key))
        {
            string adapter = typeof(T).AssemblyQualifiedName;
            adapters.Add(key, adapter);
        }
    }
}

2. Add a Control Adapter to a particular Control

To bind a Control Adapter to a particular control, you must first find the control instance in the page and then you can do the binding.

using System;
using System.Reflection;
using System.Web.UI;
using System.Web.UI.Adapters;

public class MyMasterPage : System.Web.UI.MasterPage
{
    protected override void CreateChildControls()
    {
        base.CreateChildControls();

        Control control = Page.FindControl("WebPartZone3");
        AddControlAdapterToControl<SharePointWebPartZoneControlAdapter>(control);
    }

    private static void AddControlAdapterToControl<T>(Control control) where T : ControlAdapter, new()
    {
        if (control == null)
        {
            throw new ArgumentNullException("control", "This argument can not be null!");
        }

        T adapter = new T();

        // Using reflection to bind controladapter to control
        control.GetType().GetField("_adapter", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(control, adapter);
        // Using reflection to bind control to controladapter
        adapter.GetType().GetField("_control", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(adapter, control);
    }
}

Bye Bye GuidGen.exe!

2009-06-24T16:32:00.006+02:00

While developing in Visual Studio and I needed to create a new guid, I always used the “Create GUID” under the Tools dropdown menu. This menuitem started the “guidgen.exe” application and using this was a fine method, until I attended the last DevDays 2009 (The Hague, Netherlands). There I saw a demonstration of a much easier way to create a new guid in Visual Studio by making use of a simple macro. (Thanks Wouter)

Below is the explanation on how to implement this macro.

1. Open the Macro Explorer and Load or Create a Macro Project.

2. Inside the macro IDE, create a method to generate a new guid.

Imports System
Imports EnvDTE
Imports EnvDTE80
Imports EnvDTE90
Imports System.Diagnostics

Public Module Module1
    Sub GenerateGuid()
        If (DTE.ActiveDocument IsNot Nothing) Then
            DTE.ActiveDocument.Selection.Text = Guid.NewGuid().ToString("B")
        End If
    End Sub
End Module

3. Save and close the macro IDE.

4. For the finishing though, create a keyboard shortcut to activate the GeneratGuid macro. I like to use the combination CTRL+K, CTRL+G

5. Now it is so easy to create a new guid…..just by pressing your favourite keyboard shortcut.

Bye Bye GuidGen!

DevDays 2009 (PreConference DeepDive)

2009-05-27T21:37:00.003+02:00

Today I visited the first day of the DevDays 2009 (PreConference DeepDive) in The Hague (Netherlands) and attended a session about SharePoint developing by Wouter van Vugt.

After the introduction and agenda, Wouter started with presenting some develop tools you can you use while developing and talked about the pro's and con's of every one of them.

Next was creating custom list templates and how to build your own entity picker controls using classes that are already provided inside the SharePoint object model.

After the lunchbreak he continued with a demo of how he created a complex fieldtype using a entity picker and a resultdialog. How he stored the selected value, which contained some technical data and how to split it in a displaytext and id before displaying in a list. Wouter demonstrated how he used the RenderPattern of the fieldtype to only display the displaytext and hide to technical stuf.

Last part of the session was about how he created his own SharePoint WCM Publishing site that is W3C Complaint. I found this a great demo and he gave me a lot of new idea's to work on.

Overall I had a very interesting day full of How To's, demo's and lots of code examples.

The SharePoint Developer Introduction for .NET Developers

2009-05-15T10:35:00.004+02:00

Today I found that Microsoft release a SharePoint Introduction website for .NET develpers.The site is created with SilverLight and contains lots of information on what developer can use when they start with SharePoint.

Background info
Webcasts
Screencasts
Demo's
How to's
Virtual PC's image
Hands on Labs
Links to resources and forums
...and add some

Check it out on: Do Less. Get More. Develop on SharePoint.

How to detect when a SharePoint Publishing Page is detached from it's PageLayout

2009-05-11T17:05:00.011+02:00

Recently I found a new thing about SharePoint Publishing pages. From within SharePoint Designer, publishing pages can be detached from there pagelayout!

I guess that for some of you this not a a new thing, but I didn't know.

In a normal publishing senario this is also not a common thing to do, because the page is disconnected from the pagelayout and changes to the pagelayout will no longer affect the page. But in certain situations it can be usefull, like using SharePoint Designer to place webparts on a publishing page. Normaly this can only be done from the browser interface. Of course a page can also be attached to a pagelayout again.

To detach a page in SharePoint designer, open the Pages list and right click on the page.

Now you get a dialog 'Detaching from the page layouts http:/xxxx/_catalogs/masterpage/xxxx.aspx will copy its markup into this page, where it can be customized. Changes to the pagelayout will no long affect this page.'

To reattach a page to it's pagelayout, right click on the page again.

After knowing how to detach a page from it's pagelayout, I wanted to find out how a publishing page would know it was detached and after some investigation I found that this information is stored in the listitem for the page. Each publishing page has a field called 'PublishingPageLayout' and this field normaly contains the url of the pagelayout and the name of the content type.
Value format: 'http://xxxx/catalogs/masterpage/xxxx.aspx, ContentTypeName'

But after detaching the pagelayout this field contains another kind of information. Namely an indication that the page is a disconnected publishing page and a reference to the pagelayout is once was connected to.
Value format: 'http://www.microsoft.com/publishing?DisconnectedPublishingPage=true, http://xxxx/_catalogs/masterpage/xxxx.aspx

To detect all disconnected publishing pages in a site collection I created a the following code:

using (SPSite site = new SPSite("http://demosite"))
{
    SPWeb rootWeb = site.RootWeb;

    // Query to get all publishing pages in the sitecollection that are detached from pagelayout.
    // ServerTemplate=850, is template for the Pages lists.
    SPSiteDataQuery dataQuery = new SPSiteDataQuery();
    dataQuery.Webs = "< Webs Scope="SiteCollection">";
    dataQuery.Lists = "< Lists ServerTemplate="850">";
    dataQuery.ViewFields = "< FieldRef Name="FileRef" Nullable="TRUE">";
    dataQuery.Query = "< Where>" +
                            "< Contains>" +
                                "< FieldRef Name="PublishingPageLayout">" +
                                "< Value Type="Text">?DisconnectedPublishingPage=true< /Value>" +
                            "< /Contains>" +
                        "< /Where>";                              

    // Store result in datatable
    DataTable dt = rootWeb.GetSiteData(dataQuery);
    foreach (DataRow row in dt.Rows)
    {
        if (row.IsNull("FileRef"))
        {
            Console.WriteLine("FileRef should not be null!");
            continue;
        }

        // Strip listitem id from fieldref value
        string fieldRef = row["FileRef"].ToString().Trim();
        if (!string.IsNullOrEmpty(fieldRef))
        {
            int pos = fieldRef.IndexOf(";#");
            if (pos > -1)
            {
                fieldRef = fieldRef.Substring(pos + 2);
            }
        }

        Console.WriteLine(fieldRef);
    }
}

Also you can use the 'Content and Structure Reports' functionality from MOSS to get an overview of all publishing pages that are disconnected from the pagelayout.

To do this, go to the 'Content and Structure Reports' list inside to root site. Create a new item and fill the field like below.

Report Title: All Pages Disconnected from PageLayout
Resource Id: (leave blank)
Resource Id: (leave blank)
CAML List Type: <Lists ServerTemplate='850' />
CAML Query: <Where><Contains><FieldRef Name='PublishingPageLayout' /><Value Type='Text'>?DisconnectedPublishingPage=true</Value></Contains></Where>
Target Audiences: (leave blank)
Report Description: All publishing pages that are detached from their pagelayout by using SharePoint Designer.

Afer creating a new report, you can access it through the Site Actions button.

SPSiteColumnUsage, Find all references to a site column

2009-04-26T13:41:00.012+02:00

When I try to delete a site column from a SharePoint site I often get the message "Site columns which are included in content types cannot be deleted. Remove all references to this site column prior to deleting it."

Well with only a few content types this isn't so hard to click through all content types and checking if the site column is used, but with a lot of them it's no fun and can be a hell of a job.

To make my life a bit easier I decided to create a piece of code that could delete site columns programmatically. I knew that SharePoint object model has a class that can return the usage of content types, namely SPContentTypeUsage. With this class you can tell if a content type is used in one or more lists somewhere inside the complete site collection and what the urls to those lists are.

My guess was that there should also be something like a site column usage, but I was wrong!

After some investigation on MSDN, several SharePoint blogs and good old Reflector, I created a SPSiteColumnUsage class. This class uses the LINQ and SPContentTypeUsage and can find all references to content types and lists where a site columns is in use.

SPSiteColumnUsage
Methods

GetUsages, this method takes a SPField instance as input argument and returns an array of SPSiteColumnUsage objects.

Properties

Id, the Id of the site column.
Scope, the scope of the site column.
ContentTypeId, the id of a content type where the site column is in use.
IsUrlToList, indicates if the information is about a list or a content type.
Url, the server relative to a list where the site column is in use.

Usage example to get info about the site column: Title

using (SPSite site = new SPSite("http://demosite"))
{
    using (SPWeb web = site.OpenWeb())
    {
        SPField field = web.Fields.GetFieldByInternalName("Title);

        Console.WriteLine("Field: {0}", fieldName);
        Console.WriteLine("==============================");

        var usage = SPSiteColumnUsage.GetUsages(field);
        foreach (var u in usage)
        {
            Console.WriteLine("Id: {0}", u.Id);
            Console.WriteLine("Scope: {0}", u.Scope);
            Console.WriteLine("ContentTypeId: {0}", u.ContentTypeId);
            Console.WriteLine("IsUrlToList: {0}", u.IsUrlToList);
            Console.WriteLine("Url: {0}", u.Url);
            Console.WriteLine();
        }
    }
}

See a working example on http://SPSiteColumnUsage.codeplex.com

The class also makes use of the extension method CoppyToArray I created.
For this method see a previous post: Using LINQ to query SharePoint collections

/// 
/// Class with site column usage information.
/// 
public class SPSiteColumnUsage
{
   public static IList< SPSiteColumnUsage> GetUsages(SPField field)
   {
       List< SPSiteColumnUsage> list = new List< SPSiteColumnUsage>();

       if(field != null && field.UsedInWebContentTypes)
       {
           // Use reflection to get the fields collection for the specified field
           SPFieldCollection fieldCollection = field.GetType().GetProperty("Fields", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(field, null) as SPFieldCollection;
           if(fieldCollection != null)
           {
               // Get the web context from the collection
               SPWeb web = fieldCollection.Web;

               // First collect all contenttypes to an array, so we can use Linq
               var contentTypes = web.ContentTypes.CopyToArray< SPContentType>();

               // Filter contenttypes where field is used
               var contentTypesWithField = (from contentType in contentTypes
                                            where contentType.Fields.ContainsField(field.InternalName)
                                            select contentType).ToArray();

               // Create usages for fields in contenttypes
               foreach(SPContentType contentType in contentTypesWithField)
               {
                   SPSiteColumnUsage siteColumnUsage = new SPSiteColumnUsage(field.Id, field.Scope, contentType.Id);
                   list.Add(siteColumnUsage);
               }

               // Get unique lists-urls where contentypes are beeing used
               var listUrlsContentTypeUsage = (from contentType in contentTypesWithField
                                               let contentTypeUsages = SPContentTypeUsage.GetUsages(contentType)
                                               from contentTypeUsage in contentTypeUsages
                                               where contentTypeUsage.IsUrlToList
                                               select contentTypeUsage.Url).Distinct().ToArray();

               // Create usages for fields in list
               foreach (string listUrl in listUrlsContentTypeUsage)
               {
                   SPSiteColumnUsage siteColumnUsage = new SPSiteColumnUsage(field.Id, field.Scope, listUrl);
                   list.Add(siteColumnUsage);
               }
           }
       }

       return list;
   }

   private readonly Guid _Id;
   private readonly string _Scope;
   private readonly SPContentTypeId _ContentTypeId;
   private readonly string _Url;

   private SPSiteColumnUsage(Guid id, string scope, SPContentTypeId contentTypeId)
   {
       _Id = id;
       _Scope = scope;
       _ContentTypeId = contentTypeId;
       _Url = null;
   }

   private SPSiteColumnUsage(Guid id, string scope, string url)
   {
       _Id = id;
       _Scope = scope;
       _ContentTypeId = SPContentTypeId.Empty;
       _Url = url;
   }

   public Guid Id
   {
       [DebuggerStepThrough]
       get { return _Id; }
   }

   public string Scope
   {
       [DebuggerStepThrough]
       get { return _Scope; }
   }

   public SPContentTypeId ContentTypeId
   {
       [DebuggerStepThrough]
       get { return _ContentTypeId; }
   }

   public string Url
   {
       [DebuggerStepThrough]
       get { return _Url; }
   }

   public bool IsUrlToList
   {
       [DebuggerStepThrough]
       get { return _ContentTypeId.Equals(SPContentTypeId.Empty) && !string.IsNullOrEmpty(_Url); }
   }
}

Microsoft SharePoint Designer 2007 is now free

2009-04-02T11:23:00.005+02:00

When I first heared the news that Microsoft was going to give away SharePoint Designer 2007 for free, I thought it was a April Fool's joke. But now on April 2nd, I actual believe. :-)

Download it from Microsoft Download Center.
http://www.microsoft.com/downloads/details.aspx?displaylang=en&FamilyID=baa3ad86-bfc1-4bd4-9812-d9e710d44f42

Understanding Field Controls and Web Parts in SharePoint Server 2007 Publishing Sites

2009-03-24T08:47:00.005+01:00

I just read an great article from Andrew Connell about the use of Field Controls and Web Parts in MOSS 2007 Publishing sites.

He describes clearly the advantages and disadvantages of using them and that you should considered in the early phase of the implementation of a new publishing site which approach to use.

Read the article on MSDN
Understanding Field Controls and Web Parts in SharePoint Server 2007 Publishing Sites.

SharePoint PublishingWeb class inside out

2009-03-15T22:03:00.008+01:00

For a project I've done in the past, I had to create an application that could report all sorts of SharePoint site information. While developing this application, the biggest challenge was to gather information about publishing sites, without the use off the Micosoft.SharePoint.Publishing assembly. The reason for this was that the application also had to run on a WSS only installation of SharePoint. During refactoring I found out that most information was stored in the propertybag of the web.

I created a SharePoint Publishing helper class that can retrieve values for the following PublishingWeb properties and functions.

GetAvailablePageLayouts
GetIncludeInNavigation
IncludeInCurrentNavigation
IncludeInGlobalNavigation
IncludePagesInNavigation
IncludeSubSitesInNavigation
InheritAlternateCssUrl
InheritCurrentNavigation
InheritCustomMasterUrl
InheritGlobalNavigation
IsInheritingAvailablePageLayouts
IsInheritingAvailableWebTemplates
IsPublishingWeb
NavigationAutomaticSortingMethod
NavigationShowSiblings
NavigationSortAscending
OrderingMethod
PagesListId

public static class SharePointPublishingHelper
{
 public static bool IsPublishingWeb(SPWeb web)
 {
  return GetBooleanValueFromPropertyBag(web, "__PublishingFeatureActivated", false);
 }

 public static bool IncludeInGlobalNavigation(SPWeb web)
 {
  return GetIncludeInNavigation(web, "__GlobalNavigationExcludes");
 }
 
 public static bool IncludeInCurrentNavigation(SPWeb web)
 {
  return GetIncludeInNavigation(web, "__CurrentNavigationExcludes");
 }
 
 private static bool GetIncludeInNavigation(SPWeb web, string propertyKey)
 {
  if(web == null)
  {
   throw new ArgumentNullException("web");
  }
  if (string.IsNullOrEmpty(propertyKey))
  {
   throw new ArgumentException("The argument can't be null or a empty string.", "propertyKey");
  }
 
  SPWeb parentWeb = web.ParentWeb;
  if (!web.IsRootWeb && parentWeb != null)
  {
   string globalNavigationExcludes = GetValueFromPropertyBag(parentWeb, propertyKey) as string;
   if (!string.IsNullOrEmpty(globalNavigationExcludes))
   {
    string[] list = globalNavigationExcludes.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
    bool found = list.Contains(web.ID.ToString("D"));
 
    return !found;
   }
  }
 
  return true;
 }
 
 public static bool InheritGlobalNavigation(SPWeb web)
 {
  if (web == null)
  {
   throw new ArgumentNullException("web");
  }
 
  if (web.IsRootWeb)
  {
   return false;
  }
 
  return web.Navigation.UseShared;
 }
 
 public static bool InheritCurrentNavigation(SPWeb web)
 {
  if (web == null)
  {
   throw new ArgumentNullException("web");
  }
 
  if (web.IsRootWeb)
  {
   return false;
  }
 
  return GetBooleanValueFromPropertyBag(web, "__InheritCurrentNavigation", true);
 }
 
 public static bool IncludeSubSitesInNavigation(SPWeb web)
 {
  if (web == null)
  {
   throw new ArgumentNullException("web");
  }
 
  return GetBooleanValueFromPropertyBag(web, "__IncludeSubSitesInNavigation", true);
 }
 
 public static bool IncludePagesInNavigation(SPWeb web)
 {
  if (web == null)
  {
   throw new ArgumentNullException("web");
  }
 
  return GetBooleanValueFromPropertyBag(web, "__IncludePagesInNavigation", true);
 }
 
 public static string OrderingMethod(SPWeb web)
 {
  if (web == null)
  {
   throw new ArgumentNullException("web");
  }
 
  string value = GetValueFromPropertyBag(web, "__NavigationOrderingMethod").ToString();
  switch (value)
  {
   case "0":
    return "Automatic";
   case "1":
    return "ManualWithAutomaticPageSorting";
   case "2":
    return "Manual";
   default:
    break;
  }
 
  return "Manual";
 }
 
 public static bool NavigationShowSiblings(SPWeb web)
 {
  if (web == null)
  {
   throw new ArgumentNullException("web");
  }
 
  if (web.IsRootWeb)
  {
   return false;
  }
 
  return GetBooleanValueFromPropertyBag(web, "__NavigationShowSiblings", true);
 }
 
 public static string NavigationAutomaticSortingMethod(SPWeb web)
 {
  if (web == null)
  {
   throw new ArgumentNullException("web");
  }
 
  string value = GetValueFromPropertyBag(web, "__NavigationAutomaticSortingMethod").ToString();
  switch (value)
  {
   case "0":
    return "Title";
   case "1":
    return "CreatedDate";
   case "2":
    return "LastModifiedDate";
   default:
    break;
  }
 
  return "Title";
 }
 
 public static bool NavigationSortAscending(SPWeb web)
 {
  if (web == null)
  {
   throw new ArgumentNullException("web");
  }
 
  return GetBooleanValueFromPropertyBag(web, "__NavigationSortAscending", true);
 }
 
 public static Guid PagesListId(SPWeb web)
 {
  if (web == null)
  {
   throw new ArgumentNullException("web");
  }
 
  string value = GetValueFromPropertyBag(web, "__PagesListId").ToString();
  if (string.IsNullOrEmpty(value))
  {
   return Guid.Empty;
  }
 
  return new Guid(value);
 }
 
 public static bool InheritCustomMasterUrl(SPWeb web)
 {
  if (web == null)
  {
   throw new ArgumentNullException("web");
  }
 
  return GetBooleanValueFromPropertyBag(web, "__InheritsCustomMasterUrl", false);
 }
 
 public static bool InheritAlternateCssUrl(SPWeb web)
 {
  if (web == null)
  {
   throw new ArgumentNullException("web");
  }
 
  return GetBooleanValueFromPropertyBag(web, "__InheritsAlternateCssUrl", false);
 }
 
 public static bool IsInheritingAvailableWebTemplates(SPWeb web)
 {
  if (web == null)
  {
   throw new ArgumentNullException("web");
  }
 
  return GetBooleanValueFromPropertyBag(web, "__InheritWebTemplates", false);
 }
 
 public static bool IsInheritingAvailablePageLayouts(SPWeb web)
 {
  if (web == null)
  {
   throw new ArgumentNullException("web");
  }
 
  string value = GetValueFromPropertyBag(web, "__PageLayouts").ToString();
  if (!string.IsNullOrEmpty(value))
  {
   return value.Equals("__inherit", StringComparison.InvariantCultureIgnoreCase);
  }
 
  return false;
 }
 
 public static string[] GetAvailablePageLayouts(SPWeb web)
 {
  if (web == null)
  {
   throw new ArgumentNullException("web");
  }
 
  List list = new List();
 
  string value = GetValueFromPropertyBag(web, "__PageLayouts").ToString();
  if (!string.IsNullOrEmpty(value))
  {
   SPWeb rootWeb = web.Site.RootWeb;
 
   var pageLayouts = XElement.Parse(value).Elements("layout");
   foreach (var pageLayout in pageLayouts)
   {
    string itemUrl = null;
 
    string id = null;
    XAttribute guidAttribute = pageLayout.Attribute("guid");
    if (guidAttribute != null)
    {
     id = guidAttribute.Value;
    }
 
    // first try to find pagelayout by id
    if (!string.IsNullOrEmpty(id))
    {
     SPFile file = rootWeb.GetFile(new Guid(id));
     if (file != null && file.Exists)
     {
      itemUrl = file.ServerRelativeUrl;
     }
    }
 
    // if no pagelayout is found by id, try the url
    if (string.IsNullOrEmpty(itemUrl))
    {
     string url = null;
     XAttribute urlAttribute = pageLayout.Attribute("url");
     if (urlAttribute != null)
     {
      url = urlAttribute.Value;
     }
 
     SPFile file = rootWeb.GetFile(url);
     if (file != null && file.Exists)
     {
      itemUrl = file.ServerRelativeUrl;
     }
    }
 
    if (!string.IsNullOrEmpty(itemUrl))
    {
     list.Add(itemUrl);
    }
   }
  }
 
  return list.ToArray();
 }
 
 private static object GetValueFromPropertyBag(SPWeb web, string key)
 {
  if (web == null)
  {
   throw new ArgumentNullException("web");
  }
  if (string.IsNullOrEmpty(key))
  {
   throw new ArgumentException("The argument can't be null or a empty string.", "key");
  }
 
  object value = null;
 
  // First check the AllProperties collection
  if (web.AllProperties.ContainsKey(key))
  {
   value = web.AllProperties[key];
  }
 
  // Still empty, check also the Properties collection
  if (value == null)
  {
   if (web.Properties.ContainsKey(key))
   {
    value = web.Properties[key];
   }
  }
 
  return value;
 }
 
 private static bool GetBooleanValueFromPropertyBag(SPWeb web, string key, bool defaultValue)
 {
  string value = GetValueFromPropertyBag(web, key) as string;
 
  bool ret;
  if (!bool.TryParse(value, out ret))
  {
   ret = defaultValue;
  }
 
  return ret;
 }
}

Using LINQ to query SharePoint collections

2009-03-08T22:41:00.025+01:00

I came across a challenge when I wanted to using LINQ on several SharePoint collection classes and I noticed that it wasn't possible to do this....So why not? LINQ lets you query any collection implementing the IEnumerable interface and after some research I found that most of the SharePoint collections don't implement this interface.

Ok, how to overcome this challenge? Arrays implement IEnumerable....Copy the items from the collection to an array! SharePoint collections implement the ICollection interface which provides the method: void CopyTo(Array array, int index), so this should not be a problem. Well it does!

SharePoint collections derive from a class called SPBaseCollection and this class implements ICollection. But because the explicit implementation of CopyTo, this method is private.

For this I wrote a little helper extension method that makes it possible to copy a SharePoint collections (or any class that implements ICollection) to an array of a particular type and validate for null at the same time.

public static class Helpers
{
 public static T[] CopyToArray(this ICollection collection)
 {
     if (collection == null) { return new T[0]; }

     T[] array = new T[collection.Count];
     collection.CopyTo(array, 0);

     return array;
 }
}

Now it is possible to make Linq queries like this:

using (SPSite site = new SPSite("http://demosite"))
{
 using (SPWeb web = site.OpenWeb())
 {
     // Get all webs ordered by Title
     var items1 = web.Webs.CopyToArray< SPWeb>().OrderBy(p => p.Title);
     foreach (var item in items1)
     {
         Console.WriteLine(item.Title);
     }

     // Get all content types grouped by group and ordered by group and name
     var items2 = web.ContentTypes.CopyToArray< SPContentType>().GroupBy(p => p.Group).OrderBy(g => g.Key);
     foreach (IGrouping<> group in items2)
     {
         Console.WriteLine(group.Key);

         foreach (var item in group.OrderBy(p => p.Name))
         {
             Console.WriteLine(item.Name);
         }
     }

     // Get a list by name and not by title
     var list = web.Lists.CopyToArray< SPList>().SingleOrDefault(p => p.RootFolder.Name.Equals("pages", StringComparison.InvariantCultureIgnoreCase));
     if (list != null)
     {
         Console.WriteLine("List: {0} found!", list.Title);
     }
 }
}

Create a Fake HttpContext for SharePoint

2009-02-23T13:20:00.006+01:00

While coding for SharePoint I usualy start by putting code in a console application to create the nessasary functionaly and on a later stage move it over to a browser application. I do this because I find it speeding up the development cycle, because SharePoint deployment cause a bit of overhead. But once in a while I need the HttpContext.Current to be set and I there isn't one in a console app.

To overcome this problem I created my own WorkerRequest class and a helper method that returns a HttpContext to fake a current http context. Both the class and method take a SPWeb as contructor parameter to put the correct SharePoint context into the http context.

public class FakeSharePointWorkerRequest : SimpleWorkerRequest
{
    private readonly string _ServerName;

    public FakeSharePointWorkerRequest(SPWeb web) : base(web.ServerRelativeUrl, web.Site.WebApplication.IisSettings[SPUrlZone.Default].Path.FullName, string.Empty, string.Empty, null)
    {
        _ServerName = web.Site.HostName;
    }

    public override string GetServerName()
    {
        return _ServerName;
    }
}

public static HttpContext GetFakeHttpContextForSharePoint(SPWeb web)
{
    FakeSharePointWorkerRequest workerRequest = new FakeSharePointWorkerRequest(web);
    HttpContext httpContext = new HttpContext(workerRequest);
    httpContext.Items["HttpHandlerSPWeb"] = web;
    httpContext.Items["HttpHandlerSPSite"] = web.Site;
 
    return httpContext;
}

Usage example

using(SPSite site = new SPSite("http://demosite"))
{
    using(SPWeb web = site.OpenWeb())
    {
        bool httpContextIsFake = false;
        if (HttpContext.Current == null)
        {
            // Must be set before using the SPLimitedWebPartManager in a console app
            HttpContext.Current = GetFakeHttpContextForSharePoint(web);
            httpContextIsFake = true;
        }
 
        // Do your own thingies!
        // .....
 
        // Don't forget to reset the current http context
        if (httpContextIsFake)
        {
            HttpContext.Current = null;
        }                     
    }
}

Programmatically show all list templates for a SharePoint web

2009-02-17T10:44:00.007+01:00

To programmatically create lists in a SharePoint web, I found you have to look for list templates in two different locations.

The first (obvious) location is in the ListTemplates collection on the SPWeb object, but then u would mis the custom list templates stored in the List Template Gallery.

The code belows shows all list templates for a web.

using(SPSite site = new SPSite("http://demosite"))
{
    using(SPWeb web = site.OpenWeb())
    {
        Console.WriteLine("==== List Templates");
        foreach(SPListTemplate template in web.ListTemplates)
        {
            Console.WriteLine(template.Name);
        }
  
        Console.WriteLine("==== List Templates from the List Template Gallery");
        foreach (SPListTemplate template in site.GetCustomListTemplates(web))
        {
            Console.WriteLine(template.Name);
        }
    }
}

Introduction

2009-02-12T23:23:00.005+01:00

Welcome to my webblog!

I'm Danny de Haas, a Dutch guy who is living in Amsterdam. I'm a professional software developer since 1999 and have experiences with C#, VB.NET, VB6, SQL 2000/2005, SharePoint Portal Server 2003 and MOSS 2007.

I work for a Dutch software company called Macaw and I am a member of the solution center 'Rich Internet Solutions' (RIS). Most of the time I've been busy with SharePoint Web Content Management. This platform has alot to talk about. So stay tuned! :-)

....to be continued.