Johannes Hansen's Blog

Microsoft Code Contracts project site

2008-11-04T22:00:00.001+01:00

If you are interested in learning more about the coming Design by Contract stuff in .NET 4.0 here is the link for the Microsoft Code Contracts project site. At the site you can download a MSI containing the documentation as well as a research implementation of the code contracts and some of the VS integration for VS2008. However, it’s under the research license so you won’t be able to use it in a production environment.

Programming by contract features coming in .NET 4.0!!!

2008-11-02T19:08:00.002+01:00

Image by Getty Images via Daylife

It happened! The BCL team proved me wrong (see my two previous posts), and I’m very happy that they did!

So, I’ve been sitting for the last couple of hours watching some of the many interesting PDC2008 sessions online. In particular the day 4 sessions “TL51 Research: Contract Checking and Automated Test Generation with Pex” and “PC49 Microsoft .NET Framework: CLR Futures” were extremely interesting from my perspective. In fact, I’m so excited to write this that I’m almost shaking!

What has gotten me so excited was the announcement that we will finally be able to do programming by contract with the next version of the .NET framework. And it will be integrated into VS2010 so we will see contract violations when compiling. Awesome! For those of you who know about the Spec# project, these new PbC features are the evolution of Spec# into something usable, not just by C# but by all .NET languages.

The TL51 session also talked about another extemely cool project called Pex which is now a Microsoft DevLabs project. The Pex project and the programming by contract features makes up a nice bug killing combo. So if you like bug-free code, like I do, you should pay very close attention to these projects in the future.

Finally I’d like to recommend that you go check out the PDC2008 session list. I’m sure you will find at least 1 or 2 interesting talks in there, though I suspect you will find many more. ;)

Extensibility in VS2010, possible opening for Spec# features?

2008-10-29T05:31:00.002+01:00

Image via Wikipedia

So, I’ve been watching the PDC2008 keynote and my heart jumped a bit at 1:32:52 in the keynote, which was Scott Guthries part. He was talking about extensibility in VS2010 and here’s a transcription of what he says in the video.

“Going forward you’re going to see, in VS2010, that we’re gonna be opening up the extensibility all over the place. In particular within the IDE itself as well as within the text editor.
With the next release we’re gonna go a step further, and we will also open up the language services and the compiler infrastructure as well. It’s gonna really, we think, enable some really great code capabilities.”

You could interpret the second part of the quote in many ways but it just might be a small opening for making Spec#-like features work without having to make an intrusive change of the entire C# language. Of course this is mere speculation and I havn’t been able to find any further information on these language services and compiler infrastructure extensibility points so time will tell what it really meant. But for now I’ll take it and hold on to it as a bit of hope that we will someday see Spec# fetaures in our day-to-day projects.

How to make a non-nullable type wrapper in C#, today…

2008-10-24T00:53:00.004+02:00

Image by cobalt123 via Flickr

I was reading up on the development on Spec# and at the same time trying to figure out if we would start to see Spec# features in C#, anytime soon… Unfortunately, I don’t think we will find any Spec# features in C# 4.0, but I hope the team will prove me wrong.

If you haven’t looked at Spec# yet I strongly encourage you to take a look at it. The short story is that it is a research project which focuses on adding contract oriented constructs to the C# language. You can read more about it at the Spec# homepage or watch the Spec# introduction video on Channel9 which shows off some of the very cool features contract oriented programming brings to the table.

One of the features of Spec# is non-nullable types which is a type wrapper for reference types, sort of like the Nullable<T> type we got in C# 2.0 for value types, but with opposite meaning. In Spec# non-null types can be written as “object!”.

When a type is wrapped with the non-nullable type it can never be set to null. I hope you are now starting to think; “Cool, that would be a nice feature to have in C#”… If you are not, let me explain why you should.

Imagine a world where you could avoid writing code like this:

public void DoStuff(object input)
{
  if (input == null)
    throw new ArgumentNullException("input");

  // Method implementation...
}

Instead you could let the language and the compiler do the null checks for you. If you are a developer by profession, think back on all the applications you’ve made and think of all the null-checking code you’ve written that you could’ve avoided if you had the non-null type feature. Or better yet, think of all the null-checks you forgot to write and you then later discovered when a tester or customer reported an error that turned out to be a null reference exception. Ahh yes, those were the days, right?

Now, since we don’t expect Spec# features in C# anytime soon is there any way we might be able to implement this functionality with what we have? How would we go about writing a non-null type in C#? Well, a good place to start is to fire up reflector and look at how the Nullable<T> type is implemented. After doing that and looking at Jon Skeet’s proposal, I came up with the following slightly modified code:

public struct NonNull<T> where T : class
{
  private readonly T _value;
  public T Value { get { return _value; } }

  public NonNull(T instance)
  {
    if (instance == null)
    throw new ArgumentNullException("instance", "The \"instance\" parameter must not be null.");

    _value = instance;
  }

  public override int GetHashCode()
  {
    return _value.GetHashCode();
  }

  public override bool Equals(object obj)
  {
    return _value.Equals(obj);
  }

  public static bool operator ==(NonNull<T> valueA, NonNull<T> valueB)
  {
    return valueA._value == valueB._value;
  }

  public static bool operator !=(NonNull<T> valueA, NonNull<T> valueB)
  {
    return valueA._value != valueB._value;
  }

  public static implicit operator NonNull<T>(T value)
  {
    return new NonNull<T>(value);
  }

  public static explicit operator T(NonNull<T> value)
  {
    return value._value;
  }
}

But as Jon points out in his excellent blog post that would cause a big problem, since a struct always adds a default parameter-less constructor (that you can’t directly customize) it would be possible to instantiate a NonNull variable with the empty constructor, and thus let the non-null type contain a null value which it clearly shouldn’t. Jon solved this problem by putting a null check in the getter of the “Value” property but this would still hide a potential null reference error till pretty late in a runtime flow. The good news is I found a different solution.

After doing some research I found out that MSIL doesn’t require a default empty constructor to be empty. I then simply compiled a version of the code that had an extra constructor with a dummy parameter and then deleted the parameter from the compiled assembly using the awesome Reflexil plug-in for reflector. And presto, one nice little generic NonNull type wrapper was born. The final code used for this type was:

public struct NonNull<T> where T : class
{
  private readonly T _value;
  public T Value { get { return _value; } }

  [Obsolete("The default parameterless constructor has been disabled please use NonNull<T>(T instance) constructor instead.", true)]
  public NonNull(object dummy)
  {
    throw new NotSupportedException("The default parameterless constructor has been disabled please use NonNull<T>(T instance) constructor instead.");
  }

  public NonNull(T instance)
  {
    if (instance == null)
    throw new ArgumentNullException("instance", "The \"instance\" parameter must not be null.");

    _value = instance;
  }

  public override int GetHashCode()
  {
    return _value.GetHashCode();
  }

  public override bool Equals(object obj)
  {
    return _value.Equals(obj);
  }

  public static bool operator ==(NonNull<T> valueA, NonNull<T> valueB)
  {
    return valueA._value == valueB._value;
  }

  public static bool operator !=(NonNull<T> valueA, NonNull<T> valueB)
  {
    return valueA._value != valueB._value;
  }

  public static implicit operator NonNull<T>(T value)
  {
    return new NonNull<T>(value);
  }

  public static explicit operator T(NonNull<T> value)
  {
    return value._value;
  }
}

As you can see I opted to mark the default constructor as obsolete because that gives a nice little compile-time error if it’s used. I’m also throwing a NotSupportedException from the constructor if it happens to be executed by reflection. I realize that this class isn’t as user-friendly as you would like it to be, but for now it’s probably the closest we’ll get without help from the C# language team.

If you would like to try it out you can get a precompiled NonNull type here. Enjoy!

Extension Types for easier (and strongly typed) Attribute checks

2008-08-27T01:36:00.005+02:00

I just saw a blog post from Alex Mueller about marker interfaces and C# attributes and which way you should be using them.

I, for one, believe that attributes are far the best way to mark a class instead of using an empty marker interface. Why? Well, there are several good reasons to use attributes over interfaces, especially when it comes to inheritance. That aside, attributes are also a lot more flexible than interfaces.

So why don’t people use attributes more often? The most common complaint is that interfaces are easier to use and check for in code (I.e. interfaces requires less code). But I think this is mainly because people don’t know where to look for help in the framework. So I’ve devised 30 extension methods that will make your work with attributes a little bit easier and strongly typed.

public static class AttributeExtensions
{
  // Attribute.IsDefined shortcuts
  public static bool HasAttribute<T>(this object element) where T : Attribute
    { return Attribute.IsDefined(element.GetType(), typeof(T)); }
  public static bool HasAttribute<T>(this object element, bool inherit) where T : Attribute
    { return Attribute.IsDefined(element.GetType(), typeof(T), inherit); }
  public static bool HasAttribute<T>(this Assembly element) where T : Attribute
    { return Attribute.IsDefined(element, typeof(T)); }
  public static bool HasAttribute<T>(this Assembly element, bool inherit) where T : Attribute
    { return Attribute.IsDefined(element, typeof(T), inherit); }
  public static bool HasAttribute<T>(this MemberInfo element) where T : Attribute
    { return Attribute.IsDefined(element, typeof(T)); }
  public static bool HasAttribute<T>(this MemberInfo element, bool inherit) where T : Attribute
    { return Attribute.IsDefined(element, typeof(T), inherit); }
  public static bool HasAttribute<T>(this Module element) where T : Attribute
    { return Attribute.IsDefined(element, typeof(T)); }
  public static bool HasAttribute<T>(this Module element, bool inherit) where T : Attribute
    { return Attribute.IsDefined(element, typeof(T), inherit); }
  public static bool HasAttribute<T>(this ParameterInfo element) where T : Attribute
    { return Attribute.IsDefined(element, typeof(T)); }
  public static bool HasAttribute<T>(this ParameterInfo element, bool inherit) where T : Attribute
    { return Attribute.IsDefined(element, typeof(T), inherit); }

  // Attribute.GetCustomAttribute shotcuts
  public static T GetAttribute<T>(this object element) where T : Attribute
    { return Attribute.GetCustomAttribute(element.GetType(), typeof(T)) as T; }
  public static T GetAttribute<T>(this object element, bool inherit) where T : Attribute
    { return Attribute.GetCustomAttribute(element.GetType(), typeof(T), inherit) as T; }
  public static T GetAttribute<T>(this Assembly element) where T : Attribute
    { return Attribute.GetCustomAttribute(element, typeof(T)) as T; }
  public static T GetAttribute<T>(this Assembly element, bool inherit) where T : Attribute
    { return Attribute.GetCustomAttribute(element, typeof(T), inherit) as T; }
  public static T GetAttribute<T>(this MemberInfo element) where T : Attribute
    { return Attribute.GetCustomAttribute(element, typeof(T)) as T; }
  public static T GetAttribute<T>(this MemberInfo element, bool inherit) where T : Attribute
    { return Attribute.GetCustomAttribute(element, typeof(T), inherit) as T; }
  public static T GetAttribute<T>(this Module element) where T : Attribute
    { return Attribute.GetCustomAttribute(element, typeof(T)) as T; }
  public static T GetAttribute<T>(this Module element, bool inherit) where T : Attribute
    { return Attribute.GetCustomAttribute(element, typeof(T), inherit) as T; }
  public static T GetAttribute<T>(this ParameterInfo element) where T : Attribute
    { return Attribute.GetCustomAttribute(element, typeof(T)) as T; }
  public static T GetAttribute<T>(this ParameterInfo element, bool inherit) where T : Attribute
    { return Attribute.GetCustomAttribute(element, typeof(T), inherit) as T; }

  // Attribute.GetCustomAttributes shortcuts
  public static T[] GetAttributes<T>(this object element) where T : Attribute
    { return Attribute.GetCustomAttributes(element.GetType(), typeof(T)) as T[]; }
  public static T[] GetAttributes<T>(this object element, bool inherit) where T : Attribute
    { return Attribute.GetCustomAttributes(element.GetType(), typeof(T), inherit) as T[]; }
  public static T[] GetAttributes<T>(this Assembly element) where T : Attribute
    { return Attribute.GetCustomAttributes(element, typeof(T)) as T[]; }
  public static T[] GetAttributes<T>(this Assembly element, bool inherit) where T : Attribute
    { return Attribute.GetCustomAttributes(element, typeof(T), inherit) as T[]; }
  public static T[] GetAttributes<T>(this MemberInfo element) where T : Attribute
    { return Attribute.GetCustomAttributes(element, typeof(T)) as T[]; }
  public static T[] GetAttributes<T>(this MemberInfo element, bool inherit) where T : Attribute
    { return Attribute.GetCustomAttributes(element, typeof(T), inherit) as T[]; }
  public static T[] GetAttributes<T>(this Module element) where T : Attribute
    { return Attribute.GetCustomAttributes(element, typeof(T)) as T[]; }
  public static T[] GetAttributes<T>(this Module element, bool inherit) where T : Attribute
    { return Attribute.GetCustomAttributes(element, typeof(T), inherit) as T[]; }
  public static T[] GetAttributes<T>(this ParameterInfo element) where T : Attribute
    { return Attribute.GetCustomAttributes(element, typeof(T)) as T[]; }
  public static T[] GetAttributes<T>(this ParameterInfo element, bool inherit) where T : Attribute
    { return Attribute.GetCustomAttributes(element, typeof(T), inherit) as T[]; }
}

Now you can check for the existence of an attribute like this:

var instance = new SomeClass();

// How to check for attributes using the extension methods.
bool hasMarkerAttribute = instance.HasAttribute<MyMarkerAttribute>();

// How to check for marker interface using unfair compiler sugar. ;)
bool hasMarkerInterface = instance is IMyMarkerInterface; // Not that much shorter, right?

Well, I hope someone can use this… Any thoughts or criticisms for the code will be greatly appreciated. Otherwise, enjoy! ;)

Exciting times

2008-06-06T11:38:00.002+02:00

It's a very exciting time to be a developer right now with all the new stuff that inches closer to completion... ReSharper 4 just hit RC2, Silverlight 2 will come with a beta 2 any second now, SP1 for .NET 3.5 and VS2008 is not too far out in the horizon, and there are a ton of recently updated CTPs floating around. It's very exciting to see how the future is shaping up.

Host name problems in WCF service metadata

2008-04-30T13:15:00.004+02:00

I just solved a little issue a customer had in a project where the addresses in the metadata of a WCF service were pointing to an internal address instead of the external public address. For an example let's say that we have an IIS server which external address is: https://www.example.com/problem.svc and on the internal network the server is called: https://iis.production/problem.svc. The service is configured like so:

<system.serviceModel>
  <services>
    <service name="Example.ProblemService" behaviorConfiguration="CustomBehavior">
      <endpoint contract="Example.IProblemService" binding="wsHttpBinding" bindingConfiguration="ssl" />
      <endpoint contract="IMetadataExchange" binding="mexHttpBinding" address="mex"/>
    </service>
  </services>

  <bindings>
    <wsHttpBinding>
      <binding name="ssl">
        <security mode="Transport">
          <transport clientCredentialType="None"/>
        </security>
      </binding>
    </wsHttpBinding>
  </bindings>

  <behaviors>
    <serviceBehaviors>
      <behavior name="CustomBehavior">
        <serviceMetadata httpGetEnabled="true" />
      </behavior>
    </serviceBehaviors>
  </behaviors>
</system.serviceModel>

Now the problem first shows its ugly face when you go to the external address (https://www.example.com/problem.svc) where the following text will meet you:

You have created a service.

To test this service, you will need to create a client and use it to call the service. You can do this using the svcutil.exe tool from the command line with the following syntax:
svcutil.exe https://iis.production/problem.svc?wsdl

See the problem? It is exposing the internal address instead of the external address. "No problem, I'll just rewrite the path manually", you might say. And yes, you can rewrite the path manually but then you'll find that the WSDL also contains some internal references such as:

<xsd:import schemaLocation="https://iis.production/problem.svc?xsd=xsd1 ?xsd=xsd1" .../>

or

<soap12:address location="https://iis.production/problem.svc" />

So how do we solve this problem? I first thought I could solve it with configuration. So I tried a heap of things like adding base addresses and using the httpsGetUrl property which actually got really close to solving the problem but unfortunately still left a few internal references in the WSDL.

So what can you do? Googling the problem didn't turn up much help but a few people mentioned that adding a host header to IIS might solve the problem... So I tried that, but that didn't have any effect. However, this would have solved the problem if my site wasn't running SSL. If you have a SSL site you have to run a rather obscure command from the command prompt to set the host header:

adsutil set /w3svc/{site identifier}/SecureBindings ":{port}:{host header}"

so in my example the command looked like this:

adsutil set /w3svc/1/SecureBindings ":443:www.example.com"

That's it! It took me about 3 hours of trial and error to get this issue fixed so I hope this post will help you get there a little faster. ;)

IE8 and Silverlight 2.0 betas for developers released and I will not have a computer in sight for the next 4 days... D'oh!

2008-03-06T01:12:00.001+01:00

I was just browsing the web for a last time before I am going on a teambuilding trip to Ljubljana, Slovenia for the next four days and what a big bag of bad timing I was in for… Apparently the teams responsible for IE8 and Silverlight 2.0 decided to release their first betas the very night before I am going on a tech-free business trip! I guess I will just have to wait for 4 days before my excruciating impatience for trying out the exciting new stuff in both releases will be relieved. So it seems like you guys will get a head start on these releases. Enjoy! ;)

IE8 will default to the most standards compliant HTML interpreter

2008-03-04T22:26:00.001+01:00

Just to let you guys know… Dean Hachamovitch, general manager for the IE team, just announced that IE8, regardless of earlier statements, will render web content the most standards compliant way by default. This statement, along with the ACID2 compliance achievement, is a clear indication of the IE teams recent increased focus on standards compliance. I wholeheartedly welcome this change in Microsoft’s policy for interoperability.

Web Client Software Factory 2.0 has shipped!

2008-02-29T07:15:00.001+01:00

According to Glenn Block the new version of WCSF has shipped and is ready for download from MSDN. I encourage you to take a look at it. Oh, what a nice set-up for the weekend. ;)

The C5 Collections Extravaganza!

2008-02-28T05:46:00.001+01:00

Have you ever been in the situation where you thought that the built in collection types in the .NET framework just didn’t cut it? Fret no more; the fine folks at the IT University of Copenhagen have built The C5 Generic Collection Library to fill in the gaps of, and improve on, the standard .NET framework collection types. C5 is truly an awesome library and I wholly recommend that you check out the C5 site and the accompanying manual (272 pages!) describing the library. If you like video more than reading you can check out the Channel9 interview with Peter Sestoft, which is one of the main guys behind the C5 library.

Gax/Gat 1.4 Final Released (Well... a week ago, anyway) Web Client Software Factory 2.0 just around the corner

2008-02-25T14:51:00.002+01:00

A semi-important event transpired last week that almost didn't get any press from the blogging community or anyone else for that matter. I might just have missed the news since I was a little stressed last week, and if it wasn't for a fluke coincidence I probably still wouldn’t have known about it. “So what is this important event you talk of?” I hear you ask. Well, the event was the release of the final version 1.4 of the Patterns & Practices’ GAX/GAT tools. If you don’t know what either GAX or GAT are, here is the 10 second description.

“GAX” stands for “Guidance Automation eXtensions” and “GAT” stands for “Guidance Automation Toolkit”. These are a set of plug-ins and tools by the Patterns & Practices group in Microsoft for Visual Studio that enables you (the architect or senior developer) to write guidance packages for your development team. “GAX” enables the developer to use/execute the guidance packages while “GAT” enables you to actually develop them.

To read more about what guidance packages are, I'll direct you to the P&P site, which also have the download links for the new version of GAX/GAT.

The highlights of this GAX/GAT release are:

1. It’s final... This is important because all the previous versions of GAX/GAT have been labeled “Beta” or “CTP”. However, the details about what this change in labeling actually means are still a little sketchy. Will MS commit to the product or how should we interpret this “Final” label? However I think it is probably for the better. I mean, It's always rather difficult to sell a CTP or Beta solution to my boss, even though a "CTP" or "Beta", in P&P terms, is probably as good as any product most companies would ship.

2. It now supports both VS2005 and VS2008.

3. Various bug fixes.

“That doesn't sound like much... So what’s all the fuzz about?” you ask. Well, apart from GAX/GAT being a very powerful and interesting concept, the release of version 1.4 enables another even more interesting project to be completed. Namely the Web Client Software Factory 2.0. This project hasn’t been able to ship, due to some issues in GAX/GAT. But now the problems are solved and WCSF 2.0 is just around the corner according to Glenn Block from the P&P group. The latest news on Glenn’s blog was that WCSF 2.0 is shipping sometime this week!!!

If you don’t know what the WCSF project is all about and why I think this is important news, I strongly encourage you to check out the WCSF CodePlex site. I also encourage you to check out the other software factories such as the “Web Service Software Factory” or the “Smart Client Software Factory”.

Final release of XNA Game Studio 2.0!

2007-12-13T23:47:00.002+01:00

Take a look at this post from the XNA team. As the title might indicate they just released the final (RTM) version of XNA Game Studio 2.0. Unfortunately this version of XNA GS "only" works against any VS2005 version, it's still a step up from the express only version we had earlier, but I'm still looking forward to getting rid of VS2005 and start using VS2008 exclusivly. Atm, only XNA GS 2.0 and Resharper is keeping me from that goal and I hope that both of these issues will be resolved before Q2 2008.

Download XNA Game Studio 2.0

The Blogger-FeedBurner-Reader triangle of pure blog power

2007-11-12T11:16:00.000+01:00

I recently moved my blog from the Danish .NET community DotNetForum.dk to Blogger.com. The reason for doing this was that Blogger is an extremely customizable blog engine and after Google has acquired Blogger I bet that the reliability, quality and performance will get a significant boost.

The second reason for moving to Blogger is another Google acquisition, namely FeedBurner. I was already using FeedBurner on my old blog but since Google now owns both Blogger and FeedBurner I bet the integration story between those two technologies will be much better in the future. So I’ve simply positioned my blog in a spot that I expect will provide the best/most features, as well as high reliability, quality and performance.

To top that off Google also has the awesome Google Reader application which also integrates nicely with both Blogger and FeedBurner. This integration story will also just get better as time goes on.

The conclusion is that I think that Google has started a very powerful blogging story now and it has only just begun…

How about LinqToStrings?

2007-08-21T23:22:00.004+02:00

I was playing around with Orcas Beta 2 and Linq queries just now and I thought of a new way of (mis)using linq queries... Check it out:

string text = "Johannes Hansen, 1980";

var query =
  from c in text
  where !Char.IsSeparator(c)
  group c by Char.ToUpper(c) into charGroup
  select new
  {
    Char = charGroup.Key.ToString(),
    Count = charGroup.Count()
  };

query.ForEach(item => Console.WriteLine("'{0}' occurs {1} time(s) in the string", item.Char, item.Count));

The output of this code is:

'J' occurs 1 time(s) in the string
'O' occurs 1 time(s) in the string
'H' occurs 2 time(s) in the string
'A' occurs 2 time(s) in the string
'N' occurs 4 time(s) in the string
'E' occurs 2 time(s) in the string
'S' occurs 2 time(s) in the string
',' occurs 1 time(s) in the string
'1' occurs 1 time(s) in the string
'9' occurs 1 time(s) in the string
'8' occurs 1 time(s) in the string
'0' occurs 1 time(s) in the string

So, are LINQ queries useful as a practical way of doing string parsing? Not really, no... At least I don't think so. However, it demonstrates that linq can be used for other scenarios than databases and xml. Also, please note that the "ForEach" extension method was implemented by me. It also doesn't really serve any useful purpose other than to test extension methods... It's implemented like this:

public static class CustomExtensions
{
  public static void ForEach<TSource>(this IEnumerable<TSource> source, Action<TSource> action)
  {
    if (source == null)
      throw new ArgumentNullException("source");

    if (action == null)
      throw new ArgumentNullException("action");

    foreach (TSource local in source)
      action(local);
  }
}

Without the "ForEach" extension method the last line of the first example could have been written as:

foreach (var item in query)
  Console.WriteLine("'{0}' occurs {1} time(s) in the string", item.Char, item.Count);

And so it begins... The quality pitfalls of the .NET compatibility strategy

2007-02-28T05:02:00.004+01:00

"The .NET framework is awesome." That has been my position for a few years now and probably will be for many years to come. Microsoft has done a great job of naming and segmenting the various classes and types into logical namespaces and type libraries. They are also holding true to the promise that backwards compatibility is key, which usually is a good thing. But unfortunately this rigidity is starting to degrade the tidiness and quality of the framework.

As time goes by and innovations are made in the field of software development, various improvements are realized and implemented. However, because all the good names already are taken, the additional features in the framework are beginning to degrade in naming quality and the overall tidiness of the framework is suffering.

One example could be the good old (original) DataGrid which got a new and improved little brother in ASP.NET 2.0 called the GridView. Now we have two grids, one of which is only left due to compatibility issues. In future editions of the .NET framework we will have to deal with extended/improved siblings such as the ListView vs. DataList and TimeZone2 vs. TimeZone. Personally I would rather have the various teams make a clean cut and stop cluttering the various namespaces with classes with similar functionality and names. Also, I don't mind them correcting some of the past mistakes as seen in the .NET framework "hall of shame". Maybe compatibility features could be pulled out into a separate library, like "System.Compatibility" (A "Sample.Web.UI.Compatibility" namespace were introduced in the first ajax release as a temporary validation bug fix). This could hide features for new development while making it easy for older applications to upgrade without having to rewrite the entire app.

I realize that this strategy poses migration issues to development teams but tool support is often making migrating from one framework version to another hard if not impossible anyways. Also, when migrating from one version to another you do it with the intent to change the code to use new features anyways. Just to be clear, I don't mind backwards compatibility as long as it doesn't hurt the quality of the framework.

What do you think?

References:
ListView: http://www.asp.net/learn/webcasts/view.aspx?tabid=63&id=48
TimeZone2: http://blogs.msdn.com/bclteam/archive/2006/10/03/System.TimeZone2-Starter-Guide-_5B00_Kathy-Kam_5D00_.aspx

Patterns & Practices: Web Client Software Factory released!

2007-01-14T06:48:00.008+01:00

Så blev P&P gruppen i microsoft endelig færdig med deres seneste (mindre kendte) software factory til web clients (WCSF). Yipiie!!!

WCSF er pakke guidelines til hvordan p&p gruppen mener man kan bygge en web applikation op hvor man holder de forskellige lag i applikationen adskilt vha. det kendte MVP software pattern. WCSF er baseret på ASP.NET 2.0 men bruger også .NET 3.0's workflow foundation komponent til at styre dele af navigationen i en applikation med (kaldet PageFlow). Pakken integrerer sig med VS2005 og giver lidt ekstra hjælp til at oprette solutions, views, controllers og hvad der ellers måtte være af sære klasser...

Dokumentationen til WCSF er meget spændende læsning og jeg vil stærkt anbefale alle der laver web applikationer som et levebrød at tage et kig på WCSF. Man skal jo ikke følge det til punkt og prikke men det kan da i det mindste give lidt stof til eftertanke.

WCSF Home: http://www.codeplex.com/websf
WCSF Download: http://www.codeplex.com/websf/Project/FileDownload.aspx?DownloadId=5532 (doc included)
Separate WCSF docs Download: http://www.codeplex.com/websf/Project/FileDownload.aspx?DownloadId=5531

Windows Vista speech recognition

2006-12-01T18:41:00.006+01:00

This message was written using speech recognition in Windows vista. Speech recognition in Windows Vista has been improved immensely over competing products. Unfortunately speech recognition doesn't recognize danish as of yet.

Kind regards,
Johannes Hansen