After you finally manage to get Table Storage working (see nice tutorial here) you’ll try to deploy it to your staging environment. That means you need to change the configuration.

There are three settings to use: AccountName, AccountSharedKey and TableStorageEndpoint.

Unfortunately, the values you need for them aren’t what you would naturally expect.

AccountName: This isn’t your account name, but the name of your storage account. (I guess that’s why it has to be a unique name at the time you create it.) On the summary page of your storage project you will only see the value you need in the list of endpoints. It’s the first part of each of the three domain names.

AccountSharedKey: This is the Primary Access Key as found in the summary page of your storage project in the developer portal.

TableStorageEndpoint: This isn’t the endpoint as described in the summary page, but rather a shortened version. Just lop off the AccountName part of the endpoint you use as described in the summary page. That should give you something like http://table.core.windows.net.

For more information see this article on MSDN.

It is so time-consuming to get right, that it really makes sense to follow the advice in the documentation. First, test locally. Then test your local hosted app using the live Storage account. Finally, load your app and test that in the staging environment.

Saying that, I haven’t yet managed to get the second scenario to work. It just crashes on start-up. (Help!)

I started to learn how to use the Azure Cloud Service from Microsoft this week. Currently it’s still in Tech Preview stage. Unfortunately you can tell that from the SDK documentation.

Here’s some useful links to get you going:

1. Screencasts: http://msdn.microsoft.com/en-us/azure/dd439432.aspx
   These are quite basic, but trust me, you need them to be basic to get you started.
2. SDK: http://www.microsoft.com/downloads/details.aspx?FamilyID=80e3eabf-0507-4560-aeb6-d31e9a70a0a6&displaylang=en
   Contains CHTM-style documentation, tools and samples. Don’t expect too much from the docs; they explain enough to get you confused, and then have an API reference. You need to unzip the samples and get into them to start understanding how everything fits together.
3. Visual Studio Templates: http://www.microsoft.com/downloads/details.aspx?FamilyID=8e90b639-1ef0-4e21-bb73-fc22662911bc&displaylang=en
   This gives you a set of project and item templates which you can use to create and publish Azure applications. Don’t worry about the extra projects it adds to a solution, or the config files. You will learn more about them later.
4. The Azure developer center on MSDN: http://msdn.microsoft.com/en-us/azure/default.aspx

Assuming you already registered for Azure, that’s all you really need to get started.

The biggest problem I found at first was deploying an app. Once you have generated an Azure project in Visual Studio, you expect to be able to publish it from Visual Studio too. Unfortunately you can’t, and it takes a little more effort. I’ll write more about that in another post.

I also needed help trying to understand what to focus on to get started. So here’s a big tip: Ignore .Net Services, Live Services, and SQL Data Services. They aren’t part of Azure per se. You can come back to them later. First you just need a hosted project and some storage – either blob storage or table storage. (There’s also queue storage, but I bet no one will want to use that straight away – it’s for tying two apps together, which no one will want to do at first.)

I recommend you download the SDK and the Visual Studio templates, create yourself a “Web Role” project (which is really the equivalent of an ASP.Net project), and work on that. Then move onto table and blob storage. You can use the screencasts to help you.

Good luck getting started!

I’ve been very quiet recently. (I’m trying to not be so loud, Scott. ) You see, I’ve been writing a lot of ASP.Net code for a site I’m working on. And, to be honest, I’ve been having a lot of trouble. The source code for .Net has been very helpful, and I’ve learnt a lot about what’s going on under the covers of ASP.Net because of it.

(Note: I won’t comment here on the quality of the code I’ve found – I’ll leave that up to you to judge. But in any case, I’ve been trying to build on top of it.)

One thing I’ve found to be important is the reliance on Web Controls. (It’s got something to do with javascript libraries, but that’s another story.) Getting away from the "standard" way to do ASP.Net isn’t easy though. Even the ninjas on the ASP.Net MVC team seem to be having trouble. However, with the magic of lambdas and extension methods in C#, I think I might have just about managed to get something usable. I thought I’d publish my work here, and see what comments I got.

I think it’s best to start with what my ASP.Net code looks like once I’ve got everything working. (Notice I still have some Web Controls in there, but that’s because I’ve not worked out how to do sorting of data without web controls yet.)

The inspiration for this was taken from the improvements made to NVelocity by the gurus on the Castle Project. I thought it looked great, and I’d like something similar, but I didn’t really want to learn a whole new scripting language and integrate it into my working environment just for rendering a bit of HTML. So I built some C# classes to do a similar thing for me instead. It’s not as nice as NVelocity, but it’s okay for now.

Warning: The following code may contain statements of a disturbing nature to more sensitive readers. We cannot be held responsible for any confusion, delusion or mental illness caused by this code.

It starts by taking a collection of Task objects, and calling the extension method "ForEach" on them:

<% Tasks.ForEach(sections => {
   sections.NoData = tasks => {
%>
   <p>
   Hey, you've got nothing to do.</p>
   <p>
<%
   };
   sections.BeforeAll = tasks => {
   %>
  <table class="task-list">
    <tr class="task-list-header">
      <th>
        <asp:LinkButton runat="server" CommandName="Sort" CommandArgument="StartDate"
          Text="Started" />
      </th>
      <th>
        <asp:LinkButton runat="server" CommandName="Sort" CommandArgument="DueOn"
          Text="Due" />
      </th>
      <th>
        <asp:LinkButton runat="server" CommandName="Sort" CommandArgument="Priority"
          Text="Priority" />
      </th>
      <th>
        <asp:LinkButton CssClass="task-description" CommandName="Sort" CommandArgument="Title"
          Text="Description" runat="server" />
      </th>      <th>
      </th>
    </tr>
   <%
   };
     sections.Before = task => {
    %>
    <tr class="<%= this.tableCssClasses.Next() %>">
    <%
   };
   sections.Each = task => {
    %>
    <td>
      <div class='calendar calendar-icon-<%= task.StartMonth %>'>
        <div class="calendar-day">
          <%= task.StartDayOfMonth %></div>
      </div>
    </td>
    <td>
      <div class='calendar calendar-icon-<%= task.DueMonth %>'>
        <div class="calendar-day">
          <%= task.DueDayOfMonth %></div>
      </div>
    </td>
    <td>
      <%= task.Priority %>
    </td>
    <td class="task-title">
      <a href='<%= Href.For("~/Tasks/{0}/Show.aspx", task.ID) %>'><%= task.Title %></a>
    </td>
    <td>
      <asp:Button ID="Button1" runat="server" CssClass="button" CommandName="Delete" Text="Mark Done" />
    </td>
    <%
   };

   sections.After = task => {
    %>
    </tr>
    <%
   };

   sections.AfterAll = task => {
    %>
    </table>
    <%
   };
 });
%>

It might take a while to grasp what’s going on here. The code actually starts using an Extension method to IEnumerable that looks like this:

public static void ForEach<T>(this IEnumerable<T> enumerable, ForeachSectionSetter<T> sectionSetter) {
  if (enumerable != null) {

    if (sectionSetter != null) {
      ForeachSections<T> sections = new ForeachSections<T>();
      sectionSetter(sections);

      if (enumerable.Count() == 0) {
        if (sections.NoData != null)
          sections.NoData(enumerable);
        return;
      }

      if (sections.BeforeAll != null)
        sections.BeforeAll(enumerable);

      int itemIndex = 0;
      T previousItem = default(T);

      foreach (T item in enumerable) {
        if (sections.Before != null)
          sections.Before(item);
        if (itemIndex % 2 == 1 && sections.Odd != null)
          sections.Odd(item);
        if (itemIndex % 2 == 0 && sections.Even != null)
          sections.Even(item);
        if (itemIndex > 0 && sections.Between != null)
          sections.Between(previousItem, item);
        if (sections.Each != null)
          sections.Each(item);
        if (sections.After != null)
          sections.After(item);
        itemIndex++;
        previousItem = item;
      }
      if (sections.AfterAll != null)
        sections.AfterAll(enumerable);
    }
  }
}

The delegate ForEachSectionSetter is used by the calling method with a lambda expression. As a parameter it receives an ForeachSections object, which looks like this:

public class ForeachSections<T> {
  public Action<T> Each { get; set; }
  public Action<IEnumerable<T>> BeforeAll { get; set; }
  public Action<T> Before { get; set; }
  public Action<T,T> Between { get; set; }
  public Action<T> Odd { get; set; }
  public Action<T> Even { get; set; }
  public Action<T> After { get; set; }
  public Action<IEnumerable<T>> AfterAll { get; set; }
  public Action<IEnumerable<T>> NoData { get; set; }
}

The calling method gets the chance to set the properties of this class before it is returned to the constructor of the ForEach method for processing. And because each property is already preset to a default value (Null in this case), the constructor can use the ForeachSections object just like a set of default or optional parameters. The caller can simply set values to the properties it needs, and ignore the rest.

If I had tried this another way, using overloadable constructors, it would have led to multiple constructors with indistinguishable signatures. If I’d have used property initializers, I wouldn’t have been able to run the whole routine without requiring a second call to the object, which actually wasn’t possible.

Basically, I couldn’t think of another way to do it.

The properties of the ForeachSections object are all delegates too. That means that we can use them with lambdas, which gives us lambdas inside of a lambda. (Hmm, very confusing!)

So what do you think? Could you use something like this? Can you make it simpler? Leave me a comment if you can.

.Net 3.5 had some nice tricks in it. LINQ-to-XML was one of them. With the new "X"-types, you can make working with XML really easy.

VB.Net 9 takes it one step further, and lets you write XML in your code without strings.

"Hey Rich, that’s old news," I hear you say. "And who’s interested in VB today anyway?"

Well, apparently there are a lot of VB-er’s still out there. I am mainly a C# developer myself, but I found that VB was perfect for a problem I had recently -  loading of XML data into a SQL Server table.

SQL Server 2005 and XML Fields

I recently came across the need to load a database with XML data fields in SQL Server 2005. I had a series of XML documents which all needed to be pumped into a table containing a field of type XML. I could have opened up SQL Server Management Studio and fired in a load of strings, but I was a bit concerned that the XML might not be formatted quite correctly, which would have caused problems in the loading process.

Another problem was that I wanted to be able to add dynamic XML. I wanted to generate some XML data on the fly. That’s not so easy with insert statements in SQL.

LINQ-to-SQL and XML Fields

Using my recently-acquired LINQ-to-SQL knowledge, I knew that the Entities generated for an XML field are translated to XElements – the new XML type in .Net 3.5. I also knew that VB 9 lets you create an XElement by using XML in code itself:

So I came up with a plan…

Inserts with LINQ-to-SQL

For data-loading, LINQ-to-SQL is magic. A simple Insert is a piece of cake.

First, create your DataContext using the Visual Studio template, then drag the table you are inserting to onto the DataContext canvas. That gives you an Entity class. You then can create an Entity in your code, call InsertOnSubmit on the DataContext table, then call SubmitChanges on the DataContext itself.

Using Object Property Initializers, you can make this really easy.

Here’s what it looks like with VB.Net using an XML datatype:

(Sorry to have torn the edge off the code there, but it wouldn’t fit nicely in my post at full width. XML can be a little long sometimes.)

The great thing here is that any malformed XML is highlighted (or even automatically corrected) for me by the VB compiler. I can also add parameters and generate lots of different XML using the familiar ASP syntax:

It’s all super-easy, and takes about 1 minute to get started.

Have you wondered if and when you should use the new LINQ features in .Net 3.5?

Like, where should I put a new extension method? Should I use Func<T> or a custom delegate? How do I best implement a mix-in (extension methods on an interface)?

Well, Mircea Trofin has just published a new draft of some LINQ design guidelines. You might just find your answers there.

While surfing around tonight, I came across ExtensionMethod.net, a database of useful Extension Methods for C# 3.0 and VB 9. I thought it might be useful, so I added a few of my own extension methods.

• IComparable<T>.LessThan
• int.Times
• int.To

There aren’t many there yet, but there are one or two on there from Scott Guthrie.

Have you got any code you could put up there? You could be one of the first if you go now.

Visual Studio 2008 has lots of goodies in it, like LINQ syntax, CSS editing, and testing tools. There’s a lesser-known feature which I really appreciate though – the “Remove and Sort Usings” command in the C# editor.

You activate the command by placing your cursor over the using statements and clicking on the right mouse-button.

Using this groovy tool, I’ve been able to go through my old ugly C# files and get rid of all the superfluous using statements, then tidy them up, all at the click of a button. It’s something I always wanted to do, but had no time for, and didn’t want to pay for an extra tool to do it for me.

The only problem with the feature is that you have to go through every file and right-click on the “using” statements to tidy them up. That can get a bit tedious, but it’s worth it.

But now it’s the Visual Studio Extensibility Team to the rescue!

The VSX team at Microsoft have just released PowerCommands for Visual Studio 2008. It’s a free tool for Visual Studio with loads of new tools for making a VS-developer’s life easier. And one of those new tools is a Remove and Sort Usings command at the project level.

You activate it with a right-click on the project itself.

The tool then does the same Remove and Sort command for every file in the project.

Tip: Make sure your project is buildable before using the tool. If there is an error stopping the build from running, you will get dialogs asking you to confirm every change in every file.

PowerCommands for Visual Studio 2008 also contains commands for:

• Collapse Projects
• Copy Class
• Paste Class
• Copy References
• Paste References
• Copy As Project Reference
• Edit Project File
• Open Containing Folder
• Open Command Prompt
• Unload Projects
• Reload Projects
• Remove and Sort Usings
• Extract Constant
• Clear Recent File List
• Clear Recent Project List
• Transform Templates
• Close All

So, where can you get the tool?

The official site for PowerCommands is at the Visual Studio Gallery, but when you get there, you won’t see a download button. You actually have to click the “Learn More” button to go to the download page at the MSDN code gallery.

You can read more about PowerCommands on the Visual Studio Team Extensibility blog.

I was recently reading Programming Ruby: The Pragmatic Programmers’ Guide, Second Edition, and came across this piece of example Ruby code:

[1,3,5,7].inject(0) {|sum, element| sum+element} -> 16
[1,3,5,7].inject(1) {|product, element| product*element} -> 105

Inject is a method which acts on an array by aggregating or accumulating the values within that array. It loops through the array, and for every item in the array, it performs a function. It then saves the result for the next iteration of the loop and eventually returns the aggregated value.

In C# 1.0 you would probably write such a method like this:

int sum = 0;
int[] list = new int[] { 1, 3, 5, 7 };
foreach (int item in list)
{
  // Perform some function, then save the result
  sum = sum + item;
}

It’s a bit long-winded, and if you wanted to make it reusable, you’d have a hard time.

In C# 3.0, you can do it just like you can in Ruby.

Defining the Aggregation

First, let me explain how the Ruby inject method works.

First of all, it’s really misnamed in Ruby. The method is an aggregator, or even an "accumulator". It aggregates or accumulates values. It takes two parameters – a starter value, and a block. In C# 3.0 we basically call a block a delegate, although in this case, it’s more like a Lambda Expression.

The inject method works like this:

1. it takes the starter parameter and sets the aggregated value (the sum in the above example) to its value.
2. For the first item in the array, it passes the tarter value and the item itself to the block, which then performs the defined function on it.
3. The return value from the block is then assigned to the running aggregated value.
4. The running aggregated value is passed into the next iteration with the next item from the list. The function is called on those items again.
5. When the method has iterated over all items in the list, it returns the aggregated value.

Moving to C# 2.0

So, let’s imagine you were trying to write the Inject method in C# 2.0. If you were to refactor the above C# 1.0 example as C# 2.0, you might use anonymous methods to write this:

// Define a delegate
delegate int Aggregator(int sum, int item);

static void Main(string[] args) {

  int sum = 0;
  int[] list = new int[] { 1, 3, 5, 7 };

  sum = Inject(sum, list,     delegate(int starterVal, int item) {
      return starterVal + item;
    });
}

int Inject(int starterVal, int[] list,
           Aggregator aggregator) {
  int sum = starterVal;
  foreach (int item in list) {
    // Perform some function, then save the result
    sum = aggregator(sum, item);
  }
  return sum;

However, that would only work for int objects. You could really make it generic, and use the same method for other types:

// Define a delegate
delegate T Aggregator<T>(T sum, T item);

...

  sum = Inject<int>(sum, list,
     delegate(int starterVal, int item) {
      return starterVal + item;
    });

...

T Inject<T>(T starterVal, T[] list,
  Aggregator<T> aggregator) {
  T sum = starterVal;
  foreach (T item in list) {
    // Perform some function, then save the result
    sum = aggregator(sum, item);
  }
  return sum;
}

It’s nicer, but the Ruby method still wins hands-down for neatness.

Move Over Ruby, Here Comes C# 3.0

The good news is, the C# 3.0 compiler and the .Net 3.5 framework can now take care of most of this for you.

To start with, the Aggregator delegate is no longer necessary, because the new Func<T,T,T> delegate already defines a generic delegate which returns a value.

T Inject<T>(T starterVal, T[] list, Func<T,T,T> aggregator)

Secondly, the anonymous function using the delegate keyword can be replaced by a lambda expression like this:

(starterVal, item) => starterVal + item

Thirdly, the Inject method can be defined as an extension method so that you can call it like this:

sum = list.Inject(sum, (starterVal, item) => starterVal + item );

And fourthly, the compiler can infer the type for you, so you don’t need to specify it on calling the method.

The Aggregate Method

But the even better news is that this method is already defined in the .Net framework for you, so you don’t even have to write it. Instead of being called inject, it’s called Aggregate, and is defined on the System.Linq.Enumerable<T> class.

So basically, using C# 3.0, you could reduce the above code to this:

var sum = 0;
var list = new[] { 1, 3, 5, 7 };
sum = list.Aggregate(sum,
                     (starterVal, item) => starterVal + item );

You get an extra bonus point if you spotted the extra C# 3.0 features I sneaked in there – the var keyword, and array initializers.

C# 3.0 is pretty neat huh? Move over Ruby.

One of my favorite bloggers is Matt Berseth. Nearly once a week he comes up with a post where he does something amazing with the standard ASP.Net controls. I usually read his posts in awe. He’s really good.

But he’s not only is a good developer, he’s a great writer. Even though his posts are concise and straight to the point, most of them are pages long. You can really learn a lot from following his instructions.

He’s so good, in fact, that he regularly gets a mention on Scott Guthrie’s posts.

One of my favorite posts of his was where he used LINQ-to-SQL, a LinqDataSource control, and an ASP.Net ListView control – all new in .Net 3.5 – and made a grid with grouping functionality. He did it all in a standard way, and didn’t use any funny tricks.

Here’s a link to the article:

Building a Grouping Grid with the ASP.NET 3.5 LinqDataSource and ListView Controls

Enjoy!

Yesterday I thought I’d learn about the LinqDataSource in ASP.Net 3.5, and got an interesting surprise.

The new LinqDataSource can also be used with a LINQ-to-SQL model to perform updates. You simply add the DataSource to your page, set the table name, and set EnableUpdate to true. Then, using a standard DataControl, you can make updates to your data entities.

The question is, how does this work? It appears to be a bit magical.

The Magic of LINQ

In a previous post, I mentioned that LINQ-to-SQL updates can be done in two ways: either you make a call to retrieve a row, then update it, or you provide known values for all fields and try to update using optimistic concurrency.

If the LinqDataSource used the first technique, the performance might be bad. Plus, it would have to only update those fields that had been updated by the DataControl, and ignore the rest. That wouldn’t make sense, so I correctly supposed that was not what was happening.

It makes more sense that the LinqDataSource would use the values input by the user to make the changes. It could use optimistic concurrency to compare all the entered values.

The problem is, I don’t always display all fields from a particular row on the form, so how would the LinqDataSource know what the missing fields were. Remember, all the fields involved in the update are required for the optimistic concurrency to work. That is usually all the fields in a row, and they aren’t usually all displayed.

So, have a guess. Where does the LinqDataSource store it’s values?

Let’s think now. Where would be the easiest place to keep it? To keep it really simple, I’ll let you ignore all other aspects of building an application, like security or performance.

Yep, you guessed it – ViewState.

The ViewState actually contains all values for all the fields in a LINQ-to-SQL entity by default. Those values are sent to the client, even if the user isn’t supposed to be able to see them.

Aaaarrgghhhh!

Now, let’s not get overexcited. The ViewState is encoded, so it’s not easy to just go and change it. But it’s not impossible. In general, I don’t think it’s such a great idea to have all data sent to a client by default. Someone is going to overlook something one day, and there’ll be a costly mistake.

And what if you display a large grid using the LinqDataSource. Well, you aren’t just getting the ViewState from the grid sent back and forth with your page, but the LinqDataSource is going to store all your data retrieved in the ViewState too.

Bummer!

Great control. Large overhead.

Kicking out the ViewState

The good news is that the ASP.Net team realized that this was a problem and did something about it.

If you look carefully, you will notice that the LinqDataSource has a property StoreOriginalValuesInViewState. By default (sigh) that property is set to true. If you set it to false, the control won’t work any more. Simple as that.

Here’s what the official documentation has to say about that:

If you set the StoreOriginalValuesInViewState property to false, the original values are not persisted in view state for the data-bound control. In that case, LINQ to SQL cannot verify the integrity of the data. LINQ to SQL will throw an exception that indicates a data conflict even if the data in the data source has not actually changed.

That’s in the remarks section of the LinqDataSource.StoreOriginalValuesInViewState property documentation.

Funnily enough, the same section states the problem with stuffing data into the ViewState:

Storing the original values in view state can cause the page size to become unnecessarily large and can expose sensitive data to a malicious user.

Now, I don’t know about you, but that looks like a pretty serious warning to me. Why isn’t it in a more obvious place, like as a comment that pops in up Intellisense whenever you use a LinqDataSource?

Check the UpdateCheck

So how do you handle it? How can you use the LinqDataSource?

The answer lies in the generation of the LINQ-to-SQL model which you generate. Each entity field has a Column attribute which allows you to specify if it is used for checking during an optimistic concurrency field comparison.

For example, you could create a Model with the following Property:

[Column(Storage="_AddressID", UpdateCheck=UpdateCheck.Never, ...
public int AddressID
...

Notice the UpdateCheck.Never value. That means that the field will not be used in the optimistic concurrency check.

The documentation helps a little again:

By default, when update and delete operations have been enabled, the LinqDataSource control stores the original values for all the records in view state. The LinqDataSource control stores values for all primary keys and all properties not marked with UpdateCheck.Never in the Column attribute. You set the UpdateCheck property of the Column attribute in the O/R Designer.

Admittedly, I haven’t yet tried that, so I don’t really know how if you can change that setting for a field without changing generated code, which would be a big no-no. I’ll just have to get back to you on that.

Stamp In, Please

However, there is a shortcut trick.

Basically, if you add a field of type timestamp to your record, only that field will be used for the concurrency check, and only that field’s data will be stored in the ViewState.

If the underlying data source contains a timestamp field that is automatically updated during an update, you can store only that value in view state. In that case, the timestamp property in the entity class is set to IsVersion=true and all the properties are set to UpdateCheck.Never. Because a timestamp field is automatically updated by the database every time that data in that record changes, LINQ to SQL determines from that value if data has changed. This helps reduce the size of view state, and no sensitive data is exposed. LINQ to SQL will check for data consistency by comparing the timestamp value in view state with the timestamp value in the database.

The documentation is great, if you know where to find it.

Conclusion

So, the answer is, if you use the LinqDataSource to throw a quick application together, make sure you use a timestamp field in your table. Call it UpdatedOn, or something. It will make the use of the LinqDataSource a lot easier, if only because you’ll sleep better not worrying about it.

Silverlight, ASP.Net Ajax, LINQ, Astoria, ASP.Net MVC – there’s just tons of stuff coming out of Microsoft. And that’s not to mention the stuff people have seemingly forgotten about – ASP.Net Futures with IronPython (AWOL), Patterns and Practices Web Client Software Factory, WPF, WF, WCF and CardSpaces. Now the trend seems to be functional programming languages, especially with F#.

There’s just a bit too much for me.

What I really need is guidance. My customers don’t ask me what to they should use in 6 months; they ask me how to use what already exists. They don’t want “cool”; they want stability and consistency. And while the ball keeps moving, we can’t grab it.

Take for example, the ASP.Net Futures framework. I recently took over a project where it had been used. I checked to see what was available now – nothing! It seems to be dead. I’ll have to rip it out of the project, somehow. Major headache!

MSDN Patterns and Practices have produced some great stuff recently. Policy Injection, ObjectBuilder, PageFlows, Validators; but it’s completely ignored, as no one has a chance to look at it because of all the other stuff grabbing their attention. Well that, and the fact that it looks a bit overengineered.

While this is happening, and the cool guys are playing with all the new stuff, the guys on the ground are wondering what they should learn and what not. LINQ is hard enough to learn, and most developers haven’t even looked at the near 18-month-old WF suite yet. There just isn’t time.

I recently heard Dino Esposito say the same thing. I heard him on DotNetRocks bemoaning the fact that Microsoft seems to have abandoned ASP.Net Ajax to chase after Silverlight. They could have made ASP.Net Ajax absolutely fantastic, but aren’t doing anything about it any more. Seems like it’s finished.

But above it all, the MVC Framework just tips the scale for me.

Let me start with some history. About 18 months ago, I heard Scott Hanselman say in his podcast that Ruby On Rails was the framework that Scott Guthrie and Microsoft should be worried about. I agreed. In fact, I went and learnt Rails because of that. I found it was really good, just like he said (apart from when you try to get a site deployed, at which point you need a degree in Rocket Science or a great hosting company. I had neither.) But the concepts I learnt from Rails were very interesting. I tried to apply them in my work.

Enter SubSonic. Rob Conery made a great implementation of the ActiveRecord pattern from Rails for .Net and called it SubSonic. He even included some of the syntactic sugar that makes Rails fun. It is a great framework, and I suggested to some customers that they use it. They tried. They failed. I asked them why, and they answered that it just didn’t go far enough. They went back to using DataAdapters.

Rob and Scott both work for Scott Guthrie now. They seemingly focus on the ASP.Net MVC Framework, which, unsurprisingly, is a blatant attempt at a copy of Rails.

Whether or not it’s a good framework (and I think it is), the problem is, I need some features for the stuff I’ve already got. I might need Routes (ala Rails) for my ASP.Net apps; I don’t need a complete new system for building pages. It just took me 3 years to learn ASP.Net as it is now. I don’t want to throw it all away because it’s not cool any more. And I don’t think my customers want to do that neither.

Why not make ASP.Net better? Why not take the stuff in Patterns and Practices and make it simpler to understand. That’s what happened with C-Omega and C#3.0. The good stuff from a research project found its way into the next version of the more popular language. Thumbs up to Anders!

I think that Microsoft could actually do a much better job at Rails than DHH did. Sure, he gave them a kick in the butt, but that’s a good thing.

Rails has things in it which we don’t need in ASP.Net. Multiple views are often necessary for creating REST API’s – how often do ASP.Net developers do that? If we do, we have business objects and other ways to support an API. Routes using controllers is for nice-looking URLs, especially useful for search engines – how many pages of our sites do most ASP.Net developers want to post to search engines? MVC is to make it simpler to control what goes into markup, and what goes into a view – we already have MVP, which fits well in ASP.Net, and doesn’t lead to huge controller files. (What’s a controller anyhow?)

And don’t forget that Rails doesn’t have the concepts of security built in. It doesn’t have controls. Try integrating plugins – it’s not always easy. And despite the TextMate craze, the IDE is pitiful. You have to know Ruby well before you can do anything.

On the ASP.Net side, do we really want to kick out viewstate? It was put there for a purpose. Real-world website developers were having trouble managing the control of forms in ASP, and ViewState was a good answer. Rails doesn’t have that. It does everything with IDs in forms. Cool, but if it’s put into ASP.Net MVC, it means we’ll have to learn a completely new model to achieve the same purpose.

The real reason I’m peed off, is that I’m having to invent my own guidance, while MS seems to be messing about doing other things. That’s not good for the customers, as they get new ideas from everyone, and no idea what is right or wrong.

So guys, please. Why not stop what we’re doing, take a step back, consolidate, learn from each other, and build something better than ever.

Scott Hanselman just posted his latest article in his weekly source code series. He shows various ways of producing the Fibonacci Sequence using various languages. I found it really interesting, for two reasons:

1. I tried to do the C#3.0 one on my own after listening to a podcast about F#, and never could work it out. (Doh!)
2. It makes me question what I thought about coding.

You see, I spend a lot of time refactoring. Sometimes too much. I have to ask myself why. It’s usually so that I can come back to the code later, and still understand what I was trying to do. Most of the time, conciser is better. But not always!

And that’s what I see in this post.

Suppose I had written this C# function (shamelessly stolen from Scott’s post):

Func<int, int> fib = null;
fib = n => n > 1 ? fib(n - 1) + fib(n - 2) : n;

Compare this to the C# 2.0 version:

static int Fibonacci(int x) {
  if (x <= 1)
    return 1;
  return Fibonacci(x - 1) + Fibonacci(x - 2);
}

Apart from the fact that these methods actually give different answers (sorry, Scott), if I were to try to understand these methods 6 months after writing them, which one of the code samples would I be most glad of seeing again?

You see, most code only gets read again for two reasons:

1. to debug it, or
2. to hand it over to someone else

In both cases, clever though it may seem, the first conciser version would probably cause more trouble. Now, don’t get me wrong, I’m all for good concise code, but XSLT is concise, and I hate debugging that.

Now, considering that in order to reuse the Func<int, int> function, I would have to pass the around, thus holding it in a static variable, or wrapping it in another class, it doesn’t actually turn out to be that practical after all. Concise, yes. Practical and readable, hmm.

So, while we have a very-much-by-Ruby-On-Rails-driven trend going to make code as beautiful as possible, don’t forget to not go too far. We have to be able to read code later on, remember.

I am really getting into LINQ now! I think it’s fantastic. I recently wanted to develop a quick drop-down list in ASP.Net which allows a user to select a time of day from a list. The times are 15 minutes apart, so the list would look like this:

…
08:00
08:15
08:30
08:45
09:00
…

… and so on.

Before LINQ, I would have done this with a for loop, like this:

List<string> times = new List<string>();
for (int hour = 0; hour < 24; hour++)
  for (int minute = 0; minute < 60; minute++)
    if (minute % 15 == 0)
       times.Add(string.Format(
         "{0:00}:{1:00}", hour, minute));

That’s not difficult, although it’s not so easy to understand. I would have to write a small console app or test to make sure I had done it correct though.

I thought this might be a good opportunity to use LinqPad. It’s a great tool. You can use it to test a LINQ statement in a live window, so I thought I’d give it a go.

First I needed a LINQ statement to test.

Designing the LINQ Statement

The first thing I needed was an integer for the hour. That’s quite easy, especially if you use the Range Extension Method technique as I wrote about before. That method allows you to create an IEnumerable<int> from a simple statement, like 1.To(10). So to get the hours of the day, I can simply start with:

from hour in 0.To(23)

Now I need to do a cross-join with the minutes. In C# comprehension syntax, you do that by simply adding another from statement. At first, I thought I could do it by using an enumeration of minutes, specifying each value I wanted specifically. To do that I wrote this:

from hour in 0.To(23)
from minute in new[] {0, 15, 30, 45}

That works very nicely. I think it’s easy to understand too. Even if you were going to come back to it years from now, you could still easily see what is being done.

Another alternative is to do the same as the for statement above, go through the numbers 0 to 59, selecting only those which are divisible by 15. You would do that using another range and a filter:

from hour in 0.To(23)
from minute in 0.To(59)
where minute % 15 == 0

Again, I like the way this looks. Another developer should have no difficulty reading that.

To select the string, we will also use the same format as before, this time using the select keyword:

select string.Format("{0:00}:{1:00}", hour, minute)

You then simply assign the value of this statement to a variable, like this:

var times = from hour in 0.To(23)
            from minute in 0.To(59)
            where minute % 15 == 0
            select string.Format("{0:00}:{1:00}", hour, minute);

Using LinqPad to Test the Result

Now, if you haven’t already, go download LinqPad from here, and open it up. You will see a window to write a statement in the top right.

Before you continue, you need to add the extension methods to use my “To()” method. As a treat, just for you, here’s a simple assembly and a code file you can use straight away. Download it, save the binary dll somewhere, then do the following in LinqPad:

1. From the menu, click “Query”, then “Advanced Properties” (or press F4).
2. On the Additional References tab, click the “Add…” button.
3. Click the “Browse…” button on the window which pops up.
4. Go to the location you saved RichardBushnell.Extensions.dll to, and select it. You should see it added to the list of additional references.
5. Change to the Additional Namespace Imports tab.
6. Type “RichardBushnell.Extensions”
7. Click “OK”.

Now, put your cursor in the Query1 tab, and paste in the following:

from hour in 0.To(23)
from minute in 0.To(59)
where minute % 15 == 0
select string.Format("{0:00}:{1:00}", hour, minute)

Press F5, and you will see a generated list like this:

And that’s it! You can now see exactly what you will get when you run this code.

What do you think? I’d love to hear your comments.

When using LINQ, you need to be careful to use the right kind of Lambda expression. “What, there is more than one kind?”, I hear you gasp. There sure is! And if you aren’t careful, you’ll get a nice little message at runtime to tell you:

“System.Object DynamicInvoke(System.Object[])’ has no supported translation to SQL.”

What that literally means is “You’re not using lambdas right, you dummy!”

Let me explain.

A Refactoring Problem

Let’s start with my problem. I created a Controller class which uses a DataContext to check for an item in a database, and then, if the item was not found, it inserts one. The class looks like this:

  public class UserController {
    public void CreateIDUser(string ID) {
      var DB = new DBataContext();
      var existingUsers = from user in DB.Users
                          where user.ID == ID
                          select user;

      if (existingUsers.Count() == 0) {
        User newUser = new User();
        newUser.ID = ID;
        DB.Users.InsertOnSubmit(newUser);
        DB.SubmitChanges();
      }
    }
  }

The method uses LINQ C# Comprehension Syntax (“from user in DB.Users …”) to perform a query. It then uses the DataContext to do an Insert when the changes are submitted.

I created a unit test for this method, and it gave me a glowing green light.

Now, I want to add a similar method which uses a different property for comparison. The method would be identical to the first, except for the “where” query and the initialization of the new User object. I don’t want to repeat myself, as that might lead to bugs, so I want to refactor out the common code. I’m going to do it using lamda expressions.

Refactoring using lambda expressions

I could go into my design decisions here, but that’s not the point of this post. I’ll just give you the answer – what I want my class to look like.

Basically, I want to end up with 2 methods which only differentiate on the parts I need them too:

public void CreateIDUser(string ID) {
  CreateUser(
    user => user.ID == ID,
    user => user.ID = ID);
}

public void CreateNamedUser(string name) {
  CreateUser(
    user => user.Name == name,
    user => user.Name = name);
}

I create a private method called CreateUser which does the repetitive work:

private void CreateUser(Func<User, bool> compare, Action<User> initialize) {
  var DB = new DBDataContext();
  var existingUsers = from user in DB.Users
                      where compare(user)
                      select user;

  if (existingUsers.Count() == 0) {
    User newUser = new User();
    initialize(newUser);
    DB.Users.InsertOnSubmit(newUser);
    DB.SubmitChanges();
  }
}

Now, this compiles, but when I run my existing test, I get a nasty red light, and the exception message:

“System.Object DynamicInvoke(System.Object[])’ has no supported translation to SQL.”

What’s wrong? The problem lies in the query itself, which is using expressions, not pure delegates. My Func<User, bool> cannot be used by LINQ to SQL to do its work. Instead, I have to use an Expression.

Using an Expression<Func<T, bool>>

Instead of a simple “Func<User, bool>”, I have to declare my parameter as “Expression<Func<User, bool>”. That is what LINQ to SQL expects to use for deferred queries. The good news is that I can use an expression by defining it in the method accepting the lamda; the C# compiler can translate my existing lamda expressions from delegates to expressions without any extra work.

Once that’s done, there’s one more caveat. You cannot use C# comprehension syntax with an expression. You have to use the standard LINQ query syntax instead.

Here’s what the final class looks like after the refactoring.

public class UserController {
  public void CreateIDUser(string ID) {
    CreateUser(
      user => user.ID == ID,
      user => user.ID = ID);
  }

  public void CreateNamedUser(string name) {
    CreateUser(
      user => user.Name == name,
      user => user.Name = name);
  }

  private void CreateUser(Expression<Func<User, bool>> compare, Action<User> initialize) {
    var MeetUp = new MeetUpDataContext();
    IQueryable<User> existingUsers = MeetUp.Users
      .AsQueryable<User>()
      .Where(compare);

    if (existingUsers.Count() == 0) {
      User newUser = new User();
      initialize(newUser);
      MeetUp.Users.InsertOnSubmit(newUser);
      MeetUp.SubmitChanges();
    }
  }
}

After that, I get my green light back, and we’re all happy.

While creating a little project, I wanted to know how to insert an object into a table using LINQ to SQL. Using Intellisense it wasn’t obvious at all.

Scott Guthrie wrote a post on how do it. Unfortunately, the method name has changed since he did it, so you need to call InsertOnSubmit on the Table instead of Add, as he described it.

Phew! Getting that far was hard enough!

I was recently asked to do some research and give a presentation about using Visual Studio Team System 2008. I thought I’d experiment with Slideshare.net and post it here.

The presentation was for a large corporation, and will possibly not come across as being very useful for an online presentation. I have been working on it for a while though, and I think it’s worth publishing, if only as an introduction.

I’ve used competitive products to Team System for a long time, mainly open source:

• SubVersion for source version control
• CruiseControl.Net as a build server
• NAnt for build scripts
• MbUnit for testing
• NCover for seeing my testing code coverage
• VersionOne for project planning, task management, tracking and reporting
• BugTracker for bug tracking
• A Wiki for project documentation and guidelines

I wasn’t all-too impressed with the standard of Visual Studio Team Suite 2005, but I am a little bit happier with the 2008 version. It took a while to get it installed so that I could test it, and there were lots of seemingly undocumented points which hindered my progress, but once I’d got it up-and-running, I didn’t find it that bad. (I did have to install it on  virtual machine, and run it on my laptop.)

I think the best thing about Team System is that all the things I need to do are now integrated into one place. I didn’t have to go make changes to a dozen XML files in order to get a build server working. I didn’t have to install a Wiki for the project documentation. Using Team System would also avoid resistance to using the products, as I’ve faced before trying to get other team members to use such tools. Everything would just be there, out-of-the-box, and no one would argue about using them.

What I didn’t like about Team System are some of the subtle details which don’t work as they should do. I did a basic test of multiple check-outs, using the new features, but it didn’t work. The Unit Tests that I generated were confusing and were buggy.

The biggest problem though is the price. It’s darn expensive. I wouldn’t be able to afford Team System if I was just a small development shop. However, for a large corporation, it really could make sense.

I actually wonder if there’s room for a better competitor (Rational is possibly the only serious contender, and I find their software pretty naff). It actually wouldn’t to be too hard for some Python hackers somewhere.

One of the biggest questions with Anonymous Types is “can I pass them around?” If not, why not? Can you do something like this, for example:

var GetAnonymousValue() {
  return new { Name = "Richard Bushnell" };
}

void Main() {
  var value = GetAnonymousValue();
  var name = value.Name;}

The answer is simple: no, you can’t pass anonymous types across functions. var is not a dynamic variable, like in JavaScript. The CLR knows nothing about “var”, as the compiler just uses it to infer types when a variable is initialized.

At least, that was the answer until now. Using a simple extension method and generics, Alex James just showed a nice way to pass them around on his blog.

The trick is to use an example of the anonymous type you expect.

object GetAnonymousValue() {
  return new { Name = "Richard Bushnell" };
}

void Main() {
  var value = GetAnonymousValue().CastByExample(new { Name = "" });
  var name = value.Name;
}

While this might be a little dangerous, especially if you’re not testing your code regularly, this could be the solution to a few problems I can already think of.

Watch out for casting exceptions at runtime though! If you make a mistake anywhere, you’ll won’t get a compile-time exception, but a nasty runtime exception instead.

DotNetRocks, the internet talkshow for .Net developers, has a great show about development changes over the past 20 years. Carl Franklin interviews Kathleen Dollard, who has put a list of changes together, and is publishing them online.

If you want to know where you currently stand in your software development, you want to listen to this show. You might even want to take notes.

If you are recruiting developers, you also should listen to this show. You could use very effectively it to find out what kind of people you are interviewing.

The first 10 of 60 items on Kathleen’s list of changes are:

1. Parallel entities
2. N-Tier
3. Sheer magnitude
4. Application code generation
5. SOA (Service Oriented Architecture)
6. Semantics and canonical messages
7. Workflow
8. Rules engines
9. Aspect oriented programming
10. Impact of libraries

Every software developer or architect should know at least a little about each item on this list. If you don’t, maybe you could use this to pull your career up a level.