System.Data.SqlTypes.SqlNullValueException: Data is Null. This method or property cannot be called on Null values

This was happening when I was trying to add some tasks to an existing project, and was failing at the QueueAddToProject() method. Looking through the stack trace on the error (and seriously don’t get me started on how you get errors out of Project server – I might start coughing again! lol)I found that it was failing while trying to validate the session (with the session being from where I programmatically check out the project before I add to it).

Here was the problem in the end – when you check a project out you need to specify three things – the GUID of the project, a GUID to represent the session ID, and a string the describes the checkout. Initially I was leaving the string empty, because in all honesty I didn’t care that much – but that was the problem for me. As soon as I put a value in that string it was able to happily continue adding my tasks for me.

I would have liked to be given an error when I checked out the project here (rather than letting the code for the checkout execute fine and then whinge when I try to do something with it) but in the end the stack trace made it pretty easy to figure out.

• A SharePoint Saturday compendium, with notepad and calculator
• A special SharePoint Saturday pen (metal pen with laser etched SharePoint Saturday logo)
• A discount code to attend next year’s Australian SharePoint Conference for $600 (ex. GST) – which makes these tickets even cheaper than the early bird prices
• A free copy of iShare for iPhone (created by Spyk software) that you can use to access SharePoint sites on the go!

If you want to get your hands on all of this great stuff, plus be in the running to win some great raffle prizes, plus get to see some top notch presenters then make sure you get over the websites linked above and register to attend! The Sydney event is currently sold out but we have a waiting list and are working to clear people who can’t attend off the registration list to free up spots, so it’s not too late!

Here are some pics of the compendium and the pen! I hope you all like them!

Basically here is the scenario – you have a WCF service, and that service has a method that takes an abstract class as a parameter – in my case it was an IEnumerable of that abstract class, so like this:

[OperationContract]
IEnumerable<MyResult> MySearch(IEnumerable<MyParameter> Parameters);

Now basically I have two classes that inherit from that abstract class – MyBasicParameter and MyAdvancedParameter, both with a different set of properties. Now by default when I compile my service and add the service reference to visual studio, it is only going to generate a proxy class for MyParameter, not for the basic or advanced one.

So here is how you get it to work – there is an attribute you can declare for your abstract class called “KnownType” (http://msdn.microsoft.com/en-us/library/system.runtime.serialization.knowntypeattribute.aspx). This will tell the serialiser that there are other types that it can treat the specified type in the same way as it would the type you are declaring on – simply put, it will tell the serialiser about the child type and let it accept that as valid input where the abstract type is declared.

There are two ways you can use this. The first is to just add [KnownType(typeof(MyBasicParameter))] for each type to the top of you class – this will work and when you generate the proxies for the project consuming your class you will see these types there for use now. I personally wasn’t a fan of this method as it meant I had to remember to add types to this list of attributes as I created them.

The better option is to declare the attribute like this – [KnownType("GetKnownTypes")] – where “GetKnownTypes” is a static method in your class that will return an array of type objects that can be treated as known types. The next step was simply to load a list of all the types that inherited from the MyParameter type and have them return here. Here is the code that will get you there:

public static Type[] GetKnownTypes()
{
    return Assembly.GetExecutingAssembly().GetTypes().Where(IsSubClassOfMyParameter).ToArray();
}

private static bool IsSubClassOfMyParameter(Type TypeToCheck)
{
    while (TypeToCheck != typeof(object))
    {
        if (TypeToCheck.BaseType == null) break;

        if (TypeToCheck.BaseType == typeof(MyParameter))
        {
            return true;
        }
        TypeToCheck = TypeToCheck.BaseType;
    }
    return false;
}

So now whenever I add a new class, I don’t need to remember to add it as a known type, if it inherits from MyParameter it will automatically be found and a client proxy class will be generated for it in Visual Studio.

The first thing you need to grab is the OpenXML SDK. I got version 2 from the Microsoft download site at http://www.microsoft.com/downloads/details.aspx?FamilyID=c6e744e5-36e9-45f5-8d8c-331df206e0d0&displaylang=en. When you install it there is a tool called the “OpenXML SDK 2.0 Productivity Tool” that we are going to use to make this process a whole lot easier. Basically what it does is open an OpenXML document (any of the office document formats that end with the ‘x’, like docx, pptx, xlsx, etc) and will show you all of the XML files and structures within the document itself (or the ‘package’ as it is referred to).

As a starting point, I manually did the mail merge and saved the word document and then opened it up with this tool to see what I could see. The main part that grabbed my attention was under /word/document.xml –> /word.settings.xml –> w:settings –> w:mailMerge. If you right click on this node and choose “Reflect Code” you will see two windows pop up for you on the right of the window – the first is the actual XML from that node, which is somewhat interesting and confusing at the same time, but the cooler part for me was the C# code it generated below that would create that exact XML node for me – that’s a win right there folks!

So before we go any further, I wanted to explain what some of this stuff was before we blindly started working with it – The first few tags (like query, connectionString and dataSource are all used to define the source for the data – brilliant because that’s what we need to set. There are many tags below it though that are called fieldMapData – and it wasn’t clear to me at first what there were – I did figure it out though. If you go back into your word document and have a look under the ‘Mailings’ tab in the ribbon, you will see a button called “Match Fields”. What this does is it lets you map fields in your data source to a set of known fields that word can work with – so when you do things like insert and address block or a greeting line, it will know what field in your datasource maps to things like first name, last name, business address etc. So what you should do before we go any further is go and map all of these fields in your word document, then open it back up in the productivity tool and go back to looking at that code.

Now we can grab all of that C# and put it into our visual studio project – but first we need to give it some context and create the objects that represent the word document itself. Start by opening VS and adding a reference to “DocumentFormat.OpenXml.dll” (its in the directory you installed the SDK in). Now add a reference to DocumentFormat.OpenXml.Packaging and DocumentFormat.OpenXml.Wordprocessing to your class. Now lets add this code to open our document and get ready for the code from the productivity tool.

using (WordprocessingDocument wordDocument = WordprocessingDocument.Open(WordDocmentPath, true))
{
    var settingsPart = wordDocument.MainDocumentPart.GetPartsOfType<DocumentSettingsPart>().First();

    if (settingsPart.Settings.OfType<MailMerge>().Count() > 0)
    settingsPart.Settings.OfType<MailMerge>().First().Remove();

    // more code will go here later
}

Basically the “WordDocumentPath” variable there is a string representing the location of your word document file. This will open the file and find that settings XML file for us, and then if the MailMerge node already exists it will delete it. Now if you grab the C# inside the GenerateMailMerge() method of the productivity tools output and paste it in where the comment is in the above code, then add this line directly below to add your newly formed section into the document:

settingsPart.Settings.InsertAt(mailMerge1, settingsPart.Settings.Count());

So now that all that was done I tested it and when I opened the output word document I get an error about it being corrupted – dang. I had a look through the rest of the document XML files to see if anything else looked important, and there was one thing I did find that will stop this whole thing working if you don’t include it. If you grab a copy of your word document before the mail merge and the one after the mail merge and use the “Compare Files” function, you will see a list of all XML files in the package that have changed – the one that matters here is “/word/_rels/settings.xml.rels”. This defines relationships with other documents that are declared in the settings.xml file we were looking at earlier. If you have a look in the file by double clicking on it, you will see that there is an extra relationship tag that is defined there that points to your CSV file. Now here’s the trick – note the Id property of your relationship tag – now go and have a look back at the XML in the mail merge element, specifically at the <w:dataSource>  element – the Id here is the Id of the relationship tag! This is what is telling the package the location of your CSV file, despite the fact that it looks like the query tag above it does it, and without adding the relationship your merge wont work. Here is a code chunk to create a new relationship in that file:

foreach (var relationship in wordDocument.ExternalRelationships.Where(Rel => Rel.RelationshipType == "http://schemas.openxmlformats.org/officeDocument/2006/relationships/mailMergeSource"))
{
    wordDocument.DeleteExternalRelationship(relationship);
}
var dsRelationship = settingsPart.AddExternalRelationship("http://schemas.openxmlformats.org/officeDocument/2006/relationships/mailMergeSource", new Uri(string.Format("file:///{0}", CsvPath)));

Put that in directly below where the old MailMerge element is removed (so before the rest of the code you copied from the tool). Last but not least if you then look for the line of code you copied from the tool where it creates the DataSourceReference element and replace it with this, it will ensure the correct relationship is referenced as the documents data source.

DataSourceReference dataSourceReference1 = new DataSourceReference(){ Id = dsRelationship.Id };

So I saved and compiled all that and ran it – and it worked! I then ran it with a few different word document templates and they all worked with the same code too which was awesome. So there you have it kids, hopefully now you understand a bit about how the mail merge stuff works under the hood and you can now know that you can write this stuff up to automate more things for your users if you have to.

Looks like I am going to have my hands full leading up to Tech.Ed Australia this year. I’ve just had it confirmed that I will be presenting a second session at the event!

I’ll be presenting the second session with Garth Luke from AvePoint, and we will be discussing best practices with regards to storage and physical architecture of SharePoint 2010 deployments. Here is the official blurb:

SharePoint storage and physical architecture best practices
Brian Farnhill, Garth Luke
SharePoint 2010 makes significant improvements to how key architectural components in a farm and implemented and managed, which means appropriate consideration needs to be made when building your environments to get the most out of the new platform. In this session we will discuss some of these change, including what service applications are and how they work and can scale, as well as ways you can optimise the physical architecture of your farm. This will include discussing what remote blob storage is and how it can be implemented, how you can effectively monitor and report on the performance of your environment, and we will discuss how and why these best practices can be applied. If you are in to getting the most out of your infrastructure then this session is a must.

I’m really looking forward to presenting with Garth, make sure you come in and say hi to us at the event if you are going to be there!

SharePoint Saturday Sydney is coming together nicely, and today we have announced our speaker line up for this years event.  

Once again we have had an awesome group of people put their hands up to present for us, which did unfortunately mean that we couldn’t fit everyone in to the schedule, but I’m pretty impressed with the group of people we have together – they are all very passionate about SharePoint and great presenters!

We have also had a huge amount of interest from people wanting to attend the event as well – there has been over 75 registrations made already, and that was before we had announced who was speaking there! Keeping in mind that we have a bit over 80 people attend last years event I think this is a great sign. There are still a few over 40 tickets left, so its not too late to register to attend and be a part of our event.

Also, all attendees will score themselves one of these great looking compendiums! With the SP Saturday logo on the front, and notepad, pen and calculator inside this is a great little thing that you can use to take notes in sessions during the day and then take it home and use it later – and every single person who shows up on the day gets one for free!

Once again, I would like to thank all of our sponsors (check out the site for the up to date list) – without their sponsorship events like this simply couldn’t happen – I’m really looking forward to this one, and I hope to see you there!

For more info check out the site at http://www.sharepointsaturday.org/sydney or follow us on twitter @SPSSydney!

I’m really looking forward to giving this presentation, it’s the first time I’ve been chosen to present at a Tech.Ed so I’m very excited to be there. For more information on Tech.Ed you can check out the website at http://australia.msteched.com/, and if you don’t like paying full price for tickets, then you should check out your local Microsoft user groups – there is a user group discount ticket available (and it is the cheapest ticket you can buy at $1550 inc GST, which is the same price you get for booking 30+ people in one order!). We will be taking names to get this order at this month’s SharePoint user group here in Canberra, so make sure you get along if you want to get a cheap Tech.Ed ticket as well!

So first stop, I went back to the .webpart file that is created – the assembly name is up to date ebcause it is automatically generated at build time, but the type of the web part still had the old namespace reference, so this was the first place I needed to update it.

<metaData>
    <type nameMy_Project_Name.SilverlightWebPart.SilverlightWebPart, $SharePoint.Project.AssemblyFullName$" />
    <importErrorMessage>$Resources:core,ImportErrorMessage;</importErrorMessage>
</metaData>

Upon cracking open the WSP and having a look at the manifest, I could see that the assembly name was up to date, there as well, but again the type name for the safe control was wrong. To update this (as the manifest is automatically generated) I had a bit of a hunt around Visual Studio and found that if you select the web part feature node in the solution explorer and look in the properties window, there is a “Safe Control Entires” property, that you can select and then update the safe control entry that is added to the manifest so that it has the right info.

Once these had been changed I redeployed my web part and everything worked fine!

Hot on the heels of the announcement of SharePoint Saturday Sydney, we are announcing two more events! The first of which will be in Canberra September 18, followed by Melbourne on October 30.

I’m pretty excited to be able to add Canberra to our run this year, and its looking like all three events are going to be huge! We are still on the hunt for speakers and sponsors for all three events, so be sure to check out the sites (links below) for information on this.

Also, registrations for all three events are open right now, meaning you can register for them today to lock in your place at what are sure to be some very full events!

More information on the events can be found at SharePointSaturday.org:

• Sydney
• Canberra
• Melbourne

I really hope you can all make it, and be sure to follow the events on twitter as well to keep up with the latest information (@SPSSydney, @SPSCanberra, @SPSMelbourne).

For the purposes of this blog post I set up a basic sample to discuss, so my SQL database has only the following fields: id, firstName, lastName, email1Address, email1AddressType, email1DisplayName. I create an external content type and set up the list the same as you would for any other one, mapping those fields to the office fields of the same names. I hook this up to Outlook and when I look at my contacts, this is what I see:

Both of these contacts have an email address in the database, so I would expect to see it on the business card view here. If I open the contact up I can see the email address fields are all set correctly – when I go to close the contact though I am prompted to save it, and if I do the email address is then viewable on the business card.

At this point if I create a new email and type “gary someone” in to the to field I can press ctrl+k to automatically resolve his name, which is what I would expect. If I type “sam someone” though and do the same thing it won’t resolve and will make suggestions for me as to who I mean, and it won’t work until I open her contact and save it like I did with Gary’s.

The reason this is happening, is that there is a field called “Email Selected” that outlook stores for a contact (you can see it if you open the contact, go to the fields view and select “All Contact Fields”). This property seems to tell outlook what the default email address is (so if a contact has more than one, this is the email that will show when the contact is first opened), but if this isn’t set then the contacts name and email address can’t seem to be resolved.

The reason this is a big problem for me is that the “Email Selected” field can’t be mapped through the BCS, and only exists on the client side. So that means that if user A connects to the list, opens every contact to press save and close on them to fix it, when user B connects to the same list later on they will need to do the same thing. This is because the field is not synced back to the server at all.

The bigger problem here is that I don’t have a solution for this (I know I like to put solutions to problems out here on the blog, but at this point I don’t have one!). The ideal solution for me is some way to map that field through the BCS, because then it is within my control to be set to whatever I need it to be. At the moment though plan B is looking like some sort of script at the client side (possibly in another outlook add-in) that fixes the field for users when they open outlook or something like that.

If anyone else has come across this and has a work around I would love to hear it! Leave me a comment below with any info.