Thomas Huijer

MVP C# in 2010

2010-01-01T21:16:46Z

I was notified today by email that Microsoft awarded me the 2010 Microsoft MVP Award for C#.

Just great!

MSTest: Cannot start more than one local run

2009-12-22T11:44:22Z

When I run my tests in Visual Studio and one or more tests fail, I hit the Debug Selected Test so see what is going on. But at times, I get this error message:

I don’t know what trigger this, but I had to restart Visual Studio to be able to Run or Debug tests again. After some searching on the net, I found out that there’s some sort of communication error between Visual Studio and the executable that actually runs the tests. So my resolution now is to kill that process and try again. The name of the executable to look for is VSTestHost.exe. Kill the process and you’re good to go…

Chad Hower’s story

2009-12-08T11:08:39Z

A friend of mine, Chad Hower aka Kudzu, is in trouble. Chad has developed many internet-related components for Delphi, with Indy (being shipped with Delphi) being the most well known. Chad is also a speaker and writer and now works for Microsoft. He’s accused of kidnapping his son. Although there’s really strong evidence that it’s totally impossible for him to have done so. For example, how can you kidnap a son you have custody over? It’s a heartbreaking and quite unbelievable story. Watch the 5 minute at www.freechad.org and spread the word!

What’s new in WCF 4.0: brief summary

2009-11-27T10:59:25Z

Below are the notes I took at the PDC about what’s new in WCF 4.0.

Default bindings can be created. If no bindings are specified for a service, these bindings are used.
WCf supports configuration inheritance, so bindings could also be specified at various levels including the machine.config.
Same applies to behaviors
Default bindings/behaviors are the bindings/behaviors that have no name or name=”” in the configuration
Configuration based activation allows services without *.svc files
ETW (Event Tracing for Windows) is used by WCF
AppFabric (FKA “Dublin”) stores that data in a Sql Server database for easy retrieval and querying.
Routing is a completely new feature in WCF which allows service aggregation, protocol bridging and versioning.
MessageFilters are used to determine destination(s).
Routing table can be changed at runtime.
Security can also be bridged.
Alternate endpoints can be specified for fail-over-safety.
Discovery is another new feature. It allows for location agility, dynamic / self-healing apps
Discovery adheres to WS-Discovery standards
Two mode for discovery: Ad-hoc and managed
Ad-hoc discovery uses broadcasts
Managed discovery is like UDDI with a Discovery Proxy.

Compile-time checked region names in Prism

2009-10-30T19:28:25Z

In a R&D project of mine, I’m using Prism to create a composite WPF application. I can recommend anyone writing WPF or Silverlight applications to take a look at it if you’re unfamiliair with Prism.

One thing I dislike about it though, is that is uses strings as region names. Meaning that there’s no compile-time checking if your region names in the Shell and the names you’re using when registering the views are actually aligned.

Here’s a small trick to get compile-time checking for your region names in Prism:

Define an Enum containing the names of all known regions:

    public enum RegionName

        ToolBar,

        MessageList,

        Details

Define a MarkupExtension for each value of the enum. This sounds like a lot of work, but with a base class like the one below, it’s no more than a few lines.

    public class BaseRegionExtension : MarkupExtension

        private RegionName _regionName;

        public BaseRegionExtension(RegionName regionName)

            _regionName = regionName;

        public override object ProvideValue(IServiceProvider serviceProvider)

            return _regionName.ToString();

        public RegionName Name

get

                return _regionName;

set

                _regionName = value;

Defining a MarkupExtension now becomes really simple:

   public class ToolBarRegionExtension : BaseRegionExtension

        public ToolBarRegionExtension()

            : base(RegionName.ToolBar)

When registering your view, just call the ToString() of the enum value you want to use:

  _regionManager.RegisterViewWithRegion(RegionName.ToolBar.ToString(), typeof(MainToolbarView));

When defining regions in your Shell Xaml file, use the right MarkupExtension to reference a value in your enum:

<ToolBarPanel>
<ItemsControl cal:RegionManager.RegionName="{ui:ToolBarRegion}">
</ItemsControl>
</ToolBarPanel>

Have fun!

No regions when generating code

2009-10-21T17:58:14Z

Just wished I had found this option about 5 years earlier….

Programming with a guitar…

2009-10-21T13:51:02Z

My long-time friend Mark Miller of DevExpress has created another challenge for himself. A couple of years ago at the PDC he challenged developers to write some code together. The developer would have a full keyboard and mouse and a standard Visual Studio. Mark would have a keyboard too, but he had to program with chopsticks. His Visual Studio would have CodeRush installed though. And yeah, Mark was faster…

Well, this year Mark has an even greater challenge. He’s not going to use a keyboard at all. He’s going to use a guitar to write code. Yeah…a guitar…to write code…

Watch Mark in action on his guitar: http://tv.devexpress.com/GuitarCodeInterview.movie

Great free tool to manage TFS WorkItems

2009-09-29T20:22:35Z

Internally we use TFS to manage our own projects. And also at client-site we recommend using TFS for managing the application lifecycle. But Visual Studio Team Explorer is not as easy to use as I’d like it to be. Some things are just too hard. For example, try searching for a workitem that you know has a certain term in its Title or its Description. If you’re nodding your head now, you know what I’m talking about…

Yesterday I came across a great tool from Telerik, a tool and component-vendor. They offer a FREE tool to manage TFS workitems. I recommend anyone using TFS to check out Telerik’s TFS Work Item Manager. These features are advertised by Telerik. Needless to say I really like the last one…

Work Item grid filtering, grouping, and aggregation
Area and Iteration filtering using single and multi select modes
Filter query results using a tree of areas or iterations
Unique Task board view of work items independent from any process template
Print work item cards for the board in your room
Iteration schedule
Paste clipboard contents into a work item
"New Query by example” saves your query for other team members
Search the title and description of query results as you type

Getting started with the Managed Extensibility Framework

2009-07-22T09:44:28Z

I recently started exploring the new Visual Studio 2010 code editor. The great thing about the new editor is that it supports plugins. You’re able to write additions to the Visual Studio editor that formats the code in any way you like. Microsoft put up some samples on CodePlex. Visual Studio uses the Managed Extensibility Framework (MEF) as the base for writing plugins. In this post I’d like to give you the basics of the Managed Extensibility Framework. After that, I’ll explore writing plugins for Visual Studio 2010.

What problems does MEF solve?

MEF presents a simple solution for the runtime extensibility problem. Until now, any application that wanted to support a plugin model needed to create its own infrastructure from scratch. Those plugins would often be application-specific and could not be reused across multiple implementations.

MEF provides a standard way for the host application to expose itself and consume external extensions. Extensions, by their nature, can be reused amongst different applications. However, an extension could still be implemented in a way that is application-specific. Extensions themselves can depend on one another and MEF will make sure they are wired together in the correct order (another thing you won't have to worry about).
MEF offers a set of discovery approaches for your application to locate and load available extensions.
MEF allows tagging extensions with additional metadata which facilitates rich querying and filtering

I copied the above text from the CodePlex MEF homepage. So basically, MEF is a framework that will let you write applications that support plugins very easily. MEF exposes classes, interfaces and services to easily let you write applications that support plugins.

How does MEF work?

Basically, this is how it works:

Some components (parts of your application, not System.ComponentModel.Component) expose capabilities (or services if you will).
Some components are dependent on other capabilities.

The goal of MEF is to glue the capabilities and dependencies together in your application. This allows for a very modular design. Exposing a capability in MEF is called an Export and a dependency on an other capability is called in Import.

Let’s take a look at how this works. Suppose we have an application that is able to write tracing messages to some log. One class is going to want to log a message, the other class is going to take care of that. Of course we don’t want having a direct reference from one class to the other, so we’ll use an interface. Just like you’d do in any well designed application.

    public interface ITraceMessageWriter

        void WriteToLog( string message );

The next step is to create a class that implements this interface. This class will take care of actually logging the message:

    [Export(typeof(ITraceMessageWriter))]

    public class TraceMessageWriter : ITraceMessageWriter

        public void WriteToLog( string message )

            // write here to any data store (file/database)

The only thing we added is an MEF attribute: Export. The argument of the Export attribute is the name of a contract. This can be a string or a Type. The purpose of this attribute is to link the right services to the right dependencies. So the next piece of code shows how to import a dependency:

    public partial class Window1 : Window

        [Import]

        protected ITraceMessageWriter _writer;

To make sure the _writer field actually gets a reference to an instance, we make sure MEF is going to ‘compose’ our object. To do this we call a method called Compose in the constructor. This method is one we’re defining later and will make sure that MEF fills our field. After that we can call methods on it. Note that there’s no guarantee that the field will actually be filled. In the case that there’s no Export (service/capability) found for this dependency, the field would still be null.

        public Window1()

            InitializeComponent();

            Compose();

            _writer.WriteToLog("Hello World");

The Compose method does all the MEF magic. In this Compose method, we need to do a couple of things.

Create a CompositionContainer. This container is used when composing objects.
Tell which object or objects needs composing (have their dependencies resolved).
To do this, we need a CompositionBatch. An object which holds references to all objects that need to be composed.
Tell which extensions/plugins need to be searched for Exports
In MEF we need a Catalog for this. A Catalog defines the location of one or more extensions. In this example, I’ll be using an AssemblyCatalog. A Catalog referring to an already loaded assembly

Fortunately, the resulting code is pretty easy:

        private void Compose()

            AssemblyCatalog catalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());

            CompositionContainer _container = new CompositionContainer(catalog);

            CompositionBatch batch = new CompositionBatch();

            batch.AddPart(this);

            _container.Compose(batch);

This is what we did:

We created a catalog for the current executing assembly
We created a container to do the composition
We added ourselves (since ‘this’ has the _writer field) to a CompositionBatch.
We called Compose on the container passing in the CompositionBatch.

That’s all. Our dependency is resolved by MEF and we’re ready to go. Admittedly, this is a extremely basic example. But remember that the dependencies we have may resolved from plugins that are loaded dynamically from a given directory. Or from registered plugins in a config file.

Isn’t MEF just another Dependency Injection framework?

No, not really. Although MEF does have some capabilities that DI-frameworks have, MEF’s focus is on composition. Some classes import services from other parts of the application, and some classes export services. The goal of MEF is to seamlessly glue those together. One other difference is that normally when using a DI-framework, you are aware of all the components used in the application. In MEF, this may not be the case. You load up some extensions or plugins or whatever you want to call them, and MEF discovers all the exports and imports of services in those extensions. Therefore, the actual functionality of the application is dependent of the extensions that are loaded at a given time. This is uncommon in ‘normal’ DI scenario’s.

Where and when is MEF available?

Whenever you use the .NET Framework 4.0. As MSDN says: “MEF is an integral part of the .NET Framework 4 Beta 1, and is available wherever the .NET Framework is used. You can use MEF in your client applications, whether they use Windows Forms, WPF, or any other technology, or in server applications that use ASP.NET. In addition, there are plans to add MEF support for Silverlight applications.”

So it’s going to be a part of the Framework 4.0. Until then, MEF can be downloaded from here.

Where do we go from here?

If you’re interested in MEF, I’d suggest you read at least this overview on MSDN and Brad Abrams Simple Example of MEF in Silverlight. That should give you a good headstart.

First Dutch Surface User Group meeting

2009-07-03T08:14:11Z

The Dutch Surface Usergroup had its first meeting on June 25th, 2009. See the video of that meeting here.

The usergroup also has its own website located at http://surface.dotned.nl/

Interview with Niklaus Wirth

2009-07-02T19:48:35Z

Although I mostly develop in C#, I do have a long history developing in Delphi. I just stumbled upon an interview with Niklaus Wirth, the language designer of the original Pascal. Niklaus Wirth is a very interesting man. As a real academic, he has some views on today’s programming languages and programs that are non-conventional. I found it an interesting read. Oh, and the history of languages described in this interview IS real by the way…

Read the interview here: http://www.simple-talk.com/opinion/geek-of-the-week/niklaus-wirth-geek-of-the-week/

DevDays 2009 – part I

2009-06-03T10:41:14Z

Last week, the DevDays were held in The Hague. I went there with all of my dev-collegues. Although we had seen a lot of stuff at the PDC back in november, there was plenty of new cool things to show. It was a pretty different experience from the other DevDays that I’d been to. First of all, we had no booth. That was a first. And, I had no talk to give. That was a first too. So, I could see any session I want, didn’t need to rush back to the booth in between sessions. Actually, I was much more enjoyable in general.

I saw a couple of Silverlight 3 sessions. There are some cool new features coming like H.264 and AAC support, 720p+ smooth streaming, 3D graphics, pixel shader, easing functions (animation effects), a Bitmap API, control skinning, bitmap caching. Deep linking and the ability to run a Silverlight application out of the browser. Read more about Silverlight 3 here. I really liked Mike Taulty’s fast paced style, doing lots of demo’s fairly quickly. I also liked the fact that he kept his demo’s small and simple. As he said at the beginning of his talk that was intentional. I too believe that if you’re introducing people to new concepts or new features, keep the demo’s as simple as possible. You probably have a crowd of pretty decent developers (given the fact that it’s the DevDays), they’ll think of ways of using there features in their own apps.

The ‘what’s new in WCF/WF 4.0’ session was good in terms of delivery. Aaron Skonnard did well, but … at the PDC I had been given the impression that WCF 4.0 had support for XAML-based services. And that proved to be only partially correct. It’s true if and only if you build a WF Service, that is a workflow exposed as a service. I was heavily (and visibly even: there was a customer who saw me shake my head and knew why) disappointed. It’d be so great if we had a XAML based WCF Service. That would alleviate us from the burden of config files. Although a lot of work has been done to simplify the config-files in WCF 4.0, having a XAML-based WCF Service would be even better. Way better I suppose. Because then we’d have compile-time checking of all the classes, interfaces used in the XAML file, just like WPF does. Anyway, the changes in WCF 4.0 are good, but I just expected more of it after what I heard at the PDC.

At last: my pet complaint about Visual Studio has been fixed!

2009-05-22T09:58:00Z

One of the things that has bugged me most about the Visual Studio IDE has been fixed in VS2010. In just about every training I teach, I mention this at least once. Actually, some people were complaining to me about complaining about it too much. ;-)

The one I mean is the Project and Project item dialog:

The problem I had with this dialog are the following:

It’s not sorted by default
You can’t sort it in any way
You can’t filter it in any way
The Dialog is not sizeable.

This makes it so damn hard to choose the right template fast. I don’t want to stare 5 seconds at this dialog just to find the template I need. So I was very delighted when I opened a new project in Visual Studio 2010 Beta 1. In Visual Studio 2010 the dialog looks like this:

Yeah, baby! Now I can sort, filter and resize it. Whoohoo!

History of programming languages…well, kind of…

2009-05-08T21:00:30Z

I just read this article named “A Brief, Incomplete, and Mostly Wrong History of Programming Languages” by James Iry. I thought it was hilarious…

You can read it here: A Brief, Incomplete, and Mostly Wrong History of Programming Languages

WPF Debugger Visualizer

2009-03-11T10:28:33Z

While debugging a WPF I came across a great debugger visualizer: WoodStock. WoodStock gives you a treeview of the current Visual Tree of a given element. So when you debug, you can select a framework element and show the tree like this:

It then shows a tree similar to this tree:

Great stuff when debugging a WPF app!