For example, you might want http://server/siteCollection/site/lists/somelist . If you entered this URL, you’d be taken to the default View for the list, so you don’t really need the extra /forms/… bit to identify the list – that’s all about identifying the view.

Sadly, though, there is no SPList.Url property or equivalent on the SPList object. So, how can I get a list’s URL? Well, all Lists have a RootFolder. This folder has a URL, relative to the SPWeb it’s in.

 So, we can do something like this:

string url = web.Url + "/" + list.RootFolder.Url

Well, that’s great – but the result has the full path, including the server name. This can differ in SharePoint with alternate access mappings, so it can be useful to get the server relative url instead. This can be slightly more complicated:

string url = "http://server/subsite/Documents/";

using (SPSite site = new SPSite(url))
{
    using (SPWeb web = site.OpenWeb())
    {
        SPList list = web.GetList(url);

        string listurl = web.ServerRelativeUrl;
        if(listurl == "/") listurl = string.Empty;
        listurl = listurl + "/" + list.RootFolder.Url;
        Console.WriteLine(listurl);
    }
}

This should give use the server relative URL for the list. Note also the bit where we clear our variable if we are in the root site of the root site collection of a web application (e.g. http://server/ ) as this returns an SPWeb.ServerRelativeUrl of “/”

Well, no more! In SharePoint 2010, there are now OnAddingToContentType() and OnDeletingFromContentType()  methods. We can override this in our custom fields, and this lets us do lots of useful things – like register event handlers, add workflows, or set properties on the content type, which are things that I’ve wanted to do a few times now. So, good news!

This turned out to be quite an interesting problem. All fields use a subclass of BaseFieldControl, and this is what renders the field – so it appeared to be fairly straight forward. As always, though, there was a little kink to it – you need an SPContext for the site the item comes from, and you need to use this as the contexts for the SPField’s rendering control:

SPContext ctx = SPContext.GetContext(HttpContext.Current, item.ID, relatedList.ID, relatedWeb);

SPView relatedView = list.DefaultView;

foreach (string vf in relatedView.ViewFields)
{
    SPField fld = relatedList.Fields.GetFieldByInternalName(vf);

    HtmlGenericControl titleLabel = new HtmlGenericControl("H3");
    titleLabel.InnerText = fld.Title;
    this.Controls.Add( titleLabel );

    BaseFieldControl ctl = fld.FieldRenderingControl;
    ctl.ControlMode = SPControlMode.Display;
    ctl.ListId = relatedList.ID;
    ctl.ItemId = item.ID;
    ctl.RenderContext = ctx;
    ctl.ItemContext = ctx;
    ctl.FieldName = fld.Title;
    ctl.ID = Guid.NewGuid().ToString();
   
    this.Controls.Add( ctl );
}

Groovy!

• Query a SharePoint List for data
• Display that data

Not exactly complicated stuff, but I figured it would be a start. I decided to query a Picture Library, and display the pictures in my web part, changing the displayed image every few seconds. All of this is very achievable with JavaScript or jQuery and the Content Query Web Part (as some sort of variant on the CQTWP I built), so I thought this would be a good comparison.

I created a Silverlight Application Project in Visual Studio, and didn’t create a web site to host it (we’re going to use SharePoint)

I added references to Microsoft.SharePoint.Client.Silverlight and Microsoft.SharePoint.Client.Silverlight.Runtime assemblies in the 14/TEMPLATES/LAYOUTS/ClientBin directory.

In my MainPage XAML, I added an image control:

<Grid x:Name="LayoutRoot" Background="White" Loaded="LayoutRoot_Loaded">
        <Image Height="300" HorizontalAlignment="Left" Name="theImage" Stretch="Fill" VerticalAlignment="Top" Width="400" />
</Grid>

Fine – but how do we get the images into it, to display? Well, I started by creating a function to run when the Layout Root was loaded. In it we:

• Get the context of the site (SPWeb)
• Get the ‘Pics’ list (yes, hard coded for this demo)
• Construct a CAML query for the images
• Execute the query asynchronously

public partial class MainPage : UserControl
    {

        //class variables
        SP.ClientContext context;
        SP.Web myWeb;
        SP.List myList;
        SP.ListItemCollection myItems;
        List<string> files = new List<string>();
        System.Windows.Threading.DispatcherTimer myDispatcherTimer;

        private int _currentIndex = 0;

        private void LayoutRoot_Loaded(object sender, RoutedEventArgs e)
        {
            context = SP.ClientContext.Current;
            myWeb = context.Web;
            //Get handle to document library
            myList = myWeb.Lists.GetByTitle("MyPics");

            SP.CamlQuery query = new SP.CamlQuery();
            query.ViewXml = "<View></View>";
            myItems = myList.GetItems(query);

            context.Load(myList);
            context.Load(myItems);

            context.ExecuteQueryAsync(getRequestSucceeded, getRequestFailed);
        }

So, next, what to do on Success or Failure? Well, let’s do failure first – show an error message

private void getRequestFailed(object sender, SP.ClientRequestFailedEventArgs e)
        {
            Dispatcher.BeginInvoke(() => { MessageBox.Show("Error occured:  " + e.Message); });
        }

Fine. And on Success? Well, we want to:

• Add our results to a list of image files to show,
• Start a timer that changes the image being shown every few seconds

 private void getRequestSucceeded(object sender, SP.ClientRequestSucceededEventArgs e)
{
    Dispatcher.BeginInvoke(() =>
    {
 //iterate through each file and add file to our list of files       
 foreach (SP.ListItem item in myItems)
 {
     files.Add(item["FileRef"].ToString());
 }

 // Do something with our data!
 myDispatcherTimer = new System.Windows.Threading.DispatcherTimer();
 myDispatcherTimer.Interval = new TimeSpan(0, 0, 0, 0, 2000);
 myDispatcherTimer.Tick += new EventHandler(Each_Tick);
 myDispatcherTimer.Start();

    });
}

That’s fine – but what happens every few seconds (in the Each_Tick delegate?) Well, I wanted a nice ‘Fade Out, fade in’, but this proved tricky. In the end I referred to this example, which showed me how to define my animations in the XAML:

<UserControl.Resources>
        <Storyboard x:Name="FadeOutAnimation" Completed="FadeOutAnimation_Completed">
            <DoubleAnimation Duration="00:00:00.50" From="1" To="0" Storyboard.TargetProperty="Opacity" Storyboard.TargetName="theImage" />
        </Storyboard>
        <Storyboard x:Name="FadeInAnimation">
            <DoubleAnimation Duration="00:00:00.50" From="0" To="1" Storyboard.TargetProperty="Opacity" Storyboard.TargetName="theImage" />
        </Storyboard>
</UserControl.Resources>

Fine, so I’ve got animations defined – how do I use them? Well, in my Each_Tick delegate, I incremented the index of the image to be shown, and started the Fade Out animation. Then, when the Fade Out animation completes, it changes the image to be displayed, and starts the Fade In animation:

 public void Each_Tick(object o, EventArgs sender)
{
    _currentIndex++;    
    if (_currentIndex == files.Count){
       _currentIndex = 0;    
    }    
    FadeOutAnimation.Begin();
}

private void FadeOutAnimation_Completed(object sender, EventArgs e)
{
    BitmapImage bmi = new BitmapImage(new Uri(files[_currentIndex], UriKind.Relative));
    theImage.Source = bmi;
    FadeInAnimation.Begin();
}

And that’s it! Sadly, I can’t easily display it – a static image doesn’t do it justice – but that’s all there is to it.

So, my conclusions? Well, I though that querying the list might be tricky – but it was pretty straight forward, to be honest. The hardest part of this was the fading in and out animation, which I suspect is simply down to my lack of experience with SilverLight. I think that if I really knew what I was doing with Silverlight in the same way as I do with jQuery or JavaScript, Silverlight would actually be easier to have created this effect in.

I guess the next question would be feeding in Properties that a user can edit – such as the picture library name – so that the web part is easily reusable.

/sites/web/lists/list/allitems.aspx

That’s fine … but sometimes you need a full absolute URL. For example, you might be sending out an email with a hyperlink in it – a relative URL ain’t going to cut it.

Fortunately, there is a very useful function – SPSite.MakeFullUrl() :

Returns the full URL for the specified server-relative URL.

That’s great – but it raises some questions. What about Alternate Access Maps? What URL would be returned? Well, predictably, the URL used in the SPSite Constructor in the first place. Mostly, they either accept a URL (which defines a zone), or they accept a GUID and an SPUrlZone value. There is a constructor that just accepts a GUID – which will then use the default zone. Similarly, the constructor accepting a GUID and SPUserToken also uses the Default Zone.

(If you open it up in reflector, you can see it just calling a private constructor passing the SPUrlZone.Default value).

New documents seemed to be alright, but the older ones weren’t. So, maybe the problems were all the old documents, rather than my field.

Eventually, I came across this knowledgebase article – so I “inspected” the document, removed any of it’s custom data, and resaved it – and it worked fine.

What I think happened here was, I was testing different settings for Content Approval and Versioning on my document libraries. I think the troublesome documents were created when one of those was set to be ‘on’, and I subsequently turned it ‘off’. This meant that the document actually had extra data that referred to a column that no longer existed (I think) – which probably means this is related to Content Approval.

But I’d be curious if anyone else has managed to cause this error, and how they did so.

The code I’d inherited was trying to solve this problem (it’s a known issue) this way - which is a bit ugly. It also holds memory for the Dictionary of values that, as far as I could see, was only being freed on IISReset. Yuck. And it didn’t work in our code, despite matching the example in that thread quite closely.

Fortunately, I came across a neat post on Gunnar Peipman’s blog – Temporary Solution for GetCustomProperty an SetCustomProperty Errors. I don’t like using reflection to invoke the methods I need to use, but at least it’s a solution, even if not ideal. And it works!

Please go to Gunnar’s post – but just in case his blog goes down, I’m going to shamelessly plagiarise his code below…

Thanks Gunnar!

Uses the System.Reflection API.

        private void SetFieldAttribute(string attribute, string value)
        {
            Type baseType;
            BindingFlags flags;
            MethodInfo mi;

            baseType = typeof(SemaphoreField);
            flags = BindingFlags.Instance | BindingFlags.NonPublic;
            mi = baseType.GetMethod("SetFieldAttributeValue", flags);
            mi.Invoke(this, new object[] { attribute, value });
        }

        private string GetFieldAttribute(string attribute)
        {
            Type baseType;
            BindingFlags flags;
            MethodInfo mi;

            baseType = typeof(SemaphoreField);
            flags = BindingFlags.Instance | BindingFlags.NonPublic;
            mi = baseType.GetMethod("GetFieldAttributeValue",
                                        flags,
                                        null,
                                        new Type[] { typeof(String) },
                                        null);

            object obj = mi.Invoke(this, new object[] { attribute });

            if (obj == null)
                return "";
            else
                return obj.ToString();
        }

Unfortunately, you can’t declaratively register event receivers at the SPSite (Site collection) level – which would be fantastic – just turn on the feature and across all your site collection lists/libraries of a give type would get additional event receivers. Personally, I think this may be a bug; I don’t see why this shouldn’t work at the SPSite level.

Anyway, there is still another option – we could register our event against a particular Content Type. This is a less often used approach, which raises two questions – how do you do it, and what happens to child Content Types?

So, how do you register the event? Well, first off, you can’t do it declaratively – CAML won’t let you register against a Content Type. That seems a bit of an omission. Still, we still have the programmatic option through SharePoint’s API – something like:

private void RegisterEventHandler(SPContentType ct, string name,
             int sequence, string evAssembly, string evClass, SPEventReceiverType type)
{
    SPEventReceiverDefinition oEv = ct.EventReceivers.Add();
    oEv.Name = name;
    oEv.Type = type;
    oEv.SequenceNumber = sequence;
    oEv.Assembly = evAssembly;
    oEv.Class = evClass;
    oEv.Data = string.Empty;
    oEv.Update();
}

Great! But what runs this? Well, we’ll want to use a Feature, and we can’t add it declaratively – so I’ll use a Feature Receiver (SPFeatureReceiver). When the feature is activated/deactivated, it’ll run some code, and we’ll add/remove our event receiver. The code I come up with was

using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.SharePoint;

namespace EventReceiverTest
{
    class AWBRegisterEventHandler : SPFeatureReceiver
    {
        private string[] cts = new string[] { "0x0101" };

        public override void FeatureActivated(SPFeatureReceiverProperties properties)
        {

            foreach (string ct in cts)
            {
                try
                {
                    SPContentTypeId ctId = new SPContentTypeId(ct);
                    SPSite site = properties.Feature.Parent as SPSite;

                    if (site == null)
                    {
                        throw new ArgumentException("Feature must be activated at an SPSite level");
                    }

                    SPContentType currentCT = site.RootWeb.ContentTypes[ctId];

                    if (currentCT == null)
                    {
                        throw new ArgumentException(string.Format("Content Type ID {0} not found"));
                    }

      string evClass = typeof(AWBEventHandler).FullName;
      string evAssembly = typeof(AWBEventHandler).Assembly.FullName;

                    RegisterEventHandler(currentCT,"Content Type Event Receiver", 1000, evAssembly, evClass, SPEventReceiverType.ItemAdding);
                    RegisterEventHandler(currentCT,"Content Type Event Receiver", 1000, evAssembly, evClass, SPEventReceiverType.ItemAdded);
                    RegisterEventHandler(currentCT,"Content Type Event Receiver", 1000, evAssembly, evClass, SPEventReceiverType.ItemUpdating);
                    RegisterEventHandler(currentCT,"Content Type Event Receiver", 1000, evAssembly, evClass, SPEventReceiverType.ItemUpdated);

                    currentCT.Update(true, false);

                }
                catch (Exception ex)
                {
                    throw new SPException("Failed to add event receiver to content type", ex);
                }

            }

        }

        public override void FeatureDeactivating(SPFeatureReceiverProperties properties)
        {

            foreach (string ct in cts)
            {
                try
                {
                    SPContentTypeId ctId = new SPContentTypeId(ct);
                    SPSite site = properties.Feature.Parent as SPSite;

                    if (site == null)
                    {
                        throw new ArgumentException("Feature must be activated at an SPSite level");
                    }

                    SPContentType currentCT = site.RootWeb.ContentTypes[ctId];

                    if (currentCT == null)
                    {
                        throw new ArgumentException(string.Format("Content Type ID {0} not found"));
                    }
      string evClass = typeof(AWBEventHandler).FullName;
                    UnregisterAllEventHandlers(currentCT, evClass);

                }
                catch (Exception ex)
                {
                    throw new SPException("Failed to remove event receiver from content type", ex);
                }
            }
        }
        public override void FeatureInstalled(SPFeatureReceiverProperties properties)
        {
        }

        public override void FeatureUninstalling(SPFeatureReceiverProperties properties)
        {
        }
 
        private void RegisterEventHandler(SPContentType ct, string name, int sequence,
            string evAssembly, string evClass, SPEventReceiverType type)
        {
            SPEventReceiverDefinition oEv = ct.EventReceivers.Add();
            oEv.Name = name;
            oEv.Type = type;
            oEv.Assembly = evAssembly;
            oEv.Class = evClass;
            oEv.SequenceNumber = sequence;
            oEv.Data = string.Empty;
            oEv.Update();
        }

        private void UnregisterAllEventHandlers(SPContentType ct, string evClass)
        {
            bool bContinueDelete = true;
            while (bContinueDelete)
            {
                if (ct.EventReceivers.Count < 1)
                {
                    bContinueDelete = false;
                }
                else
                {
                    bool bFoundOne = false;
                    foreach (SPEventReceiverDefinition d in ct.EventReceivers)
                    {
                        if (d.Class == evClass)
                        {
                            d.Delete();
                            ct.Update(true,false);
                            bFoundOne = true;
                            break;
                        }
                    }
                    if (!bFoundOne)
                    {
                        bContinueDelete = false;
                    }
                }

            }
        }
    }
}

This code will register/unregister my AWBEventHandler class, for Content Types based on Documents (oxo1o1). By adding more elements into the array at the top, we could register against more content types. Naturally, a more sensible thing would be to have a Feature Property elements feeding in things like the Assembly, Class, Event Name, and Content Types, but this is just an example.

Note that the UnregisterAllEventHandlers is a little strange. Normally, I’d write something like:

private void UnregisterAllEventHandlers(SPContentType ct, string evClass)
{
    List<SPEventReceiverDefinition> toRemove = new List<SPEventReceiverDefinition>();
    foreach (SPEventReceiverDefinition d in ct.EventReceivers)
    {
        if (d.Class == evClass)
        {
            toRemove.Add(d);
        }
    }
    foreach (SPEventReceiverDefinition d2 in toRemove)
    {
        d2.Delete();
    }
}

In that function, we iterate over the SPEventReceiverDefinitionCollection generating a list of things to delete, and then delete them. We don’t delete them in the first for loop as deleting an item invalidate the enumerator for the for loop – so it throws an exception. Anyway, I tried using that function, and it didn’t remove all of the event receivers. I don’t know why – it works fine on lists. Instead, I developed the weird looking function shown above.

All of which is fine, but this still leaves a question – will these events be registered for child content types? In our code, we’ve got the line:

currentCT.Update(true, false);

That .Update(true,false) call will update child content types, and not throw an exception if it tries to update a sealed content type (important if you’re trying to register against something as general as the ‘Document’ content type. So the short answer is yes, our event receiver will be registered against child content types.

For example, I had a document library which allowed two document content types:

After registering against the Site content type for Documents, I used SharePoint Manager to see what event receivers I had registered in my Site collection. The image below shows a Library which has only one content type at the top, and one with 2 content types below. You can see that there are 4 event receivers registered per content type.

Note – if you change the Content Type after uploading a document – which you can through the user interface – and save that change then the other content type’s event receiver is run for ItemUpdated.

What might be interesting is the question – if we got our SPContentType object from an SPWeb (as above) – therefore as a Site Content Type, and didn’t apply the event receiver to child content types, would the list content types get the event receivers? Short answer – existing children would not, but I’m pretty sure that new child content types would.

So, in summary – above we’ve seen how to register and unregister an event receiver against a content type and all it’s child content types. And that seems to work pretty well! This has the advantage that it’s pretty simple, therefore, to add an event receiver across an entire Site Collection in one feature, rather than need a feature activated for each Web.

So, first off, as a reminder to myself, Wiki libraries are defined in the ‘WebPageLibrary’ feature. Took a while to track that down.

Second off, calling the SPListItem.Title for a Wiki pages causes an ArgumentException. (Waldek Mastykarz has written about this). Kind of makes sense – the wiki item doesn’t have a title – but I’d prefer it returned the filename (without extension) instead. That would seem a more useful compromise.

I’m trying to do something with various types of item, including Blog Posts, in SharePoint. Naturally, I’m getting the SPListItem for them, and then the SPListItem.ContentType, so I can check what kind of item is it. The weird thing is, if I try to get a Blog Post, the SPListItem.ContentType is NULL.

The code I’m running is:

static void Main(string[] args)
{
    string url = "http://vm-moss2007/sub/blog/Lists/Posts/";
    using (SPSite site = new SPSite(url))
    {
        using (SPWeb web = site.OpenWeb())
        {
            SPList list = web.GetList(url);
            SPListItem item = list.GetItemById(1);

     Console.WriteLine(item.DisplayName);
     if (item.ContentType == null)
     {
         Console.WriteLine("ContentType is Null");
     }
     else
     {
         Console.WriteLine(item.ContentType);
     }
 }
    }
}

I was running this code in a console application on the server. The URL is to a Blog Post library in a Blog site. When run, the output was:

I then tried this, but using a URL to a Pages Library. This shows an output type of SPContentType – which is what I’d expect.

That’s weird. I mean, the item clearly DOES have a content type at some level – there is an SPBuiltInContentTypeId.BlogPost value. However, SharePoint Manager doesn’t show it, my code reports it  as NULL, and I can’t find any references to this anywhere! And the Advanced Settings page for a Blog’s “Posts” list doesn’t have an option “Allow Management of Content Types”.

Views can show  the Content Type column, which reports itself as ‘Post’ for each item.

Anyone else ever seen this?

Themes, on the other hand, are fiddly to install automatically, don’t work on the DatePicker, and are individual to each site once applied. To pick up changes to a global theme, you’d have to apply a different theme and then reapply the desired theme - for every site.

Well, that was with SharePoint 2007. SharePoint 2010 is a bit different, as I got to find out on a Combined Knowledge course in January (and this is the first time I’ve managed to write about it!)

Themes in SharePoint 2010 are, well, really quite neat. The branding itself is made up of images and CSS – no surprise there. However, you can ‘annotate’ your CSS so that particular colours can be replaced by your theme. The colour schemes themeselves are defined in PowerPoint. Yes, PowerPoint. I was suspicious, but works pretty well. (You can also use SharePoint Designer too – see below). There are the built in ones:

But more likely, you’ll be defining your own 12 colours:

You can save this theme as a ‘.thmx’ which you can then upload to SharePoint, and use! No changing XML files or anything!

However, the problem in 2007 of doing just a global replace of CSS colours was that a lot of the branding for SharePoint is done through images – all of the menus, the little gradients on toolbars, the background of the pages – there are a lot of images, and regenerating these took time. Well, in SharePoint 2010 your can annotate images used in your CSS to be regenerated using the colours of your theme. That’s right, instead of having to manually create those images, you can get SharePoint to do it for you. It’ll even do just areas of the image. For example, if your site had a single which showed one of those stock pictures of ‘happy people looking at a PC’ and a company logo, you might want to re-color the people, but not the logo bit. SharePoint 2010 can do that. Wow! I think this will allow the sort of ‘basic’ branding that a lot of organisations want internally.

Edit: actually, the SharePoint Designer blog has a good example. I can’t say that I blame them for being stoked – this is really neat! Well, provided the core styles have been designed properly, with themes in mind.

I don’t think this will replace branding via features – it still can’t make changes to the layout of your pages, beyond what can be achieved with CSS – but it does address a number of the pain points with 2007 Themes. Certainly, it’s something I can see being useful for those customers wanting SharePoint to “just not look SharePointy” without having to go to the pain of development.

Though they will have to choose decent colors!

What we really needed was a way to set that the property wasn’t to be shown in the Document Information Panel. However, there is no easy way of doing this with a purely programmatically created column. There are properties on the SPField object that can be accessed programmatically, and the CAML for a FieldRef can set ShowInFileDlg – but there isn’t an obvious way to set this value from C# code.

Naturally, that’s what we wanted to do. Well, there is a combination approach – the SPField.SchemaXml property allows us to get/set the CAML that defines the field.

So, I came up with this static function:

static void SetShowInFileDlg(SPField f, bool value)
        {
            XmlDocument fieldSchemaXml = new XmlDocument();
            fieldSchemaXml.LoadXml(f.SchemaXml);
            XmlAttribute attr = fieldSchemaXml.CreateAttribute("ShowInFileDlg");
            attr.Value = value.ToString().ToUpper();
            XmlNode fieldXmlNode = fieldSchemaXml.SelectSingleNode("Field");
            XmlAttributeCollection fieldAttributes = fieldXmlNode.Attributes;
            fieldAttributes.Append(attr);
           
            f.SchemaXml = fieldXmlNode.OuterXml;
            f.Update(true);
        }

I’m not sure what happens if you’re trying to update an already widely used column – will it update all content types that that column – but this worked for us.

Add this to the xsl:stylesheet tag at the top:

xmlns:ddwrt="http://schemas.microsoft.com/WebParts/v2/DataView/runtime"

Then you can use something like the following (where item_date is an XSL variable with our date in it):

<xsl:value-of select="ddwrt:FormatDate(string($item_date), 2057, 15)" />

Here the FormatDate function is taking the string of the date, formating it for Great Britain’s locale (2057), and specifying an output format (15). Output formats vary by locale, and not all seem to be valid. I found that when I tried a format of ‘2′, for example, that I got an XSL error.

This is a particularly useful with the Content Query Web Part and the RSS Feed Web Part

Now, here is the weird thing. When I started to examine it, I tried to replicate the problem. And I realised that the page worked when I accessed it from the server, but threw an ArgumentNullException when I accessed it from a client.

Yes, you read that right. What machine you browsed to the page on mattered. The browsers were the same. The code worked when viewed on the server, and failed when viewed from the client. When I eventually fixed it, I swapped between the broken and fixed code a few times to prove it – this really was the behaviour!

I can only hope there is another factor I’ve not considered, ‘cos I don’t get how that can be the case.

The error message was:

Value cannot be null.
Parameter name: serverContext   at Microsoft.Office.Server.UserProfiles.UserProfileManager..ctor(ServerContext serverContext, Boolean IgnoreUserPrivacy, Boolean backwardCompatible)
   at Microsoft.Office.Server.UserProfiles.UserProfileManager..ctor(ServerContext serverContext)
   at MyAssembly.Pages.SettingsPage.OnLoad(EventArgs e)
   at System.Web.UI.Control.LoadRecursive()
   at System.Web.UI.Page.ProcessRequestMain(Boolean includeStagesBeforeAsyncPoint, Boolean includeStagesAfterAsyncPoint)

Looking in my code, I only had one call to the UserProfileManager constructor:

UserProfileManager oMgr = new UserProfileManager(ServerContext.Current);

ServerContext is in a SharePoint assembly, so it was out with reflector:

Ok, so we’re just calling GetContext() with the HttpContext. What goes on in there? This mess…

Yes, it’s nice and easy to figure out the logic of what’s going on in there. The short of it is that I saw several ways of NULL being returned – which would then cause our error.

So, my solution? Well, I didn’t like that mess, so I tried a different GetContext() method.

UserProfileManager oMgr = new UserProfileManager(ServerContext.GetContext(this.Site));

This worked when browsed to on either client or server. I chose that overload as it is much simpler, and doesn’t seem to rely at all on the HttpContext at all

Further research showed that other people have seem the same strange behaviour. Repeatedly. And the issue may be related to how the ServerContext is initialised.

I still don’t get how it can be different between the client and server, though. Post your ideas here!

EDIT: Ah-ha! Evidence that the problem is related to the Alternate Access Mappings. And a German blog post suggesting the same. And that would explain why the difference between client and server.

To check, I reverted my code back to it’s original form – and the exception reappeared. I then added another AAM:

The Extranet one is what I added – and suddenly the error went away – and my code worked. Interesting.

Ben started by discussing the why of BI, and the tools available. There are quite a lot – SQL Reporting Services, Excel Services, Business Data Catalog (sorry, Business Connectivity Services now!), KPIs in SharePoint.

The crux of this point was that ultimately, you want to empower business users to report on data they think is relevant. You don’t want to have to employ developers to build these things – they don’t know the data, or what figures are important. It’s a fair point. The sidebar to that is that you do need technical staff to get the data into your ‘cube’ in the first place. In other words, data has to be drawn into a central location and structured there, and then end users can generate the metrics they want from that.

His demo was, frankly, a bit of a stunner. Drilling down through what was clearly a large data-set, sorting and filtering millions of rows to show off PowerPivot (no, I still don’t really get what it is). The Decomposition Tree was very neat. Definite ‘wow’ factor, with a bit of a message of ‘just slap a few web parts on, and it works’.

And that last point was what stuck out for me. Yes, the demo was very impressive. Plenty of charts, filtering, drilling down, publishing to Excel, Bing maps. Slapping web parts on the page looked very simple. But it all relies on you having put your data into an OLAP cube. Don’t know what one of those is? No, me neither (and I was very glad when Chris O’Brien asked what they were – I was assuming everyone else knew!)

When we then started talking about how to draw in that data, the message really became one of “Plan, Plan, Be methodical and Take Your Time”. That rather sits at odds with the demo. Building your data model does need to be done carefully, but it’s not visible, it’s not sexy, and it’s not interesting to management/end users. They just want pretty charts. So you’ve got this tension between the user interface end being “Fast, Easy, POW – Done” and the back end being “Careful, Plan, Gently”. I’m worried that Microsoft’s marketing – and salesmen throughout the industry – will set an expectation which can’t be easily met.

Of course, if you’ve already got a nice OLAP cube to use, that’s not an issue. But the other elephant in the room was that most companies don’t have that. Reporting is an afterthought. At best you get Requests for Tender that say you ‘must be able to produce reports’, but the dialog then goes:

“Report on what?”

“Um, anything we want”

Sometimes reporting isn’t mentioned at all. And when there is reporting, what is the most ubiquitous reporting tool around? Excel Spreadsheets. Every organisation has lots invested in Excel spreadsheets for reporting. And it’s all very well to say “Ah-ha! Excel Services!” – but now tell me how to deal with linked spreadsheets? Or VBA Macros? They always make an appearance, and it’s a phenomenally hard thing to deal with short of ‘right, let’s start again with a different technology’, which is hard to do without a feeling of reinventing the wheel. That’s not to say that I don’t think it should be done – but it’s a tough sell.

All of which then leads round the methodology of this, and the change management – which was a bit outside what could be covered in the meeting. This is where things will get interesting, though – controlling the vision of what can be achieved, and then managing the changes to the existing reporting strategy. Especially as people do like (or maybe just ‘know’) Excel. But that’s for  later post – or maybe just someone who knows more.

Anyway, that aside – you can make Visual Studio break on any exception, not just the unhandled ones. Use Ctrl-Alt-E to edit – there is supposed to be some way to get to it though the menu, but I’ve not found it. Discovered in a blog post here.

Breadcrumbs in Layouts pages are driven by an XML file in your IIS web app. Now, you can add entries which are merged into that – a described by Jan Tielens’ Adding Breadcrumb to application pages in SharePoint – the easy way. However, this doesn’t cover the whole problem – he goes on to describe dealing with Central Admin too.

However, the really tricky bit of this that though we can define our own sitemap.xml file, it’s kind of hard to merge with the existing one. Specifically, the problem is that to merge ‘our additions’ and the ‘existing file’, we have to call a function ApplyApplicationContentToLocalServer, and as brilliantly described by Sean McDonough, the word ‘local’ is a problem in this method – it only forces a merge of the files on one server. Not much use in a server farm.

Sean’s article describes his attempt at a fix – using a one-time timer job, and a fair bit of reverse engineering of the ApplyApplicationContentToLocalServer function. Also, it seems like Vince Rothwell has come up with a similar solution, so it’s likely that this is a good approach.

A real pain to have to build so much to do such a simple task, though.

Application master pages are tricky – out of the box in SharePoint 2007, there is no way of changing the master page used for ‘administrative’ pages. Unfortunately, those administrative pages include things like the recycle bin, file upload, and the ‘View all site content’ pages – things that users will likely see.

Well, folks have found a solution to this -  using an HTTPModule to intercept pages using the normal application.master and redirecting it to use your custom one. This works pretty well, but I was always a bit uncomfortable – what if you only want this to happen for particular site collections, or specific sites within a Web Application? I’d tried knocking up an HTTPModule to do this, but matching against URLs – bit it was awkward to configure, complex, and adding new sites/site collections could be a bit annoying – basically, a nightmare to configure.

What we really need, I thought, is some way of just turning on/off the master pages being used with Features. And that’s what I’ve built. Check it out here…

SPWebConfigModification modification = new SPWebConfigModification(
     "add[@name='MyNavProvider']",
     "configuration/system.web/siteMap/providers");
modification.Value = "<add name=\"MyNavProvider\" type=\"{Assembly info here!}\" />";;
modification.Sequence = 0;
modification.Type = SPWebConfigModification.SPWebConfigModificationType.EnsureChildNode;
modification.Owner = "MyConfigModification;

webApp.WebConfigModifications.Add(modification);
webApp.Update();

That works, but what about removing them? It’s important to do this – otherwise you can cripple a system. Well, I basically do the same as Vincent Rothwell – loop through the existing modifications finding ones with the correct owner, then then delete them.

However, I did have a problem the other day which took hours to track down. When I tried to remove my SPWebConfigModification, it would be removed – but the XML remained in my web.config. Eventually I realised something pretty obvious -the ‘name’ is really part of an XPath query used to find the node we’d added, in order to remove it. From MSDN:

When the type of web.config modification is EnsureChildNode, the Name property refers to an XPath expression that uniquely identifies the node under the parent node, as identified by the Path property

Therefore, the ‘name’ in my Name property must match the ‘name’ in the XML node I’d inserted in my web.config.

Mine were different (though my own stupidity), so the Remove operation was trying to remove a different XML node to the one I’d added.

Interestingly, Deletes still have a version number. But there really is no version number recorded for updates…

… even when there is Versioning on the list:

 
Further, although previous versions of Documents have a url which includes the _vti_history folder, previous versions of ListItems do not – instead they just have a VersionNo GET parameter:

In the VersionNo paramater, the Major version is (VersionNo DIV 512) and the Minor version is (VersionNo MOD 512) – thanks to Dink for the hint on that part!