It isn’t immediately obvious how to do that. For a start, we wouldn’t actually be using the TaxonomyClientService. To set values on items, you use the Lists web service, using the UpdateListItems() method. This accepts XML describing the field and values.

But what fields do we submit, and what values? After all, as mentioned in part 1, there are two fields – one for the displayed value, and a hidden ‘notes’ field that contains the actual data!

There was no documentation about how to set these values, and limited and contradictory information in blog posts, so I investigated…

What you send depends on the type of field you’re trying to set. Normal managed metadata fields are different to the Enterprise Keywords field.

For normal taxonomy fields – either single or multiple values – you send an empty ‘display’ field, and populate the hidden field as below. This shows single and multi valued fields respectively, and the ‘_0′ fields are the hidden notes fields:

<Field Name='SomeField'></Field>
<Field Name='SomeField_0'>TermName1|12345678-0000-0000-0000-1234567890AB</Field>
<Field Name='SomeField2'></Field>
<Field Name='SomeField2_0'>TermName1|12345678-0000-0000-0000-1234567890AB;TermName2|98765432-0000-0000-0000-BA0987654321</Field>

There are a number of blogs out there that suggest that you need to submit your term’s display name in the display field. You don’t. You also don’t need to submit term IDs, GUIDs or otherwise.

There are also blog posts suggesting that your values you submit to the hidden notes field have to be of the form:

2;#My Term|d511f3c7-377f-480f-aff6-beebecd3c675

In this form, the ’2′ would represent the term description on the hidden list of taxonomy terms that is stored in the site collection. (I think that this is effectively a cache, though quite why I’m not too sure)

There’s a problem with that though. To submit terms in that form we’d have to look up their ID on that cache list (which is laborious, and it’s a different value for each site collection). Also, what if the term hasn’t been cached already?

Well, other blogs posts (I’m afraid I’ve lost their reference) say that you should submit your values in the form:

-1;#My Term|d511f3c7-377f-480f-aff6-beebecd3c675

The ‘-1′ is supposed to represent the fact that you don’t know what the ID is. But if you don’t know that, how does it get filled in?

Well, there is an event handler that runs for all lists that use a Managed Metadata field. It looks after populating the hidden list of taxonomy terms, and it will insert that ID into the value of an item. It also populates the display text for that Managed Metadata field, which is why we can submit an empty value to that field.

And, in fact, the ‘-1′ is not only unnecessary – that event handler is smart enough to recognise if there is no ID of the term on the hidden list being submitted – but if you want your values to look exactly the same as standard SharePoint’s values, then you should submit your value in the form:

#My Term|d511f3c7-377f-480f-aff6-beebecd3c675

Submitting a value with -1 at the start of it does work – but the value stored internally is not identical to the value that would be stored if you had set it using the SharePoint User Interface.

Now, all of that was for normal Managed Metadata fields…

Enterprise Keyword fields accepted values of a slightly different format. For reasons I can’t quite fathom, you seem to have to submit your values in the form:

<Field Name='TaxKeyword'>;#</Field>
<Field Name='TaxKeywordTaxHTField'>TermName1|12345678-0000-0000-0000-1234567890AB;TermName2|98765432-0000-0000-0000-BA0987654321</Field>

Note that the ‘Display’ field has a value of ;# submitted to it. I don’t know why (again, I found this input via exhaustive seach), but the Enterprise Keywords field does not work if you submit an empty value for that field (as you would for a normal managed metadata field).

Bonus information: As others have noted, the Enterprise Keywords fields will always have the same names and GUIDs to identify them:

• TaxKeyword – {23F27201-BEE3-471E-B2E7-B64FD8B7CA38}
• TaxKeywordTaxHTField – {1390A86A-23DA-45F0-8EFE-EF36EDADFB39}

(For those of you interested, I determined the correct input by filling in a number of fields using SharePoint’s user interface. I then looked at the raw data stored against the list item for them.

Then I wrote a console application that used the web service to set those fields, and compared the value that was actually stored with the example values. The console application tried lots of different inputs – various combinations of having a lead ID, of that ID being zero or -1, of having the term text, of having the term GUID, separating values with ; or with ;# etc. – to determine what formats resulted in the correct output. What I’ve written above is based on those tests, and I’ve used these formats of input for an application that I’ve written, and it seems to be working okay.)

string clientTimestamps = string.Format("<timeStamp>{0}</timeStamp>", lastClientCacheTime );
string clientVersion = "<version>1</version>";
string termStoreIds = string.Format("<termStoreId>{0}</termStoreId>", termStoreId.ToString("D"));
string termSetIds = string.Format("<termSetId>{0}</termSetId>", termSetId.ToString("D"));
string serverTermSetTimestampXml;
string result = _wssTax.GetTermSets(termStoreIds, termSetIds, 1033, clientTimestamps, clientVersion, out serverTermSetTimestampXml);

Fine, but what are these properties we’re passing into GetTermSets()?

Well timeStamps is the time you last retrieved the term set as number of Ticks for that time. E.g.

long clientTime = 0;
if (File.Exists(taxonomyFileCachePath))
{
clientTime = File.GetLastWriteTimeUtc(taxonomyFileCachePath).Ticks;
}

clientVersion is described as:

Collection of versions of the server that each TermSet was downloaded from (always 1 unless the client doesn’t have the TermSet, then it is 0).

That has me puzzled, so I always just send a version of 1.

termStoreIds is the ID of the term store we want to get terms from.

termSetIds is the term set we want to retrieve.

serverTermSetTimestampXml is the an output parameter which contains the last edit times for each of the retrieved term sets.

You may notice that for the above parameters I keep talking about term sets – as if you format your XML strings with multiple entries you should be able to retrieve multiple term sets at the same time. To be honest, though, I reckon this might be more effort than it’s worth, so I’ve written my functions to retrieve one term set at a time.

So what do I get back?

If my last cached time is from before the last editted time on the server, I get back the XML for the term set.

If my last cached time is more recent than the last editted time on the server, I get back XML containing no terms.

Thus, my logic for caching becomes:

• Get the last time I cached the term set.
• Call GetTermSets() on the web service.
• If there are terms in the response then the term set was editted since I last cached them. Write these new terms to the cache.
• Read the terms from the cache.
• Return them.

This would be something like:

long clientTime = 0;
 if (File.Exists(taxonomyFileCachePath))
 {
     clientTime = File.GetLastWriteTimeUtc(taxonomyFileCachePath).Ticks;
 }
 string clientTimestamps = string.Format("{0}", clientTime);
 string clientVersion = "1";
 string termStoreIds = string.Format("{0}", termStoreId.ToString("D"));
 string termSetIds = string.Format("{0}", termSetId.ToString("D"));
 string serverTermSetTimestampXml;
 //HACK: Hardcoded Locale
 string result = _wssTax.GetTermSets(termStoreIds, termSetIds, 1033, clientTimestamps, clientVersion, out serverTermSetTimestampXml);
 // Get the terms from the Web Service Response as a list of 'WssTaxonomyTerm' objects.
 // WssTaxonomyTerm is my own class to represent a Term in a Termset
 terms = GetResultsFromString(result);
 XmlSerializer ser = new XmlSerializer(typeof(List));
 //Terms.count could be zero because we already have a cached version in a file locally.
 //If so, don't overwrite that file. We'll load from it below.
 //If we did get terms back, then they are more recent than our cache. Save them. They'll be loaded below.
 if (terms.Count > 0)
 {
     using (FileStream fs = new FileStream(taxonomyFileCachePath, FileMode.Create, FileAccess.Write))
     {
         ser.Serialize(fs, terms);
     }
 }

if (File.Exists(taxonomyFileCachePath))
 {
     using (FileStream fs = new FileStream(taxonomyFileCachePath, FileMode.Open, FileAccess.Read))
     {
         terms = (List)ser.Deserialize(fs);
     }
 }

return terms;

Anyway, as a note to myself…

• SharePointBlues has good post on how to set up those custom styles.
• MSDN has an article about How to: Customize the SharePoint HTML Editor Field Control
• Don’t forget to style things like lists and tables.
• Don’t forget to set a minimum edit height.
• Regarding the difference between Markup Styles and Styles:
  • the “Markup Styles”
    • nest the text and its HTML tag within the html tag specified in the style if the tag to nest is a <span> element
    • replace the current tag if is is not a <span> element
    • remove all the styles for the children elements
    • remove the html tag if the same style is applied a second time (this is a way of removing a Markup style for an end-user)
  • the “Styles”
    • nest the text in a <span> tag with the style class if the text is not already inside an HTML tag
    • just add the class to the current HTML tag if this tag is not a <span> tag
    • replace the class of the HTML tag if this tag is a <span> tag
    • remove the html <span> tag if the same style is applied a second time (this is a way of removing a Style for an end-user)
• Consult the Out-of-box styles as examples. It’s in LAYOUTS\1033\STYLES\HtmlEditorStyles.css , and it’s actually a pretty well structured (if substantial) file.

Web Part or Web Form Control on this Page cannot be displayed or imported. The type is not registered as safe

This is discussed in KB2535012, the main thrust of it being:

This issue occurs because the RSS Viewer Web Part is not available in Office 365. This issue is scheduled to be resolved in a future version of Office 365.

In fairness, this restriction is mentioned in the SharePoint Online Release notes.

Alternatives? Well, they’re limited. Rene Modery has written a solution using JavaScript and the Google Feed API (which should mean that there’s some caching of the feed, albeit on Google’s servers). It’s the main alternative that I’ve come across, and it’s how I’d approach the problem, although I think that authentication between your Google server, with it’s cache, and the target feed could be tricky.

There’s more information on his approach here.

And further evidence that it might be the only reasonable approach – Raghavendra Shanbhag describes doing the same sort of thing with the zRSSFeed jQuery library.

Or, I guess the other alternative is to wait for Microsoft to fix this – and they have to, not having RSS in Office 365 SharePoint is absurd.

If you create a site using the Team Site template and go to Settings > Site Theme, you get a more advanced page.

Both these experiences are supported by the one page (/_layouts/themeweb.aspx). So what gives?

Well, themeweb.aspx contains two delegates placeholders, and there is a feature EnhancedTheming (ID: 068BC832-4951-11DC-8314-0800200C9A66) that contains controls to insert to them. This feature is hidden, but is used by a lot of the site templates – but not Blank sites. It’s also required by the publishing features.

(Actually, this feature is stapled to most of the site templates by the BaseSiteStapling feature)

So, could we turn this on for a Blank site? Obviously we can’t through the UI, but STSADM should let us.

stsadm -o activatefeature -name enhancedtheming -url [site url]

And voila! A Blank site with enhanced theming!

So why this structure? I know that the enhanced theming isn’t part of SharePoint Foundation, so having a feature that staples it to Site Definitions in full SharePoint makes sense. However, I must confess, I’m puzzled why is isn’t also stapled to ‘Blank’ sites. I guess that maybe it’s to try and keep Blank sites, um, blank.

System.Runtime.Serialization.SerializationException was unhandled Message=Unable to find assembly ‘<my assembly strong name>’

Interesting. I tried similar code within a Console application using the full SharePoint API…

    public enum Color
    {
        Red,
        Green,
        Blue
    }
    class Program
    {
        static void Main(string[] args)
        {
            string url = "http://sp/";
            using (SPSite site = new SPSite(url))
            {
                using (SPWeb web = site.OpenWeb())
                {
                    web.SetProperty("TempKey", Color.Green);
                    Color c = (Color) web.GetProperty("TempKey");
                    Console.WriteLine(c);
                    Console.ReadLine();
                }
            }
        }
    }

This worked fine, so it seemed to be something to do with the Sandbox. However, all the bits of the API I was using were allowed in the Sandbox. Eventually, I found the solution – and it turns out the problems is with Serialization inside Sandbox solutions. From Florin Muntean’s post:

The problem is that the serialization mechanism inside .NET requires to load the assembly for reflection. The SandBox assembly can’t be found because it is not saved in the GAC or any of the SharePoint folders as it only resides in memory and on the Content Database.

A work around for this to create your own serialization to xml/string using custom methods that will save/restore your data using one of the .NET classes (that can be serialized because they live in GAC).

Actually, it’s pretty obvious when someone explains it to you!

Following that advice, instead of storing the enumeration I stored the the .ToString() of it’s value, and parsed it back to the enum when I retrieved it:

public static LogLevel Level
{
    get
    {
		SPWeb rootWeb = SPContext.Current.Site.RootWeb;
		object obj = rootWeb.GetProperty(LoggingConsts.LOGLEVEL_PROPERTY);

		LogLevel lvl = LogLevel.None;
		if( obj != null ) {
			lvl = (LogLevel) Enum.Parse(typeof(LogLevel), obj.ToString());
		}
		return lvl;
    }
    set
    {
		SPWeb rootWeb = SPContext.Current.Site.RootWeb;
		rootWeb.SetProperty(LoggingConsts.LOGLEVEL_PROPERTY, value.ToString());
		rootWeb.Update();
    }
}

And it worked like a charm. Nice one Florin!

However, I ran into a hitch when working with Office 365. Although reflection worked fine on my local machine’s sandbox, I got an error when I tried to run the same code on Office 365′s SharePoint system. It was pretty obviously and emphatically using System.Reflection that was the problem.

This was a shame, as my build process is (as usual) putting the AssemblyFileVersion in. Sadly, I don’t see any easy way to get the AssemblyFileVersion value from within Office 365 code. So, alternatives?

Well, my answer was a little … primitive. I added a CONST to my code:

const string SOLUTION_VERSION = "Development";

And I modified my build process to do a regex replace of that line in my code file during the build. I’d already written a build activity that would do a “regex find and replace in files”, so this was pretty simple to do.

The hard part, however, was deciding what the replacement pattern should be. The build process doesn’t seem to have any easy to use variables (our build processes are largely based on TFS Versioning on CodePlex).

(Note – from here on things get a little specific to what we use)

So, I chosed to the replacement pattern:

String.Format("string SOLUTION_VERSION = ""{0}.{1}"";",
    Regex.Replace(AssemblyFileVersionPattern, "\.[^.]+\.[^.]+$", ""),
    Regex.Replace(LabelName, "^.*_", ""))

The first regex cuts the tail two elements off the AssemblyFileVersionPattern for our build, which is a variable we do have. By convention, in our build process, the front two elements are always numbers, and are manually altered when we move between versions.

The second regex cuts off the start of the build name. Our build name ends with the year and day of year, and the build revision for that day, just like our AssemblyFileVersion. Thus, the result of that regex is the tail two elements of our AssemblyFileVersion.

This results in a number of the form 1.2.12345.6 which is then inserted into our constant during the build process.

(Told you that the solution was a little bit specific to our process)

However, I’m now working on a sandbox solution, and when I tried using it, I got the error:

MissingMethodException Method not found: ‘Void Microsoft.SharePoint.SPWeb_SubsetProxy.Recycle()’.
at Microsoft.SharePoint.SPWeb.Recycle__Inner()
at Microsoft.SharePoint.SPWeb.Recycle()

Hmm. That’s strange; my call to recycle seems fine, and the documentation says it’s available in the Sandbox, but internally there seems to be a missing method.

Out of curiousity, I tried using Delete() rather than Recycle(), and this worked correctly. So what gives?

Next I opened Reflector, and opened the Microsoft.SharePoint assembly from 14/Usercode. Note that this is not the same as the Microsoft.SharePoint assembly from 14/ISAPI. The Usercode one is the assembly used in the Usercode service, and it is a subset of the full object model. It also works differently internally.

Anyway, I opened the SPWeb.Recycle__Inner() method:

Okay, only two lines. Long story short, I checked the SubsetOMEnabler.VerifySubsetOMEnabled() line, and it was doing something about controlling what OM was available. I couldn’t see anything that would result in the stacktrace I’d got, though.

However, the other line could. It casts an object to an SPWeb_SubsetProxy instance, and then calls Recycle() on it. This was the method that seemed to be missing, so I checked the SPWeb_SubsetProxy class to see if it had such a method.

Hmm. There’s a notable lack of a Recycle() method, just like the exception said.

So how does this compare with the SPWeb.Delete() method? Well, it uses the same pattern – a call to an inner method which casts the same object to an SPWeb_SubsetProxy class, and then it calls Delete() on the subset proxy.

The difference is, though, that the SPWeb_SubsetProxy class actually has a Delete() method.

Conclusions? Well, I’m not sure, but I think…

• The error message was right – the method appears to be missing.
• Compilation of the usercode version of the Microsoft.SharePoint assembly probably didn’t pick it up due to the ‘cast and call a method on the resulting object’ line. If it’d been:

SPWeb_SubsetProxy px = (SPWeb_SubsetProxy)base.__InnerObj;
px.Recycle();

… then I suspect the compiler would’ve complained.

• As this Object Model stands, it is not possible to recycle sites in Sandbox solutions. Which is sad, ‘cos that’s nice functionality.

Has anyone else seen this problem? I was trying this on a machine that was patched up to the February 2012 Cumulative Updates.

(I’m a bit hesitant as often ‘faults’ in APIs are down to developer understanding rather than actual faults, in my experience).

I couldn’t figure out what was causing this, but found the solution on MSDN forums:

In VS 2010, while you have the solution open in Solution Explorer, select File-> Source Control-> Change Source Control, could you click on Bind for each project/solution? Binding provides version control functionality. This includes various version control icons that indicate status in Solution Explorer.

This advice was correct – I went to the binding dialog, and the solution and projects weren’t bound. I added the bindings back – and presto. I’m not sure, however, how the project became unbound…

So, what do you do to link to an external stylesheet? Um, well, there isn’t any pretty story. The best I’ve come across is by Ian Chivers, who uses JavaScript to add another <Link>  tag into the <Head> of the page.

• Add a Stylesheet to a Page from a Sharepoint 2010 Sandbox WebPart

Clever, but yuck!

The explanation that I came across by Mukul Sabharwal (and seemed pretty good) was:

Sandbox webparts do not execute in the same ASP.NET context as the page in which they reside, instead they execute in a distince ASP.NET context in a seperate worker process (UserCode Worker Process). SharePoint setups a make-believe world for the WebPart — specifically this make believe world consists of a single page with a single webpart zone and a single webpart — your sandbox webpart.

Once the webpart finishes execution the result is returned back to the main page. In fact, even if RegisterCssReference was not internal, there is no guarantee that the CSS could be applied, because we may have be too late in the ASP.NET page lifecycle to go do that.

This brings me to to answering your question, which is it is not currently possible to specify CSS into a page for a Sandbox Web Part.

Makes sense – but some way of registering CSS might be useful.

Edit: I tested Ali Robertson’s comment about just putting the link tag directly in the page, and that works.Unfortunately, there’s no way of then resolving Themed CSS files – something the CssRegistration class does – so you can’t have themed CSS in sandbox solutions (at least, as far as I can see at the moment).

Anyway, I knew that the API you could use in the sandbox was smaller than the full API, and I wanted my solution to warn me (e.g. fail to compile) if I tried to use something that wasn’t available in the sandbox. I found two approaches…

1. Replace the reference to Microsoft.SharePoint.dll. If you instead reference the version for the sandbox ( in 14/UserCode/assemblies ) and the project compiles successfully then it is a valid sandbox solution.(Note: Only reference this dll for validation during development. You should reference the Mirosoft.Sharepoint.dll at /14/ISAPI for Release, although I’m not entirely sure why.)
2. Use the SharePoint Power Tools Visual Studio Extension. Not only does it give a Sandboxed Visual Web Part project (nice!), but it also changes Intellisense and compilation to use the Sandboxed API. Fantastic!

Really, the Visual Studio extension is much simpler than changing and restoring assembly references, so I would always recommend it!

using (new SPMonitoredScope("My Monitored Scope"))
{
    // Do Stuff...
}

It’s worth noting that you can record more than just time (which I’d forgotten) – such as:

• SPSqlQueryCounter
• SPRequestUsageCounter
• SPExecutionTimeCounter

I must confess, I’m not entirely sure what these are for. I can’t ever seem to get them to show much information, and doesn’t the SPMonitoredScope return the execution time anyway?

Also, while not quite the same sort of counter, there is also the SPCriticalTraceCounter, that lets you record events…

SPCriticalTraceCounter.AddDataToScope(25, "My Event", 15, "Pop Goes the Weasel");

I’ve mentioned them (and the ‘level’ parameter) before.

These produce quite nice outputs:

Then you can also get Performance Counter information too.

SPHttpThrottleSettings throttleSettings =
      SPHttpThrottleSettings.GetHttpThrottleSettings(SPContext.Current.Site.WebApplication);
SPSystemPerformanceMonitorCollection monitors = throttleSettings.GenerateMonitors();
StringBuilder sb = new StringBuilder();
foreach (SPSystemPerformanceMonitor monitor in monitors)
{
	SPSystemPerformanceCounterMonitor counterMonitor = (SPSystemPerformanceCounterMonitor)monitor;
	sb.AppendFormat("{0} = {1}\n", counterMonitor.Name, counterMonitor.Value.ToString());
}

For my system, that code output:

I’m not quite sure what else you might be able to get from that. I’m also guessing that you probably need fairly high permissions to see some of that information…

Well, the easiest way would be to use C# Preprocessor Directives to change what your application does:

bool isDebug = false;
#if (DEBUG)
isDebug = true;
#else
isDebug = false;
#endif

I know the else isn’t needed, but it’s to show the other condition too.

So, what is this magical value DEBUG? Well, it’s a preprocessor variable that is optionally added to your project at build time. By default, it’s true for Debug build, and not for Release builds. You can find it in the project settings:

You could also just put this information into the AssemblyInfo.cs file for your assembly with the same Preprocessor directives:

[assembly: AssemblyTitle("Example Assembly")]
#if (DEBUG)
    [assembly: AssemblyConfiguration("Debug")]
    [assembly: AssemblyProduct("Example Assembly (Debug)")]
#else
    [assembly: AssemblyConfiguration("Release")]
    [assembly: AssemblyProduct("Example Assembly (Release)")]
#endif

Here I’m using AssemblyProduct to show the version as this information is shown in Details tab of the file’s properties in Windows:

Okay, so we can have the solution compile differently for Release and Debug. What if we wanted to detect it for an assembly that we’d not compiled? Well, Scott Hanselman has answered this already, but he doesn’t really define what is meant by a Debug build? Dave Black goes into this in more detail - but in short, does ‘Debug’ mean you can attach a debugger, or that optimisation of the code is turned off? I agree with his opinion – most people are asking if the code is optimized.

So, based on their offerings, here is my code for determining if an assembly was build in ‘Debug’ mode or not:

public static bool IsAssemblyDebug(Assembly assm)
{
    bool IsDebug = false;
    object[] attributes = assm.GetCustomAttributes(typeof(DebuggableAttribute), false);
    if (attributes.Length > 0)
    {
        DebuggableAttribute d = (DebuggableAttribute)attributes[0];
        IsDebug = d.IsJITOptimizerDisabled;
    }
    return IsDebug;
}

Warning 1 CA0068 : Debug information could not be found for target assembly ‘Something.exe’. For best analysis results, include the .pdb file with debug information for ‘Something.exe’ in the same directory as the target assembly.

Annoyingly, it didn’t seem to allow you to suppress it, and I was doing a Release build – so I didn’t expect to have a .pdb file.

So, how to get rid of it? Step 1 – RTFM:

Make sure that Debug info is either set to full for debug builds or to pdb-only for release builds. It should not be set to none.

Excellent – but where is the setting? Well, in my project this seemed well hidden, but was actually under the ’Advanced…’ button:

Apparently, the location of those settings can move, depending on project type.

I wanted to query for a particular item, some (though not all) of it’s properties, and I wanted to get it’s permissions. This post by Henrik Andersson gave me a good clue, though it didn’t explicitly mention getting the properties. To get the item, with it’s properties and it’s permissions:

//var clientContext = new SP.ClientContext(.... ;
clientContext.load(listItem, 'EffectiveBasePermissions', 'ID', 'Title', 'Owner', 'Active', 'Modified', 'Editor');
clientContext.executeQueryAsync(Function.createDelegate(this, this.OnItemQueryCompleted), Function.createDelegate(this, this.OnItemQueryFailed)); 

That performs the query to get the item and permissions – but how do you check them? Well, you need to to use the SP.ListItem.get_effectiveBasePermissions() method. (Note: there are SP.List.get_effectiveBasePermissions() and SP.Web.get_effectiveBasePermissions() methods too, for those tiers of the hierarchy).

function OnItemQueryCompleted(sender, args) {
	var perms = listItem.get_effectiveBasePermissions();

	if (perms.has(SP.PermissionKind.editListItems)) {
	      // ....
	}
}

The permissions are retrieved into an SP.BasePermissions object, which has the .has() method that you can use to check the permissions (returns true if the user does have that permission). The Permissions mask is defined by the values in the SP.PermissionKind enumeration.

function OnItemQueryFailed(sender, args)
{
   alert('Error:\n' + args.get_message() + '\n' + args.get_stackTrace());
}

Note that these details are from the SP.ClientRequestFailedEventArgs class. There are other properties too.

These properties are quite important, as they tell us what we need to know to get the correct TermSet for our field.

If you look in the properties you’ll see:

• SspId – The ID of the Managed Metadata Service containing the TermSet for this field. This ID is also sometimes referred to as the TermStore ID.
• TermSetId - The ID of the TermSet for this field.

With this information we can use the GetTermSets method of the TaxonomyClientService. (The code below is based on “Working with the Managed Metadata Service Remotely” by Virtosoft.

string clientTimestamps = string.Format("<timeStamp>{0}</timeStamp>", clientTime);
string clientVersion = "<version>1</version>";
string termStoreIds = string.Format("<termStoreId>{0}</termStoreId>", termStoreId.ToString("D"));
string termSetIds = string.Format("<termSetId>{0}</termSetId>", termSetId.ToString("D"));
string serverTermSetTimestampXml;
string result = _wssTax.GetTermSets(termStoreIds, termSetIds, 1033, clientTimestamps, clientVersion, out serverTermSetTimestampXml);

So, there are a lot of parameters to that call – I’ll deal with them in part 3, which will be about caching. You’ll note that you can retrieve multiple termsets from multiple termstores – I think. I’ve not tried it (I’d rather make several calls and keep things simple).

Let’s look on what we get back from the service:

Nice. So much for XML being human readable. So what’s this about?

First off, notice that there’s no nesting. All Terms are returned in a flat list:

The elements of the terms are:

• TS – Term Set
• T – The Term.
• LS – Label Set
• TL – Term Label. Potentially a Term can have several labels, for different Languages
• TMS – More Term Set Information
• TM – Term Information
• TD – Term Description

The attributes are all numbered, which is really helpful. What do they mean?

• a9 – Term ID or TermSet ID
• a11 – TermSet Description
• a12 – Term Set Name the Term belongs to
• a16 – Submission Policy (Is the termset open or closed)
• a17 – Term is Enabled (can be used for tagging)
• a21 – (boolean) False if the term is not deprecated
• a24 – Term Set ID the Term belongs to
• a25 – Parent Term ID
• a31 – (boolean) Not sure, I think this is true if it’s the default term label?
• a32 – Label Text
• a40 – Parent Term Name
• a45 – A semicolon separated list of the IDs of the Terms to the current term’s location in the taxonomy. (I.e. its path!)
• a61 – (integer) ?
• a67 – ?
• a68 – TermSet contact email

Nice and simple, eh?

Still, using this information you can determine the structure of the termset. In Part 3, we’ll look at caching.

This has proved particularly bloody hard.

To start with, let’s look at what fields I needed to deal with. When you add a Taxonomy column to a list, it actually adds two columns.

The first is your ‘display’ column, and this can actually be one of two types – TaxonomyFieldType or TaxonomyFieldTypeMulti. As the name suggests, these are for single select and multi-select respectively.

The second column is a hidden field of the ‘Notes’ type. This stores your actual data, it appears, though quite why still mystifies me a bit (more on that later).

Anyway, there are two columns. As you can see from the screenshots above, the Taxonomy column contains an array of customisation properties.

So, how are these two fields related? Well, not using the ‘RelatedField’ attribute (too obvious), and when I did a bit of a search I kept finding blog posts saying that I would have one field with the name I gave it, and another field with the same number but ending with an additional “TaxHTField0″ text. This was not the behaviour that I saw; it might have changed in a service pack.

On my system, the second (Notes) field seemed to have a GUID-like name. It looked mostly hexidecimal, but was often prefixed by a couple of non-hex characters. At first I thought that this might be the reference between the two fields.

However, the relationship is in fact one of the array of properties on the field:

The TextField property contains the ID of the Notes Field. Great, that’s nice and simple.

So, in summary, the relationship between the TaxonomyField and Notes field is held in the TextField property in the array of properties of the TaxonomyField. The value is the ID of the Notes field. You can get this information a variety of ways, but I used the GetListContentType method of the Lists web service.

In Part 2 we’ll look at getting and interpreting the TermSet for our field.

They’ve using the Telerik RadEditor web part quite a lot, so we had to keep that working. We’ve put in Assembly Binding Redirects using an SPWebConfigModification (more on that in a later post).

However, we also needed to put in the SafeControl entry for the old assembly. Maurice Prather discusses this here. The short of it is:

What happens to your Web Part when it’s redirected to version Y?

1. On first render of a redirected Web Part instance (this is a KEY thing to remember), if the SafeControl for version X exists, an attempt to load the Web Part is made.
2. The .NET framework kicks in and redirect to version Y is successfully made.
3. SharePoint notices that the Web Part type guid (nothing we the Web Part developers can explicitly control) has changed and saves the new type id back to the database.
4. From that point forward, the next time the Web Part is loaded, the call is made directly for version Y.

Take a look at step #3.  This is key.  The database actually contains a reference to your web part in a form of a guid.  The guid is a calculated value that allows the SafeMode parser to rapidly associate the serialized form with a live class type.  The important thing to remember is that this reference lives on a per-page reference (i.e. page ABC has reference to web part types M, Q, V).

Why is this important?  Until all instances of Web Part version X have been rendered, you cannot remove the SafeControl reference to version X unless you want bindingRedirect to fail.

Okay, fine. That makes sense, and I don’t have a problem marking a web part that we’ve been using for ages as safe, even if it will ultimately be updated in all instances by the redirection.

So, I put a new SafeControl entry into on the SharePoint Project Items of my solution.

(Please note: below I’ve used an assembly called ‘MyAssembly’. I’ve changed the name from the real assembly ‘cos I’m not sure I’m allowed to talk about it. But I’m showing the behaviour I saw).

This was then included in my Manifest:

However, when I went and checked the web.config I saw:

WTF? As best as I can determine, the assembly information in my SafeControls entry in my solution’s manifest has been ignored. The entry in the manifest lives within a particular Assembly element, so presumably SharePoint itself chooses to read the information from the assembly, rather than the manifest! (Why ask for the information then?)

Consequently, I found that the best option I had was to write an SPWebConfigModification to add my Safe Control entry. And that worked nicely.

Conclusion: If your WSP doesn’t contain the assembly you’re trying to create a SafeControl entry for, you’ll probably need to use an SPWebConfigModification. That seems a shame, given that Visual Studio 2010 appears to let you create other Safe Control entries, and puts them into the manifest correctly.

Found the answer on Stack Overflow:

So it turns out that Outlook doesn’t load the CLR on startup (it must be loaded shortly thereafter when it becomes necessary), which apparently confuses the VS debugger and causes it to only debug native code. To force it to load the CLR immediately, create an OUTLOOK.EXE.config file in the same folder with:

<configuration> <startup> <supportedRuntime version="v2.0.50727"/>  </startup></configuration>

which is from this blog post. Then, even when VS starts attached, it will debug CLR code