U2U all posts

When SharePoint Matters: OneResponse

Jan Tielens — Mon, 08 Mar 2010 20:52:00 Z

Two weeks ago I was in Iceland, talking about SharePoint 2010 at TM Software (some photos here :-) ). During the course, some students showed me a pretty cool public SharePoint 2007 site that they have been working on: OneResponse (http://oneresponse.info). OneResponse is the site the United Nations uses to collaborate and share information during catastrophes such as the recent earthquake in Haiti. Besides of the fact that the site is implemented really well, it must be pretty cool to know that your work will have such a big impact. Well done guys, it was a pleasure to be your guest!

Speaking at the Italian SharePoint Conference Next Week

Jan Tielens — Fri, 05 Mar 2010 11:15:00 Z

Next week on Wednesday and Thursday I’ll be in Milano, Italy during the SharePoint & Office Conference 2010. They have a nice lineup of both Italian and international speakers to deliver 60 sessions during three days. I’ll be presenting four of them:

Client Side Technologies in SharePoint 2010
Building, Deploying and Managing Sandboxed Solutions
Advanced Web Part Development in SharePoint 2010
Silverlight and SharePoint 2010: Better Together

So, please come and say hi if you’re on the SharePoint Conference in Italy next week!

How to play the Accordion - WPF Toolkit

Diederik Krols — Thu, 04 Mar 2010 16:35:00 -1300

The accordion is a musical instrument invented in Europe in the beginning of the 19th century. It produces music (or rather noise) by expanding and collapsing it while pressing buttons. This metaphor is applied to software: you may know the Accordion user interface control from Microsoft Outlook's navigation bar. In the last couple of years the control appeared in an ASP.NET AJAX implementation and a SilverLight implementation. Recently, the latter was ported to WPF and published as part of the February 2010 release of the WPF Toolkit. This article describes how to use this great WPF control.

Introduction

The Accordion is an ItemsControl that allows you to provide multiple panes and expand them one at a time (well, by default). The items shown are instances of AccordionItem. Clicking on a header will expand (actually 'select') or collapse the item's content. The Accordion class carries the usual responsibilities of an ItemsControl, like providing templates for header and content, and managing the selected items (plural, that is). On top of that, it supports the following extra properties:

SelectionMode: One, OneOrMore, ZeroOrOne, or ZeroOrMore
ExpandDirection: Left, Right, Up, or Down
SelectionSequence: Simultaneous or CollapseBeforeExpand [I'm pretty sure that this one doesn't work in the WPF version]

Hello World

Let's go for a first test-drive. Download the toolkit, create a new WPF project, and add the following two references:

xmlns:layoutToolkit="clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls.Layout.Toolkit"

Then drop the following code in the window:

<layoutToolkit:Accordion>
    <layoutToolkit:AccordionItem Header="Red">
        <Rectangle Fill="Red" Height="120" Width="200" />
    </layoutToolkit:AccordionItem>
    <layoutToolkit:AccordionItem Header="Orange">
        <Rectangle Fill="Orange" Height="120" Width="200" />
    </layoutToolkit:AccordionItem>
    <layoutToolkit:AccordionItem Header="Yellow">
        <Rectangle Fill="Yellow" Height="120" Width="200" />
    </layoutToolkit:AccordionItem>
    <layoutToolkit:AccordionItem Header="Green">
        <Rectangle Fill="Green" Height="120" Width="200" />
    </layoutToolkit:AccordionItem>
    <layoutToolkit:AccordionItem Header="Blue">
        <Rectangle Fill="Blue" Height="120" Width="200" />
    </layoutToolkit:AccordionItem>
    <layoutToolkit:AccordionItem Header="Indigo">
        <Rectangle Fill="Indigo" Height="120" Width="200" />
    </layoutToolkit:AccordionItem>
    <layoutToolkit:AccordionItem Header="Violet">
        <Rectangle Fill="Violet" Height="120" Width="200" />
    </layoutToolkit:AccordionItem>
</layoutToolkit:Accordion>

You end up with sir Isaac Newton's 7 colors of the rainbow:

The ExpandDirection property -unsurprisingly- changes the direction in which the items expand. Under the hood, a rotation transformation is applied to the header, so be careful when using images. This code:

<layoutToolkit:Accordion ExpandDirection="Right">

will transform our accordion like this:

In some applications you may want to open an item just by hovering over its header, instead of clicking. This behavior doesn't come out of the box, but it's easy to implement: just register a handler for the MouseEnter event for each AccordionItem:

private void AccordionItem_MouseEnter(object sender, MouseEventArgs e)
{
    AccordionItem item = sender as AccordionItem;
    item.IsSelected = true;
}

XAML

<layoutToolkit:Accordion ExpandDirection="Right">
    <layoutToolkit:Accordion.Resources>
        <Style TargetType="{x:Type layoutToolkit:AccordionItem}">
            <EventSetter Event="MouseEnter" Handler="AccordionItem_MouseEnter" />
        </Style>
    </layoutToolkit:Accordion.Resources>
    <layoutToolkit:AccordionItem Header="Red">

Deeper dive

I decided to build a test application (or torture chamber) to figure out whether or not the control is ready to be used in a production application. An Accordion is used a main navigation control, displaying more than just rectangles: a TextBox, a picture library inspired by the rainbow accordion, a control with a variable height (a TreeView), and a control that behaves badly in any WPF application (the WPF WebBrowser is just a thin wrapper around the IE ActiveX). Here are a couple of screenshots:

Sizing

In their default style, the accordion and its items only occupy the space they need, so smaller content also shrinks the headers:

That's why the main navigation accordion has its HorizontalAlignment set to Stretch. While the width of the main navigation accordion is fixed, its height will remain unpredictable - specifically if multiple items can be selected/expanded. A good old scrollbar will do:

By the way, the size of an item doesn't change dynamically. In our sample application, the expansion of treeview items will just add a scrollbar, not push down the accordion's headers:

Only when the same item is unselected and then reselected, the new height is applied:

The picture library needs a more predictable behavior (fixed height and width), otherwise you end up with unacceptable looks - like a shrunk accordion, or headers being pushed out of sight:

Here's how to deal with this:

<Style TargetType="Image">
    <Setter Property="Stretch" Value="UniformToFill" />
    <Setter Property="Height" Value="280" />
    <Setter Property="Width" Value="400" />
</Style>

Styling

The application is styled through the very popular WPF Themes, yet another port from SilverLight. Unfortunately the libraries don't contain styles for Toolkit controls (yet). The default styles for the Accordion are not really innovative - the selected item gets the same style as the selected date in a Calendar control:

So download the WPF Toolkit's source code, and copy-paste the relevant styles into a resource dictionary:

These are the relevant styles:

AccordionButton: displays the animated arrow in the header,
ExpandableContentControl: displays the item's content,
Accordion: displays the container,
AccordionItem: displays the item, basically a 2x2 grid, and
TransitioningContentControl: starts the animation when content changes.

Now you have access to the whole look and feel of the control. Just don't forget to register the resource dictionary in your XAML:

<Grid.Resources>
    <ResourceDictionary Source="Themes\CustomAccordion.xaml" />
</Grid.Resources>

Source Code

Here's the full source code of the sample project: U2UConsult.WPFToolkit.Accordion.Sample.zip (1,98 mb).

Enjoy !

Team System 2010: Easier project management with Team Project Collections

Peter Himschoot — Wed, 03 Mar 2010 12:39:59 -1300

Team System 2010 introduces the concept of team project collections (TPC). A team project collection is, as it says, a collection of team projects, which can be managed individually. You can backup, move, delete, etc… each collection individually. Each collection will also have its unique work item ids, check sets, etc… Team project collections also change the way team foundation stores its stuff. Before it would use a bunch of databases, now everything connected is stored in a single database. One database per collection. You can easily find the database because it’s called Tfs_<CollectionName>. You ‘ll also find the Tfs_Configuration database containing all configured project collections (and depending on your installation a database for the analysis services).:

Project collections also solve a problem some of you might have encountered; TFS 2008 has an upper limit of 255 team projects. Now with TPC you just add another TPC when you reach the limit (I don’t know the limit of projects per collection, but I would assume it would be around the same…).

A TPC can also easily be moved to another team server/farm, or to another SQL server on the same farm, as long as you keep it on the same type of SQL server (enterprise, express, …). Documentation states you cannot move it to another kind. The way to do this is to first open the Team Foundation Administration Console, and select the Team Projects Collections tree item. To the right you should see all your TPCs.

Here you can also create new TPC's, but that should be obvious.

So to move a TPC you should first stop the collection. You’ll be asked for a reason:

And then you detach the collection:

Next you go through a verification step:

And then you click Complete:

Now the TPC is no longer connected to TFS, but is still there in SQL server.

So now you detach the database in SQL server, move it to another SQL server or TFS farm. You might first need to restart a couple of services, such as the build service.

So after attaching the database in SQL server, we now need to attach the database to TFS; go back to Team Foundation Administration Console, and click the “Attach Collection” button. Now choose your SQL server instance, and you’ll see all candidate databases:

Hit Next if you want to change properties such as the name/description:

And next again to see an overview.

So complete attaching, hit Verify to make sure everything is in order:

And then hit attach.

Eh voila!

Now the TPC should be in the list:

You can also split the projects in a single TPC to multiple TPCs (but not merge them, so be careful), but that will be for a later post.

Referencing Javascript Files with SharePoint 2010 Custom Actions using SciptSrc

Jan Tielens — Mon, 01 Mar 2010 12:45:00 Z

If you’re an avid reader of this blog, you are probably aware of the fact that using Javascript plus SharePoint is a very powerful combination. In SharePoint 2007 there were a couple of techniques you could use to make sure your Javascript files would be referenced by SharePoint pages:

Add the Script reference to the Master Page
Use a Delegate Control (e.g. the AdditionalPageHead)
Dynamically through code, e.g. in a Web Part

Although all those techniques work, and will still work in SharePoint 2010, they all have some limitations. The first technique requires you to build a custom Master Page, which may be a little overkill just to get a Javascript file referenced. Additionally, your custom Master Page is not used on Application Pages (unless you use the Superbranding trick). The second is my favorite one in SharePoint 2007, but the requirement is that the Master Page you’re using has the corresponding Delegate Control, and you need to have either a Server Control or Web User Control that generates HTML to reference the script. The third technique is nice if you only want to use the script when the Web Part is on the page, otherwise you’ll have to put the Web Part on every page where you’d like to reference the script.

SharePoint 2010 is adding another very interesting technique to this list; using the ScriptSrc attribute of the CustomAction element in a Feature. Check the following Feature Elements file:

The first important thing to notice is that the CustomAction element contains the ScrptSrc attribute that points in this example to the jQuery Javascript library. The jQuery library is added to the /_layouts folder in the SharePoint Root, in a folder called JSDemo (the /_layouts/ prefix is added automatically). By the way, adding files to the /_layouts folder is very easy in a SharePoint project in Visual Studio 2010, using a Mapped Folder. The second important attribute is the Location; it must be set to ScriptLink so the Javascript file is referenced in the head element of the page. Optionally you can specify a Sequence attribute to determine the in which order the script references will be added (if you have multiple). When Feature is activated, it results in the following HTML:

document.write('<script type="text/javascript" src="http://weblogs.asp.net/_layouts/jsdemo/jquery-1.4.2.min.js?rev=EAku7lY97C3Kgrd9LPWhrg%3D%3D"></' + 'script>');

It’s important to mention that adding a reference to a script using this technique only works for scripts stored in the /_LAYOUTS folder in the SharePoint Root, so unfortunately it’s not possible to do something like this:

Besides the ScriptSrc attribute, you can also use the ScriptBlock attribute to render a script inline. The following example shows an annoying message box every time a pages load:

Unfortunately the ScriptSrc attribute doesn’t work very well in combination with Sandboxed Solutions: you can’t add files to the SharePoint Root using Sandboxed Solutions, and the ScriptSrc attribute requires the referenced script to be in the SharePoint Root’s /_layouts folder. I’m still figuring out a nice way to add for example the jQuery library to a SharePoint site, only using a Sandboxed Solution. If I’m successful, you’ll can definitely read more about it in a future post! :-)

Little SharePoint 2010 Gem: AJAX Options in List View Web Parts

Jan Tielens — Mon, 01 Mar 2010 07:06:00 Z

Last week I stumbled upon some pretty neat functionality of the out-of-the-box List View Web Part in SharePoint 2010: the AJAX Options. When you add a Web Part from the List and Libraries category (that basically shows you every List and Document Library you have on the SharePoint site) behind the scenes the Data View Web Part is being used to display the List or Document Library data.

When you edit such a Web Part once it has been added to a page, you’ll notice there is a new AJAX Options section in the Web Part properties. AJAX stands for Asynchronous Javascript and XML and is a web development technique to build more interactive, rich web sites. The AJAX Options are disabled by default, but by enabling you can get some pretty cool results:

Enable Asynchronous Update: enabling this option will make paging, sorting, filtering work without full page refreshes.
Show Manual Refresh Button: enabling this option will show an icon to allow the user the refresh the data manually, once again without refreshing the rest of the page.
Enable Asynchronous Automatic Refresh: when enabled, the Web Part will dynamically refresh the date it’s showing, without completely reloading the page. The interval can be specified in the textbox below.
Automatic Refreshing Interval: specifies the interval used in the previous option.
Enable Asynchronous Load: when enabled, the Web Part will initially be displayed without any data in it. But once the page is loaded, the Web Part will asynchronously fetch the data afterwards. When the data is being loaded, the Web Part will display an animation. This option will speed up the initial page load.

When being lazy is (finally) good

Peter Himschoot — Sun, 28 Feb 2010 15:50:19 -1300

In this blog post I want to talk about .NET 4 new Lazy<T> class. First of all, why would you need something called Lazy?

You can use it for data access for example; when you load a row from a database parent table. Would you need to load the child rows automatically, or delay until they’re required. Some systems will delay load automatically, or load all they can (but what then when the child rows have other relations to grandchild rows, etc…). This kind of delayed loading of data is just what Lazy<T> (or Lazy(Of T) when using VB.NET) supports.

It’s a great type to use when you have an object which is very expensive to create, and you only want to create it on first use.

Let’s start with an example; let’s say you have this big-ass class:

        1: class BigAndExpensive

       2: {

       3:   string s = "";

       4:  

       5:   public string GetTheData()

       6:   { 

       7:     return s; 

       8:   }

       9:  

      10:   public BigAndExpensive()

      11:   {

      12:     Console.WriteLine("BigAndExpensive is being created...");

      13:     for (int i = 0; i < 10000; i++)

      14:       s = s + ".";

      15:     Console.WriteLine("BigAndExpensive is finally created...");

      16:   }

      17: }

As you can see, creating is very expensive (it will actually consume about 10 Gb of memory, triggering a lot of garbace collects).

Let’s create an instance of this class without, then with Lazy<T> and look at the performance:

       1: BigAndExpensive be;

       2: Lazy<BigAndExpensive> lbe;

       3:  

       4: using (new MeasureDuration("Not using Lazy evaluation"))

       5: {

       6:   be = new BigAndExpensive();

       7: }

       8: using (new MeasureDuration("Accessing non-lazy object's method"))

       9: {

      10:   string s = be.GetTheData();

      11: }

      12: using (new MeasureDuration("Using Lazy evaluation"))

      13: {

      14:   lbe = new Lazy<BigAndExpensive>(false);

      15: }

      16: using (new MeasureDuration("Accessing lazy object's method"))

      17: {

      18:   string s = lbe.Value.GetTheData();

      19: }

      20: using (new MeasureDuration("Again accessing lazy object's method"))

      21: {

      22:   string s = lbe.Value.GetTheData();

      23: }

In order to use the Lazy<T> object you have to get it’s value property. When the lazy loaded value hasn’t yet been created, accessing the Value will create it.

The MeasureDuration class is a little timer taking advantage of the using statement:

       1: class MeasureDuration : IDisposable

       2: {

       3:   Stopwatch sw;

       4:   string what;

       5:  

       6:   public MeasureDuration(string what)

       7:   {

       8:     this.what = what;

       9:     sw = new Stopwatch();

      10:     sw.Start();

      11:   }

      12:  

      13:   public void Dispose()

      14:   {

      15:     sw.Stop();

      16:     Console.WriteLine("Measured duration of -{0}- took {1} ticks ({2} ms)"

      17:                      , what, sw.ElapsedTicks, sw.ElapsedMilliseconds);

      18:   }

      19:  

      20: }

The output I get on machine looks like this:

As you can see, creating a Lazy object is very fast, but of course as you can expect, using it the first time is just as expensive due to the creating process. Using it the second time is again very fast.

Now go back to the code, and look for the Lazy<T> constructor. Change the false argument to true:

       1: lbe = new Lazy<BigAndExpensive>(true);

This will make the instantiation process of the actual instance thread-safe. This means it will be a little slower, but only during construction. Is it worth the price? If you’re using multiple threads YES YES YES!

Now let’s try to see what happens when many threads access an unprotected Lazy object (never be lazy AND unprotected :))

This is the code:

       1: private static void UsingLazyObjectsFromMultipleThreads()

       2: {

       3:   Lazy<BigAndExpensive> createMeOncePlease = new Lazy<BigAndExpensive>(isThreadSafe:false);

       4:  

       5:   ManualResetEvent youMayBegin = new ManualResetEvent(false);

       6:   AutoResetEvent done = new AutoResetEvent(false);

       7:  

       8:   // create a lot of threads that will use our object all at once

       9:   for (int i = 0; i < 20; i++)

      10:   {

      11:     Thread t = new Thread(() =>

      12:       {

      13:         youMayBegin.WaitOne();

      14:         Console.WriteLine("Thread {0} getting data", Thread.CurrentThread.ManagedThreadId);

      15:         using (new MeasureDuration("Multithreading"))

      16:           createMeOncePlease.Value.GetTheData();

      17:         done.Set();

      18:       });

      19:     t.Start();

      20:   }

      21:   youMayBegin.Set();

      22:   // wait for all threads to complete

      23:   for (int i = 0; i < 20; i++)

      24:     done.WaitOne();

      25:  

      26: }

I’ve now used the named argument feature of C# 4.0. In this case it make the code a lot clearer doesn’t it?

So what does the code do. It creates 20 threads which all first wait for the “youMayBegin” event. This way all threads will start running at the same time. Then they each access the “createMeOncePlease” lazy instance, so some of them will start to create the instance (because it hasn’t yet been created). Then they will all signal that they’re done so the main thread can stop too.

So let’s run the code (making sure the isThreadSafe is set to false). I get this:

This is bad. Very bad. Instead of calling the constructor of my very expensive object once, it calls it several times. why?

Think about lazy’s possible thread-unsafe implementation:

       1: class Lazy<T> where T : class, new()

       2: {

       3:   T instance = null;

       4:  

       5:   public T Value

       6:   {

       7:     get

       8:     {

       9:       if (instance == null)

      10:         instance = new T();

      11:       return instance;

      12:     }

      13:   }

      14: }

When you run the if statement on multiple thread, each will evaluate to true, then each will create an object and overwrite instance’s value.

So what is the solution? Simply pass true for the isThreadSafe argument.

Running this code once more looks like this on my machine:

Good. My expensive object only get’s created once. But why are the calls soo expensive after all. That is because when we access Value, only one thread will be allowed to create the instance, but the other Value calls will need to wait for the first one to complete. If you insert another call using Value you’ll see the speed is very fast.

If you only need initialization to be thread-safe, or only access to the object in a thread-safe you you can also use the contructor taking a LazyThreadSafetyMode enumeration:

       1: None = 0,

       2: PublicationOnly = 1,

       3: ExecutionAndPublication = 2

What if your expensive class requires special construction, like a special constructor? Then you can use another constructor of Lazy<T>, one that takes a delegate( Func<T> ) so you can create your object your way.

       1: Lazy<BigAndExpensive> createMeOncePlease = 

       2:   new Lazy<BigAndExpensive>(() => new BigAndExpensive());

IntelliSense improvements in Visual Studio 2010

Peter Himschoot — Tue, 23 Feb 2010 22:06:51 -1300

What developer today can live without intelli-sense? Of course I mean developers who have used intelli-sense before (if you don’t know something how can you miss something?). However finding a member in Visual Studio 2008 requires you to know the first letters of the class/method/… I’m quite sure you sometimes now a class contains a certain word, but can’t remember the beginning.

Now the new and improved intelli-sense in Visual Studio 2010 allows you to see any member containing a certain substring. For example when you type “opt”, you’ll get this:

But it even gets better. Try typing “AD”. Because .NET uses Pascal casing for all members, when you type the capital letters it will show you which members contain these same capital letters (and same order):

Love it! This also works in other places, for example in the Navigate To window!

With following code,

        1: class WebDeveloper

       2: {

       3: }

       4:  

       5: class Program

       6: {

       7:  

       8:  

       9:   static void Main(string[] args)

      10:   {

      11:     WebDeveloper dev1 = new WebDeveloper();

      12:  

      13:   }

      14: }

opening the Navigate To window (use Ctrl-comma for example, and typing WD in the search box will show like this:

Oh, and selecting the WebDeveloper class will automatically highlight every other use of it:

Cool!

And don’t you hate it when you start typing a method name you haven’t declared yet. By default Visual Studio will list a couple of suggestions, and when you commit (by pressing space of “(“) Visual studio inserts its own suggestion (and then you need to Undo (Ctrl-Z) to make Visual Studio keep whatever you were typing.

So for example, when you have a variable s of type string, and then you type s.c intelli-sense will show the following. If you now press space, by default you’ll get s.Clone.

But now you have auto-completion suggestion mode. In this case Visual Studio will not insert its own suggestion, but will keep your typing instead.

If you do want to insert the suggested method, simply press TAB instead of space of open bracket. From now on this will be my default mode of working…

Las Vegas MIX’ing at Microsoft together with BESUG

kevin derudder — Mon, 15 Feb 2010 15:11:19 -1300

MIX 2010 must be one of the best events Microsoft organizes for web folks. Since not everyone can make it to Las Vegas for this we at Microsoft Belgium together with the Belgian Silverlight User Group have a solution for you. We will organize a live keynote streaming on a big screen in a cool Vegas style. Expect a live intervention from some Belgians at MIX and cool prizes to be won.

What’s on the agenda:

16h30 – Welcome
17h00 – 19h00 – Live keynote streamed from Las Vegas – don’t miss the announcements
19h00 – Break
19h30 – Live feed to some Belgians at MIX…
20h00 – American style light dinner
21h00 – Poker evening, prize draw

So hope to invite you all, please subscribe on following link

Visual Studio 2010 Release Candidate is available via MSDN sub download

Peter Himschoot — Sun, 07 Feb 2010 23:21:06 -1300

Download VS2010 RC here.

And soon available for everyone tomorrow!

Gated Check In with Multiple Build Definitions

Peter Himschoot — Fri, 05 Feb 2010 03:35:00 -1300

As promised in my previous blog on Gated Check In, in this blog I’ll discuss using multiple builds with gated check in.

So what happens when you check in (using gated check in) and there are multiple build definitions targeting the solution? Well, Gated Check In will then allow you to choose between the different build definitions; for the moment Team Build does not allow you to filter the build definitions that are shown:

In my example I’ve created a second build definition that doesn’t run tests, so you can select this one when you need to check in code without running tests…

Never break a build again with the new Gated Check-in feature from Visual Studio Team System 2010

Peter Himschoot — Thu, 04 Feb 2010 12:11:42 -1300

Breaking the current team build is not a good thing. This will cause many people to lose time while the build is being fixed. So how can you avoid this? One way is by only checking-in on isolated branches, which allow you first to test if everyone’s changes build together.

But, remember that Team System Source Control has that one-click branching feature, called shelving? Well, now if you check in VSTS can take your changeset and merge it on a shelve with the current version in source control. It will then launch a build (using Team Build) and if this is a successful build (depends on the build) will allow you to check-in.

Let’s have a look at this:

To try this you first have to have something in Source Control. For example this simple library project and class:

        1: namespace Lib

       2: {

       3:   public class Code

       4:   {

       5:     public int Test(int i, int j)

       6:     {

       7:       return i + j;

       8:     }

       9:   }

      10: }

I’ve also added two unit tests in a test project:

       1: [TestMethod()]

       2: public void Test_2And3_Returns5()

       3: {

       4:   Code target = new Code(); 

       5:   int i = 2;

       6:   int j = 3;

       7:   int expected = 5;

       8:  

       9:   int actual;

      10:   actual = target.Test(i, j);

      11:   Assert.AreEqual(expected, actual);

      12: }

      13:  

      14: [TestMethod()]

      15: public void Test2And4Returns10()

      16: {

      17:   Code target = new Code();

      18:   int i = 2; 

      19:   int j = 4; 

      20:   int expected = 6; 

      21:   int actual;

      22:   actual = target.Test(i, j);

      23:   Assert.AreEqual(expected, actual);

      24: }

Make sure all of this is currently checked in.

Now go to Team Explorer, right-click on Builds and choose “New Build Definition…” The Build Definition dialog should open. Call your build GatedCheckIn (although the name doesn’t matter, I’ll be using it later).

Now go the the Trigger tab; here is where the new Gated Check-in can be selected:

Next go to the Workspace tab, and select the folder containing your solution (both the library and test projects).

Next come Build Defaults, the usual (you might need to create a shared folder so you can map to it here; make sure the Build Service account can access it):

I’ve left everything in the Process tab to its default value, but you might want to double check the Automated Tests. Team Build will run all tests in all assemblies whose name contains test.

Also note the Fail Build On Test Failure setting; you can change it to true to ensure nobody can check-in with failing tests.

If you’re using the Layer Diagram, you can also validate it during the build.

And finally Retention Policy, where you can choose whatever you like.

Close the window and save your changes.

You might want to test your build definition by queuing it. It should work:

Ok, now let’s make a change to our code that would break the build by failing one on the tests:

       1: namespace Lib

       2: {

       3:   public class Code

       4:   {

       5:     public int Test(int i, int j)

       6:     {

       7:       return i - j;

       8:     }

       9:   }

      10: }

I’ve simply changed to + sign into a – sign.

Now open the Pending Changes window and click the Check In button. The Gated Check-in dialog should appear:

Note the Shelveset and Build definition. If you have more than one build definition, things change, we’ll look at this later.

Also note the Preserve my pending changes locally. This works exactly the same way as normal shelving, so if you leave it checked, your changes are left on your machine. If the build fails, everything is the same. If you uncheck it, your changes will be shelved, but then you will have to make sure you reconcile back with the server’s version after the check in succeeds.

Ok, Click the Build Changes button. A build should start. Open the Build Explorer if it doesn’t do so automatically:

The tests failed, so TFS decides that the check in failed:

Change the code back to use the + sign. Check In. This should now succeed.

Now this really become interesting if two developers check-in conflicting changes. We can emulate this using two workspaces. So I’ve setup another workspace mapped to the same project. To do this, go to Source Control Explorer and open the Workspace: drop-down list:

Select Workspaces…, this should open the Manage Workspaces dialog (you will have other names for any workspaces you might already have):

Now pick a name, and in the Working Folders select your project mapping, one for the server, one for on your disk. For example:

Then get all files locally (TFS will suggest this anyway). To switch between the workspaces you simply select it from the “Workspace:” dropdown list.

In one workspace rename the Test method in the Code class to Add. Use the Rename feature to ensure all references are renamed as well… Run all tests, they should succeed. Don’t check in yet.

Open your solution in the other workspace. Change the implementation of the Test method like this:

       1: public class Code

       2: {

       3:   public int Test(int i, int j)

       4:   {

       5:     if (j == 4) j = 8;

       6:     return i + j;

       7:   }

       8: }

And change the unit tests as well:

       1: [TestMethod()]

       2: public void Test2And4Returns10()

       3: {

       4:   Code target = new Code();

       5:   int i = 2; 

       6:   int j = 4; 

       7:   int expected = 10; 

       8:   int actual;

       9:   actual = target.Test(i, j);

      10:   Assert.AreEqual(expected, actual);

      11: }

Run all tests. They should succeed. Then check In. A build should start. While that is running check in your other changes (other workspace). Because your first check in is still running you shouldn’t see any conflict with your other changes. Actually, both builds should work, because the second build will merge the first build’s changes in the workspace, and they auto-Merge…

Let’s try to really break it now. In one workspace add another method to call the Add method (reconcile the workspace first, or do a recursive get-latest version):

       1: public class Code

       2: {

       3:   public int Add(int i, int j)

       4:   {

       5:     if (j == 4) j = 7;

       6:     return i + j;

       7:   }

       8:  

       9:   public void OtherMethod()

      10:   {

      11:     int x = Add(3, 2);

      12:   }

      13: }

Then in the other workspace rename the Add method again. Check this workspace in, then the other workspace. Because the extra method doesn’t get the Add method renamed, the build will break:

Merge your code with the current check in code, and retry. This should now succeed.

The Missing Linq to SQL Spatial

Diederik Krols — Sun, 31 Jan 2010 19:48:00 -1300

This article provides hints and hacks on how to use the SQL Server spatial data types -Geography and Geometry- in Linq to SQL. The data provider has a problem with serializing and deserializing the SQL UDT's. If you ever tried to use these data types in a Linq to SQL (or Entity Framework) project then you certainly encountered the following error: “One or more selected items contain a data type that is not supported by the designer”.

Setting up a test environment

I created a small database called 'Spatial' with a schema called 'Europe', and a table called 'Countries'. Here's the structure of the table:

CREATE TABLE [Europe].[Countries](
    [CountryID] [int] IDENTITY(1,1) NOT NULL,
    [CountryName] [nvarchar](50) NOT NULL,
    [Shape] [geography] NOT NULL,
 CONSTRAINT [PK_Countries] PRIMARY KEY CLUSTERED 
(
    [CountryID] ASC
)

The source code that accompanies this article contains the scripts to create the assets and populate the table. Here's an indication of the table contents:

I created a Visual Studio 2008 Console application, and added a reference to Microsoft.SqlServer.Types. Then I added Linq to SQL classes (Europe.dbml). When I dropped the Europe.Counties table into the designer, the result was the expected error message:

Hint 1: Use views that cast the data type

I decided to create a view in the schema: vw_Countries. It exposes the same signature as the table, but with one difference: the shape column is returned as Varbinary(MAX) instead of Geography:

CREATE VIEW [Europe].[vw_Countries]
AS
SELECT CountryID
      ,CountryName
      ,CONVERT(VARBINARY(MAX), Shape) AS Shape
FROM Europe.Countries

The Geography UDT is physically stored as Varbinary(MAX) in SQL Server, so the table and the view are basically the same. There's one important difference though: Visual Studio is not allergic to the view. You can easily drag and drop it into the data model designer:

The Linq data provider delivers the varbinary data as System.Data.Linq.Binary, but is -strangly enough- unable to convert this back to SqlGeography. It took me a while to figure out the conversion myself, but here's a working version:

Binary belgiumb = (from c in db.vw_Countries
                   where c.CountryID == 4
                   select c.Shape).FirstOrDefault();
SqlGeography geo = new SqlGeography();
geo.Read(new System.IO.BinaryReader(new System.IO.MemoryStream(belgiumb.ToArray())));

Hint 2: Package your conversion code

We're going to get stuck with this type of conversions for a while, so it makes sense to wrap the calculations e.g. in extension methods. Here's an example:

/// <summary>
/// Converts a Linq Binary to a SQL Server Geograpy.
/// </summary>
/// <remarks>Throws an Exception if the Binary contains invalid data.</remarks>
public static SqlGeography AsGeography(this Binary binary)
{
    if (binary == null)
    {
        return SqlGeography.Null;
    }
 
    SqlGeography result = new SqlGeography();
 
    result.Read(
        new System.IO.BinaryReader(
            new System.IO.MemoryStream(
                binary.ToArray())));
 
    return result;
}

So now I can call it like this:

SqlGeography b = (from c in db.vw_Countries
                  where c.CountryID == 4
                  select c.Shape).FirstOrDefault().AsGeography();
Console.WriteLine(" The area of Belgium is {0} m²", b.STArea().Value);

Hack 1: Change source mappings

I wanted to execute my queries directly against the table. So I copy/pasted the view in the dbml, and modified the source mapping:

Now I can call the queries like this:

belgium =
    SqlGeography.Parse((from c in db.Countries
                        where c.CountryID == 4
                        select c.Shape.ToString()).FirstOrDefault());

Hack 2: Change data type mappings

Since I wanted IntelliSense, I copy/pasted the Country table again, and changed the .NET type of the Shape property to SqlGeography:

The good news is: I now have IntelliSense at design time:

The bad news is: I will have exceptions all over the place.

If you return a spatial data type in the select, then a query is successfully constructed and sent to SQL Server, but the return values cannot be deserialized. Here's such a query:

belgium = (from c in db.Countries2
           where c.CountryID == 4
           select c.Shape).FirstOrDefault();

It results in a runtime exception:

If you call a method -apart from ToString()- on a spatial data type in the where-clause, then you'll bump into a NotSupportedException already at compile time. Here's such a query:

var query = (from c in db.Countries2
             where (c.Shape.STArea() > 10).Value
             select c.CountryName).FirstOrDefault();

And its result at compile time:

Intermezzo

I tried to use Varbinary as data type for the _Shape backing variable, and SqlGeography as data type for the Shape property, and call conversions in the getter and setter. It didn't work: the getters and setters seem to be bypassed by the Linq provider.

Conclusion: hack 2 was not a good idea. We'll stop using the Countries2 entity...

Hint 3: Use scalar functions

Since STIntersects cannot be used, I created a scalar function that takes two Well-Known Texts, and returns whether or not the shapes intersect:

CREATE FUNCTION [Europe].[Intersects]
(
    @Shape1 NVarchar(MAX),
    @Shape2 NVarchar(MAX)
)
RETURNS integer
AS
BEGIN
 
    DECLARE @Geo1 Geography = geography::Parse(@Shape1)
    DECLARE @Geo2 Geography = geography::Parse(@Shape2)
 
    RETURN @Geo1.STIntersects(@Geo2)
 
END

Again, Visual Studio's designer has no problem with this, so you can drag and drop the function into the DataContext:

So you can use it in your queries:

var query = from c in db.Countries
            where db.Intersects(c.Shape.ToString(), belgium.ToString()) == 1
            select c.CountryName;

The response time seems to be good enough against such a small table. But I know that it is never a good idea to call functions in the where-clause of a query. It will force a table scan and an evaluation of the function for each row in the table. If you can live with the performance, then I suggest you just stick to this type of functions: they're highly reusable since they don't contain any hard-code table names.

Hint 4: Use table valued functions

If your geographical tables get bigger, it makes sense to define table valued functions or stored procedures to do the heavy lifting. The following example doesn't mask the usage of STIntersects in the where-clause, and may let SQL Server decide to use a spatial index (or you may even use a hint):

CREATE FUNCTION [Europe].[Intersectors]
(   
    @Shape NVarchar(MAX)
)
RETURNS TABLE 
AS
RETURN 
(
    SELECT CountryID, CountryName
    FROM Europe.Countries
    WHERE Shape.STIntersects(geography::Parse(@Shape)) = 1
)

And yes: I do realize that Intersectors probable doesn't appear in a regular dictionary...

Here's how a call to it looks like in Linq - we still have IntelliSense:

var query = from c in db.Intersectors(belgium.ToString())
             select c.CountryName;

I couldn't keep myself from comparing the performance of the two functions. When I checked the actual query plans,my jaw hit the ground , ouch! Completely against my expectation, the cost of the table value function was higher than the cost of the scalar function. And not just a little bit, but 5 times higher:

Anyway, you should never blindly base your conclusions on just the query plans, so I started the SQL Profiler to inspect reality. After thorough testing I was relieved . I observed that the tabled valued function easily outruns the scalar version: it consumes between 3 and 8 times less CPU and returns the results 5 to 10 times faster. This is actually an impressive difference for such a small table. Here's the result from a test session (scripts are included in the source code):

A negative aspect of this table valued function is its reusability: the function only works against the Europe.Countries table. If you need to query more tables with spatial data, then you need to add complexity to it, or start copy/pasting.

Conclusions

The current Linq to Sql provider doesn't support the SQL Server spatial data types properly, so you have to be creative if you want or need to use these. It's not a waste of time to invest some effort in implementing the work arounds I suggested, and in optimizing and performance tuning these. Your solution will last for a while, since there seems to be no Microsoft solution on the horizon. The problems are not solved in SQL 2008 R2, Visual Studio 2010, or .NET 4.0.

Source code

Here's the source code for the test program. It also contains the necessary SQL scripts for creating and populating the entities, as well as for testing and performance tuning: U2UConsult.DockOfTheBay.LinqToSpatialSample.zip (153,76 kb)

Here's how its output should look like:

Credits

I would like to thank my colleague Kris Vandermotten for his input during the research.

Hiding / Showing Jump Lists in windows 7

Peter Himschoot — Fri, 29 Jan 2010 07:03:21 -1300

The jump list feature in Windows 7 makes it really easy to find the documents you were working on for each application. Just go to the taskbar and right-click the application. If your application has been enabled for jump lists (and they should, it is really easy to enable this using some API’s) then you should see a list of recently opened items. One day I started noticing I didn’t have any jump lists any more. Luckily the problem is easy to fix. Open your taskbar properties and go to the Start Menu tab. Check the “Store and display recently opened items in the Start menu and the taskbar” you you should get them back. I must have disabled this by accident…

Converting Spatial Coordinates with Proj.NET

Diederik Krols — Thu, 28 Jan 2010 20:52:00 -1300

In my previous article I expressed some disappointment in the usefulness of the Map Projections in SQL Spatial Tools on CodePlex. There's not much you can do with these in a real-life application. Fortunately there's also Proj.NET on CodePlex, a flexible advanced point-to-point coordinate conversion engine that is used internally by a lot of open source GIS projects.

Here's a small fraction of its object model:

Geographic Coordinate Systems

The only predefined geographic coordinate system is WGS84:

ICoordinateSystem gcs_WGS84 = GeographicCoordinateSystem.WGS84;

But you can easily create your own, from Well-Known Text (WKT) or through the object model:

string wkt_WGS84 =
    "GEOGCS[\"GCS_WGS_1984\"," +
         "DATUM[\"D_WGS_1984\",SPHEROID[\"WGS_1984\",6378137,298.257223563]]," +
         "PRIMEM[\"Greenwich\",0]," +
         "UNIT[\"Degree\",0.0174532925199433]" +
    "]";
ICoordinateSystem gcs_WGS84 = CoordinateSystemWktReader.Parse(wkt_WGS84) as ICoordinateSystem

Projected Coordinate Systems

The only predefined projected coordinate system is UTM:

IProjectedCoordinateSystem pcs_UTM31N = ProjectedCoordinateSystem.WGS84_UTM(31, true);

But again, you can easily create your own, from WKT or through an object model. Here's how Lambert 2008 -a local Belgian projection- looks like:

string wkt_Lam08 =
    "PROJCS[\"ETRS89 / Belgian Lambert 2008\"," +
        "GEOGCS[\"ETRS89\"," +
            "DATUM[\"European Terrestrial Reference System 1989\"," +
                "SPHEROID[\"GRS 1980\",6378137.0,298.257222101," +
                    "AUTHORITY[\"EPSG\",\"7019\"]]," +
                "TOWGS84[0.0,0.0,0.0,0.0,0.0,0.0,0.0]," +
                "AUTHORITY[\"EPSG\",\"6258\"]]," +
            "PRIMEM[\"Greenwich\",0.0," +
                "AUTHORITY[\"EPSG\",\"8901\"]]," +
            "UNIT[\"degree\",0.017453292519943295]," +
            "AXIS[\"Geodetic latitude\",NORTH]," +
            "AXIS[\"Geodetic longitude\",EAST]," +
            "AUTHORITY[\"EPSG\",\"4258\"]]," +
        "PROJECTION[\"Lambert Conic Conformal (2SP)\"]," +
        "PARAMETER[\"central_meridian\",4.359215833333335]," +
        "PARAMETER[\"latitude_of_origin\",50.79781500000001]," +
        "PARAMETER[\"standard_parallel_1\",49.833333333333336]," +
        "PARAMETER[\"false_easting\",649328.0]," +
        "PARAMETER[\"false_northing\",665262.0]," +
        "PARAMETER[\"standard_parallel_2\",51.16666666666667]," +
        "UNIT[\"m\",1.0]," +
        "AXIS[\"Easting\",EAST]," +
        "AXIS[\"Northing\",NORTH]," +
        "AUTHORITY[\"EPSG\",\"3812\"]]";
IProjectedCoordinateSystem pcs_Lam08 =
    CoordinateSystemWktReader.Parse(wkt_Lam08) as IProjectedCoordinateSystem;

The list of supported projections includes Mercator, Transverse Mercator, Albers, Lambert Conformal, and Krovak.

If you download the project's source code, you'll also discover an SRIDReader class that allows you to instantiate a coordinate system from nothing more than its Spatial Reference ID.

Transformations

A coordinate conversion can be defined and called through the API as follows:

CoordinateTransformationFactory ctfac = new CoordinateTransformationFactory();
ICoordinateTransformation trans = ctfac.CreateFromCoordinateSystems(gcs_WGS84, pcs_UTM31N);
double[] fromPoint = new double[] { 4.296545, 50.880324 };  // U2U Consult Head Office, in degrees
double[] toPoint = trans.MathTransform.Transform(fromPoint);

If you're lucky, then you also get the inverse transformation, but it's not always implemented.

try
{
    IMathTransform inversedTransform = trans.MathTransform.Inverse();
    double[] point = inversedTransform.Transform(toPoint);
}
catch (NotImplementedException ex)
{
    // Your exception handling here...
}

Test Client

Here are U2U Consult's Headquarter's coordinates:

I built a small test client that applies some transformations on these (WGS 84 - UTM - Lambert 1972 - Lambert 2008). Here's how the result looks like:

For the sake of completeness: here's the full source code: ProjNetClient.zip (38,93 kb)

Techdays 2010

Peter Himschoot — Tue, 26 Jan 2010 10:46:39 -1300

I’m happy to say I’ll be speaking at TechDays 2010 in Belgium and DevDays 2010 in the Netherlands.

In Belgium I’ll be doing one session on “What is new in WCF 4” and one session on “Workflow Foundation 4”.

In the Netherlands I’ll do on session on “What is new in WCF4” and one on “Developing for Windows 7 with the Windows API code pack”.

Planning, Running and measuring tests with Visual Studio 2010 Ultimate and Test and Lab Manager

Peter Himschoot — Sun, 24 Jan 2010 02:27:24 -1300

So what does Visual Studio 2010 bring for testers? A whole lot! Especially the new test environment, where you can create a test plan to validate the quality of the software you’re building. A test plan is a collection of test cases, which you can then run. While running the system keeps track of a whole lot of things, including code coverage and IntelliTrace information. And finally this application allows you to examine the combined results of all tests, to see how your development effort is doing.

So again: A test plan is a collection of test suites, used to test a certain iteration in your project. A test suite is a collection of test cases to test a certain part of your project, and a test case is a test for a project feature. A test case is basically an UI test running in a specific environment. To model this, Test and Lab manager also allows you to define a test configuration, which is a certain environment for your code, for example Windows 7 with IE8, or Windows XP SP2 with IE7.

Running Test and Lab Manager

First time you run this application it will ask for your Team Foundation Server (TFS) and after that, for the Project Collection and Team Project:

Ok, next step it will ask you for a test plan; since there are none you will have to create a new one:

Then click “Select plan >”.

This opens the test plan.

if you want you can change some of the properties of this test plan by clicking on the properties tab:

Here you can change the iteration for example, or the test settings.

With test settings you can change how your tests will be executed. For example in the Local Test Run settings you can change the diagnostic data adapter, which record data from your test run. For example is you want an action recording, event log entries, etc… You can also use it to emulate certain environments, for example running low on memory. You can even create your own data adapter.

This first page allows you to change the name, and choose between running a manual or automated test.

On the second page you can define the roles. You define a role for each tier to use to run tests and collect data. One the local settings you can only have one role, your own physical machine. If you want to use roles, you will also have to define environments.

Here you can define what kind of data you want to gather. For example, the Action Recording will record each action taken during the test, making it easy for another person (typically a developer) to understand what happened during running the test. The Action log is a text version of the recording. IntelliTrace will allow a developer to load the IntelliTrace log and step back in the code, to see how the error came to be.

Go back to the Contents tab.

Now we’re ready to test some of our user stories (from now on I will be using User Stories, but this could just as easily be called a requirement or anything else to denote a certain needed functionality of your software system). Test cases are grouped into test suites. Per test plan you have a default test suite, but you can also create a test suite for a specific user story, copy a test suite from another test plan, create a nested suite or create one from a query:

If you select “Add requirement"to plan” you will need to select a user story. This user story is now associated with this test suite. This will allow reporting to figure out which tests have ran for which user story.

Now we’re ready to add a test case, so click the New button. The New Test Case dialog should show:

Add the four steps (please note that we’re doing this for the sake of the demo, normally your requirement should not be to crash :) ). Save it.

Click on the Tested User Stories tab: the User Story should be there. Save and Close.

A couple of other things you can now do is to assign it to a tester, and/or change the configurations:

Let’s run the test. First open the Test tab:

From here you can see all test cases for a test suite:

Select the test case and click on the run button. The Test Runner should open:

Check the Create action recording button and hit Start Test. Do as the test case says, and try to use a repeatable way to start the application (for example using the start menu). The first and second step should not be a problem, so click the drop down boxes to the right of each step to indicate success:

Now make the third step fail. You’ll need to enter a comment why it failed. Then click the End Test hyperlink button. You’ll see test center gather some information.

On top of the test runner window you’ll see a toolbar. Click on the Create Bug button:

You’ll see that most of the fields are automatically filled in. You might want to change the Severity for example, and maybe assign it to a certain tester, but that is all… Click Save. Check out the information included in the System Info, and All Links tab. Close it.

Remember me asking you to start the application using some repeatable way? Well, try and click on the play button. Your test should replay again. This makes it easier to re-test later.

Coming back to Test and Lab Manager. The test case failed so now the UI updates to show this:

If you have more than one test, the bar will color depending on how many succeeded, failed or are still in progress.

Later you can come back and verify if a bug still exists by using the Verify Bugs tab:

Go back to the Plan tab, then open the properties. Now you should see an overview:

Back to Visual Studio, so close the Test and Lab Manager. Go to the Team Explorer and open the My Bugs query. You should see the bug we created before. Open it:

Go to All Links, and open the IntelliTrace log (.tdlog). With it you can now replay the bug, just like in my previous post on IntelliTrace. If this doesn’t work, go back to the test settings. You might also like the Video feature, so you can replay the user’s actions!

Using the WPF Visualizer in Visual Studio 2010

Peter Himschoot — Sat, 23 Jan 2010 21:18:02 -1300

Visual Studio 2010 now has a cool little feature I want to show you. When you’re debugging WPF applications, you sometimes need to see the controls and their hierarchy. Now with VS2010 this is easy. Simply use the magnifying class (the visualizer feature) and select the WPF Tree Visualizer:

This will show you all the controls with their properties like this:

In the left pane you get the tree view of controls with a rendering of the selected control, at the right side you get all properties of the control.

Service oriented architecture in SQL Server with Service Broker

Nico Jacobs — Wed, 20 Jan 2010 12:01:25 -1300

Wouldn’t it be nice if a stored procedure could run certain statements in parallel, if we could easily scale out SQL Server applications,… When you have code that can run asynchronously, all these things become possible, if you implement them with the Service Broker: Service Broker is an service oriented framework build into SQL Server 2005, and has been extended in SQL Server 2008. If you want to see how to implement code in this framework, and what Service Broker can do for you, come to my talk at the next Belgian SQL user group meeting on February 11. Checkout www.sqlug.be for free but required registration.

SharePoint Connections 2010 & SharePINT with Belgian Beer in Amsterdam

Jan Tielens — Thu, 14 Jan 2010 06:44:00 Z

Next week (18th and 19th of January, 2010) the Microsoft SharePoint Connections 2010 will be held in Amsterdam RAI (The Netherlands). There is a great lineup of speakers and sessions over there, so I'm sure it will be a very interesting event! I will be presenting three sessions, one on Monday and two on Tuesday:

Client-Side Technologies in SharePoint 2010
Silverlight and SharePoint 2010: Better Together
Advanced Web Part Development in SharePoint 2010

I'm also very proud to mention that U2U will be sponsering the SharePINT community event on Monday evening. As a Belgian company we are of course buying you guys some real Belgian beer (Leffe)! So make sure to visit the expo area of the conference after the last session on Monday and feel free to say hi. :-)

Besug new years drink

kevin derudder — Tue, 12 Jan 2010 00:22:30 -1300

For those who forgot it, tonight Frederik and I invite for our Silverlight user group new years drink. Please check the besug site for more details.

There will be some silverlight, geek or normal talking with a glass of beer, wine or whatever you like, which is totally for free.

SQL Spatial Tools: Map Projections

Diederik Krols — Sun, 10 Jan 2010 08:30:00 -1300

SQL Server Spatial Tools on CodePlex contains useful extra functions for the SqlGeometry and SqlGeography data types, as well as a new data type for affine transformations (to scale, translate, and rotate) and a handful of Map Projections. This article describes how to use these projections and visualize the result in Windows Presentation Foundation.

All projections are instantiated from static method calls against the SqlProjection class, with one to five parameters. SQL Spatial Tools contains sample T-Sql scripts, but here's how it looks like in C# (for the inverse projection, don't forget to first assign a Spatial Reference System Identifier to the geometry):

Projection

SqlGeography shape3D = new SqlGeography();
shape3D = SqlGeography.Parse("some valid WKT"); // Or read from DB
SqlProjection proj = SqlProjection.LambertConformalConic(0, 90, 12, 36);
SqlGeometry shape2D = proj.Project(shape3D);

Inverse Projection

SqlGeometry shape2D = SqlGeometry.Parse("some valid WKT");
shape2D.STSrid = 4326; // WGS 84
SqlProjection proj = SqlProjection.AlbersEqualArea(0, 0, 15, 30);
SqlGeography shape3D = proj.Unproject(shape2D);
 
That's all there is to!
 
I added this code to an improved version of my SqlGeometry Extension Methods for WPF Visualization. Here's how the resulting application looks like, displaying a reduced shape of Belgium, and the exact location of my office @ U2U Consult: 
 

OK, I admit: projecting Belgium is not that spectacular. It will have the same shape in virtually every projection: it's a small surface on an average latitude.

So let's apply some transformations on a more representative victim such as the Tropic of Cancer. This will generally be projected as a straight line, but if you stand on the North Pole -e.g. via a Gnomonic Projection- it looks like a circle:

And with a Transverse Mercator projection it should look like an Ellipse:

Unfortunately the SQL Spatial Tools code only implements the Spherical version of the Transverse Mercator projection, and not (yet ?) the Ellipsoidal version. Otherwise SQL Spatial Tools would have all the ingredients for a latitude/longitude WGS84 to UTM conversion. After all, you only need to project, then scale (to convert to meters), and finally translate (for false easting). This is a horrible calculation, but don't worry: Proj.NET on CodePlex should be able to handle this (this feels like a topic for a later article).

Anyway, here's the full solution: U2UConsult.DockOfTheBay.SpatialProjectionsSample.zip (144,07 kb).

Tuning SQL Server Lookups to a Linked Server

Diederik Krols — Sat, 09 Jan 2010 04:04:00 -1300

In SQL Server, if you join a local table with a table on a linked server (e.g. a remote Oracle instance) you should be prepared for horrible performance. In a lot of scenarios it makes a lot more sense to tell the remote server exactly what you need, store that data in a temporary table, and join locally with it. A couples of weeks ago I used this technique to bring the response time of some queries from SQL Server to a linked Oracle instance down from 500 seconds to less than one second.

Let's say we want to enumerate the countries that use the Euro as currency, like this (in AdventureWorks2008):

    SELECT c.CurrencyCode, r.Name
      FROM Sales.CountryRegionCurrency  c
INNER JOIN Person.CountryRegion r
        ON c.CountryRegionCode = r.CountryRegionCode
     WHERE c.CurrencyCode = 'EUR'

Here's the result:

Let's suppose that the names of the countries are in a separate database (e.g. an Oracle on an AS/400 box), and there's no replication in place. From SQL Server, we can get access to that source by defining a linked server. For demonstration and practical purposes -I don't have a portable AS/400 with Oracle on it- I'll create a linked server to the local SQL instance:

execute sp_addlinkedserver '.'

The distributed query will now look like this:

    SELECT c.CurrencyCode, r.Name
      FROM Sales.CountryRegionCurrency  c
INNER JOIN [.].AdventureWorks2008.Person.CountryRegion r
        ON c.CountryRegionCode = r.CountryRegionCode
     WHERE c.CurrencyCode = 'EUR'

For this particular query in this particular configuration, the response time is actually still nice (it's already five times slower, but you don't really notice that). In real-life queries -and with a real remote Oracle- you'll notice a dramatic decrease in performance. For this demo configuration, you can use Sql Profiler to reveal the query that was sent to the linked server. Instead of performing a selective look-up, SQL Server selected ALL of the rows, and forced even a SORT on it:

    SELECT "Tbl1003"."CountryRegionCode" "Col1011","Tbl1003"."Name" "Col1012"
      FROM "AdventureWorks2008"."Person"."CountryRegion" "Tbl1003"
  ORDER BY "Col1011" ASC

Here's a small part of the result for the query:

You can imagine what will happen if your lookup target is not a small local table but a large complex view. This is bad for the remote machine, the local machine and the network between the two. All of this happens because SQL Server will try to optimize its own workload, and considers the linked server as a black box (which -in the case of an AS/400- it actually ìs ).

What we should send to the linked server is a request for a -limited- number of key-value pairs, such as SELECT id, name FROM blablabla WHERE id in ('id1', 'id2', ...). We should send this query via the OPENQUERY function, so we can use the native SQL syntax of the remote DMBS. A classic way to create a short comma-separated list in T-SQL is with a variable and the COALESCE function. If the key is not numeric, then you need to wrap each value in quotes. OPENQUERY uses OLEDB under the hood, and this doesn't like double quotes. So you have to wrap each value in two single quotes that you have to wrap in single quotes during the concatenation. Oops, you're lost ? Just look at the code:

DECLARE @Countries VARCHAR(MAX)
 
-- Create comma-separated list of lookup values
;WITH Countries AS
(
SELECT CountryRegionCode
  FROM Sales.CountryRegionCurrency
 WHERE CurrencyCode = 'EUR'
)
SELECT @Countries = COALESCE(@Countries + ',', '') + '''''' + CountryRegionCode + ''''''
  FROM Countries

After these calls, the @Countries variable holds a comma-separated list of country codes:

Unfortunately OPENQUERY does'nt take parameters, so we need to construct the whole query dynamically, and call it via EXECUTE. To store the result, we need to create a temporary table, because unfortunately table variables disappear from the scope with EXECUTE:

CREATE TABLE #Countries (CountryRegionCode nvarchar(3), Name nvarchar(50))
 
DECLARE @Query VARCHAR(MAX)
 
SET @Query = 'INSERT #Countries ' +
             'SELECT * FROM OPENQUERY ([.], ' +
             '''SELECT CountryRegionCode, Name ' +
               'FROM AdventureWorks2008.Person.CountryRegion ' +
               'WHERE CountryRegionCode IN (' + @Countries + ')'')'
 
EXECUTE (@Query)

This is the value of the @Query variable:

After these calls, the #Countries table contains the remote data (at least the fraction we're interested in):

So we now can join locally:

    SELECT c.CurrencyCode, r.Name
      FROM Sales.CountryRegionCurrency  c
INNER JOIN #Countries r
        ON c.CountryRegionCode = r.CountryRegionCode
     WHERE c.CurrencyCode = 'EUR'

And while the complexity of the code dramatically increased, the response time went down equally dramatically ...

For the sake of completeness, here's the whole demo script:

/***************/
/* Preparation */
/***************/
 
/* Add linked server to local instance */
execute sp_addlinkedserver '.'
 
USE AdventureWorks2008
GO
 
/********/
/* Test */
/********/
 
 -- Local query
    SELECT c.CurrencyCode, r.Name
      FROM Sales.CountryRegionCurrency  c
INNER JOIN Person.CountryRegion r
        ON c.CountryRegionCode = r.CountryRegionCode
     WHERE c.CurrencyCode = 'EUR'
 
 -- Query through linked server
    SELECT c.CurrencyCode, r.Name
      FROM Sales.CountryRegionCurrency  c
INNER JOIN [.].AdventureWorks2008.Person.CountryRegion r
        ON c.CountryRegionCode = r.CountryRegionCode
     WHERE c.CurrencyCode = 'EUR'
 
 -- The query sent to the linked server (from Sql Profiler)  
    SELECT "Tbl1003"."CountryRegionCode" "Col1011","Tbl1003"."Name" "Col1012"
      FROM "AdventureWorks2008"."Person"."CountryRegion" "Tbl1003"
  ORDER BY "Col1011" ASC
 
/**************/
/* Workaround */
/**************/
 
DECLARE @Countries VARCHAR(MAX)
 
-- Create comma-separated list of lookup values
;WITH Countries AS
(
SELECT CountryRegionCode
  FROM Sales.CountryRegionCurrency
 WHERE CurrencyCode = 'EUR'
)
SELECT @Countries = COALESCE(@Countries + ',', '') + '''''' + CountryRegionCode + ''''''
  FROM Countries
-- OLE DB Drivers don't like double quotes, so we have to hexuplicate ;-))
 
-- Uncomment next line for testing
-- SELECT @Countries
 
-- Create temporary table to hold results from query to linked server
CREATE TABLE #Countries (CountryRegionCode nvarchar(3), Name nvarchar(50))
 
DECLARE @Query VARCHAR(MAX)
 
-- Build query to linked server
SET @Query = 'INSERT #Countries ' +
             'SELECT * FROM OPENQUERY ([.], ' +
             '''SELECT CountryRegionCode, Name ' +
               'FROM AdventureWorks2008.Person.CountryRegion ' +
               'WHERE CountryRegionCode IN (' + @Countries + ')'')'
 
-- Uncomment next line for testing
-- SELECT @Query
 
-- Execute query to linked server
EXECUTE (@Query)
 
-- Uncomment next line for testing
-- SELECT * FROM #Countries
 
-- Execute query entirely locally
    SELECT c.CurrencyCode, r.Name
      FROM Sales.CountryRegionCurrency  c
INNER JOIN #Countries r
        ON c.CountryRegionCode = r.CountryRegionCode
     WHERE c.CurrencyCode = 'EUR'
 
DROP TABLE #Countries
 
/************/
/* Teardown */
/************/
 
/* Remove linked server */
execute sp_dropserver '.'

Displaying spatial data in WPF: from SqlGeometry to PathGeometry

Diederik Krols — Tue, 05 Jan 2010 14:17:00 -1300

This article explains how to visualize spatial data (e.g. from SQL Server 2008) in Windows Presentation Foundation without using 3rd party components or proprietary formats. We'll build a little form that allows us to enter test data in the Well-Known Text format (WKT) - manually or via copy/paste, e.g. from SQL Management Studio. A Draw button will convert our input to WPF graphics, and display it. Here's how the application looks like:

It's probably a waste of time to do the validation of the input text and the parsing of its structure ourselves, since the native spatial SQL Server .NET UDTs -SqlGeometry and SqlGeography- are specialized in that. These types are stored in the Microsoft.SqlServer.Types assembly, so we should make a reference to that one in our project. On the user interface side, the best candidate type to visualize spatial data in WPF is without any doubt the Geometry class, which represents a composite 2D-shape. To create a WPF version of spatial data, we read the WKT format and use it to initialize a SqlGeometry instance. Then we call some of the OGC-functions to break the SqlGeometry Object Model down into a PathGeometry Structure. For ease of use, it makes sense to wrap this functionality in extension methods for SqlGeometry. Here's the class:

namespace U2UConsult.DockOfTheBay
{
    using System.Windows;
    using System.Windows.Media;
    using System.Windows.Shapes;
    using Microsoft.SqlServer.Types;
 
    /// <summary>
    /// Extension Methods for SqlGeometry.
    /// </summary>
    public static class SqlGeometryExtensions
    {
        /// <summary>
        /// Translates a SqlGeometry into a Systems.Windows.Media.Geometry.
        /// </summary>
        public static Geometry AsWpfGeometry(this SqlGeometry sqlGeometry)
        {
            PathGeometry result = new PathGeometry();
 
            switch (sqlGeometry.STGeometryType().Value.ToLower())
            {
                case "point":
 
                    // Return a little 'X' 
                    // (well: 'little' depends on the coordinate system ...)
                    PathFigure pointFigure = new PathFigure();
                    pointFigure.StartPoint = new Point(
                        sqlGeometry.STX.Value - .1,
                        sqlGeometry.STY.Value - .1);
                    LineSegment line = new LineSegment(
                        new Point(
                            sqlGeometry.STX.Value + .1,
                            sqlGeometry.STY.Value + .1),
                        true);
                    pointFigure.Segments.Add(line);
                    result.Figures.Add(pointFigure);
 
                    pointFigure = new PathFigure();
                    pointFigure.StartPoint = new Point(
                        sqlGeometry.STX.Value - .1,
                        sqlGeometry.STY.Value + .1);
                    line = new LineSegment(
                        new Point(
                            sqlGeometry.STX.Value + .1,
                            sqlGeometry.STY.Value - .1),
                        true);
                    pointFigure.Segments.Add(line);
                    result.Figures.Add(pointFigure);
 
                    return result;
 
                case "polygon":
 
                    // A Spacial Polygon is a collection of Rings
                    // A Ring is a Closed LineString
                    // So, return a PathFigure for each Ring
 
                    // Outer Ring
                    result.Figures.Add(LineStringToWpfGeometry(sqlGeometry.STExteriorRing()));
 
                    // Inner Rings
                    for (int i = 1; i <= sqlGeometry.STNumInteriorRing(); i++)
                    {
                        result.Figures.Add(LineStringToWpfGeometry(sqlGeometry.STInteriorRingN(i)));
                    }
 
                    return result;
 
                case "linestring":
 
                    // Return a PathFigure
                    result.Figures.Add(LineStringToWpfGeometry(sqlGeometry));
                    return result;
 
                case "multipoint":
                case "multilinestring":
                case "multipolygon":
                case "geometrycollection":
 
                    // Return a Group of Geometries
                    GeometryGroup geometryGroup = new GeometryGroup();
 
                    for (int i = 1; i <= sqlGeometry.STNumGeometries().Value; i++)
                    {
                        geometryGroup.Children.Add(sqlGeometry.STGeometryN(i).AsWpfGeometry());
                    }
 
                    return geometryGroup;
 
                default:
 
                    // Unrecognized Type
                    // Return an empty Geometry
                    return Geometry.Empty;
            }
        }
 
        /// <summary>
        /// Translates a SqlGeometry into a Systems.Windows.Shapes.Path.
        /// </summary>
        public static Path AsPath(this SqlGeometry sqlGeometry)
        {
            Path path = new Path();
            path.Data = sqlGeometry.AsWpfGeometry();
            return path;
        }
 
        /// <summary>
        /// Translates a LineString or a single Polygon Ring to a PathFigure.
        /// </summary>
        private static PathFigure LineStringToWpfGeometry(SqlGeometry sqlGeometry)
        {
            PathFigure result = new PathFigure();
 
            result.StartPoint = new Point(
                sqlGeometry.STPointN(1).STX.Value,
                sqlGeometry.STPointN(1).STY.Value);
 
            for (int i = 1; i <= sqlGeometry.STNumPoints(); i++)
            {
                LineSegment lineSegment = new LineSegment();
                lineSegment.Point = new Point(
                    sqlGeometry.STPointN(i).STX.Value,
                    sqlGeometry.STPointN(i).STY.Value);
                result.Segments.Add(lineSegment);
            }
 
            return result;
        }
    }
}

To use these extension methods, all we need to do is create a SqlGeometry instance with some data. Then we need to ensure it's valid against the OGC standards, so that the OGC compliant sql methods behave properly. Finally we call the conversion, like this:

// Make OGC Compliant
if (!sqlGeometry.STIsValid())
{
    sqlGeometry = sqlGeometry.MakeValid();
}
 
// Transformation Samples
Path path = sqlGeometry.AsPath();
Geometry geometry = sqlGeometry.AsWpfGeometry();

We end up with a Geometry that is expressed in the original spatial coordinates: latitude/longitude or X/Y against a specific SRID. So we need to translate and scale it, to project it to windows coordinates. Since we only visualize one shape, it suffices to let it stretch automatically in its container. By the way: don't forget to draw upside-down, because the origin of a Control is the upper left corner while the origin of a map is generally at the bottom left:

// Flip Y-coordinate
// Origin of a map is usually at the bottom left
path.LayoutTransform = new ScaleTransform(1, -1);
 
// Automate Translation & Inflation
path.Stretch = Stretch.Uniform;

Samples

I tested the code against a high number of possible (mostly Belgian) shapes. Here are some examples:

The river Zenne at the point where it leaves Brussels, heading to the north. An example of a LineString.
The province of Antwerp. An example of a MultiPolygon.
The province of Flemish Brabant. An example of a Polygon with an inner Ring.
The arrondissement Halle-Vilvoorde. An example of a Polygon.

Here's the full code for the WPF Window. To bring you up-to-speed immediately, it starts with a reduced shape (24 Points) of Belgium:

XAML:

<Window
   x:Class="U2UConsult.DockOfTheBay.SpatialSample"
   xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
   xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
   Title="SQL Spatial to WPF Sample"
   Icon="/U2UConsult.DockOfTheBay;component/dotbay.png">
    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="*" />
        </Grid.RowDefinitions>
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="*" />
            <ColumnDefinition Width="2*" />
        </Grid.ColumnDefinitions>
        <Button
           x:Name="DrawButton"
           Click="DrawButton_Click"
           Content="Draw"
           Grid.Row="0" Grid.Column="1"
           Margin="15"
           Height="32" Width="64"
           HorizontalAlignment="Left"
           VerticalAlignment="Bottom"
           />
        <!-- Reduced shape of Belgium -->
        <TextBox
           x:Name="GeometryTextBox"
           Margin="5"
           Grid.Row="0" Grid.Column="0"
           TextWrapping="Wrap"
           AcceptsReturn="True"
           AcceptsTab="True"
           Text="POLYGON ((
                    5.4695768356323242 49.499450206756592, 
                    5.8744573593139648 49.576767921447754, 
                    5.7810144424438477 49.959678173065186, 
                    6.4083404541015625 50.333068847656250, 
                    6.1721935272216800 50.550515174865723, 
                    6.2783794403076172 50.616397857666016, 
                    5.6911020278930664 50.761138916015625, 
                    5.8341245651245117 51.168460845947266, 
                    5.2405147552490234 51.261853218078613, 
                    5.0372371673583984 51.485389232635500, 
                    4.4786109924316406 51.480998992919922, 
                    3.9020967483520508 51.198946952819824, 
                    3.1825008392333984 51.361250877380371, 
                    2.5581483840942383 51.093193054199219, 
                    2.6278944015502930 50.814075946807861, 
                    3.1747541427612305 50.752677917480469, 
                    3.2816371917724609 50.526985168457031, 
                    3.6048288345336914 50.489061832427979, 
                    3.7020025253295900 50.300303936004639, 
                    4.2115697860717773 50.269905090332031, 
                    4.1991643905639648 49.960120201110840, 
                    4.6723327636718750 49.985515117645264, 
                    4.8746204376220700 50.151000022888184, 
                    4.8553209304809570 49.794033050537109, 
                    5.4695768356323242 49.499450206756592))"
           ToolTip="Place your Well-Known Text here ..."
           />
        <Border
           x:Name="DrawingCanvas"
           Padding="15"
           Grid.Row="0" Grid.Column="1"
           />
    </Grid>
</Window>

C#:

namespace U2UConsult.DockOfTheBay
{
    using System;
    using System.Windows;
    using System.Windows.Controls;
    using System.Windows.Media;
    using System.Windows.Shapes;
    using Microsoft.SqlServer.Types; // Add Reference !!!
 
    /// <summary>
    /// Demonstrates displaying SQL Server Spatial data in WPF. 
    /// </summary>
    public partial class SpatialSample : Window
    {
        public SpatialSample()
        {
            InitializeComponent();
        }
 
        private void DrawButton_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                // Read Well-Known Text
                SqlGeometry sqlGeometry = SqlGeometry.Parse(this.GeometryTextBox.Text);
 
                // Make OGC Compliant
                if (!sqlGeometry.STIsValid())
                {
                    sqlGeometry = sqlGeometry.MakeValid();
                }
 
                // Transform to Path
                Path path = sqlGeometry.AsPath();
 
                // Basic Properties
                path.Stroke = Brushes.Black;
                path.StrokeThickness = 1;
 
                // Polygons only ...
                //path.Effect = new DropShadowEffect() { Direction = 225 };
                //path.Fill = Brushes.DarkGreen;
 
                // Flip Y-coordinate
                // Origin of a map is usually at the bottom left
                path.LayoutTransform = new ScaleTransform(1, -1);
 
                // Automate Translation & Inflation
                path.Stretch = Stretch.Uniform;
 
                this.DrawingCanvas.Child = path;
            }
            catch (Exception ex)
            {
                // Input not valid
                this.DrawingCanvas.Child = new TextBlock()
                {
                    TextWrapping = TextWrapping.Wrap,
                    MaxHeight = 128,
                    VerticalAlignment = VerticalAlignment.Top,
                    Foreground = Brushes.Red,
                    Text = ex.Message
                };
            }
        }
    }
}

Static Reflection in .NET, part 2

Kris Vandermotten — Tue, 29 Dec 2009 20:23:53 -1300

A few weeks ago, I talked about static reflection and its advantages. You’ll remember that the main advantages, compared to the normal reflection API’s, are the compile time checking of parameters and IntelliSense support.

How does it compare at other levels, performance for example? Before we dive into that question, let me state that performance may or may not be important to you. A program that is fast enough is, well, fast enough. It’s unlikely that a (single) reflection call will have a significant impact on, say, the response time of a graphical user interface, and so performance doesn’t matter. If you’re algorithm requires millions of reflection operations, I’m sure you can rewrite it somehow to reduce that number significantly, and then performance again probably doesn’t matter anymore. That being said, we still want to know, right?

First of all, let’s compare code.

Take this line (using the Example class from the last post):

PropertyInfo pi = typeof(Example).GetProperty("Description");

This line compiles to the following IL (simplified for readability):

ldtoken Example 
call class Type Type::GetTypeFromHandle(valuetype RuntimeTypeHandle) 
ldstr "Description" 
call instance class PropertyInfo Type::GetProperty(string)

Compare that to the following line:

PropertyInfo pi = StaticReflector.Create<Example>().PropertyInfo(e => e.Description);

Which compiles to:

call class IStaticReflector`1<!!0> StaticReflector::Create<class Example>()
ldtoken Example
call class Type Type::GetTypeFromHandle(valuetype RuntimeTypeHandle)
ldstr "e"
call class ParameterExpression Expression::Parameter(class Type, string)
stloc.0 
ldloc.0 
ldtoken instance string Example::get_Description()
call class MethodBase MethodBase::GetMethodFromHandle(valuetype RuntimeMethodHandle)
castclass MethodInfo
call class MemberExpression Expression::Property(class Expression, class MethodInfo)
ldc.i4.1 
newarr ParameterExpression
stloc.1 
ldloc.1 
ldc.i4.0 
ldloc.0 
stelem.ref 
ldloc.1 
call class Expression`1<!!0> Expression::Lambda<class System.Func`2<class Example, string>>(class Expression, class ParameterExpression[])
call class PropertyInfo StaticReflectorExtensions::PropertyInfo<class Example, string>(class IStaticReflector`1<!!0>, class Expression`1<class System.Func`2<!!0, !!1>>)

As you can see, this code doesn’t load the “Description” string, it uses the ldtoken instruction instead. Some bloggers have suggested that this would make it more efficient. Unfortunately, even if the ldtoken instruction is efficient, it is largely offset by the construction of the lambda expression. I ran a little benchmark, in which I compare execution time (in ticks) and memory usage (in generation 0 garbage collection runs) of both approaches, executing each one a million times. This is the result (on my laptop):

Using Reflection       Time:    1089308 Collections:    45
Using StaticReflection Time:   13513777 Collections:   264

As you can see, the Static Reflection approach is about 13.5 times slower than the good old dynamic reflection, and it uses a lot more memory. That should be no surprise either: both cases allocate a PropertyInfo object, but the static case also allocates the expression, which is nothing but food for the garbage collector.

So, one approach seems good at compile time, and the other is good at run time. It seems we’re stuck between a rock and a hard place. But the situation isn’t so bad: we have two options to choose from, each with their pro’s and con’s. What the best one is depends on your requirements, and what you value the most: compile time checking (which may result in productivity and maintainability benefits), or performance.

And who knows, maybe there is a third option, giving the best of both worlds. But that’s for next time.

May I introduce you to Lis Tielens

Jan Tielens — Tue, 22 Dec 2009 21:33:00 Z

I'm very happy to announce that this morning our daugher Lis was born. She and her mother are recovering from the C-section but they are doing well. For more news (in Dutch), feel free to check out our family blog: http://kids.neleenjan.net.