One recurring theme in that feedback has been around domain driven design, so among our other criteria we’ve put together an advisory council which includes some members with notable credentials in that area.

Eric Evans – http://www.domainlanguage.com/about/ericevans.html
Stephen Forte – http://www.stephenforte.net/
Martin Fowler – http://martinfowler.com/
Pavel Hruby – http://www.phruby.com/
Jimmy Nilsson – http://jimmynilsson.com/

Yes… I had to take a second look myself. That’s an impressive list I say!

Its just words on a web page at this point, but I think this speaks loud and clear that MS is listening to all the valuable constructive criticism that has been given from the community. I commend the Data Programmability team for making such a great move, but mostly all those who have stepped up to provide their insight.

Along with this announcement, Danny is also requesting that folks continue to keep providing feedback.

Frickin’ sweet!

If you have Visual Studio 2008 installed, you can find the samples in this directory: C:\Program Files\Microsoft Visual Studio 9.0\Samples\1033.  Then extract the file CSharpSamples.zip.  The sample will be found at CSharpSamples\LinqSamples\DynamicQuery.

From the sample you will see that you can do perform things like this:

var query =    db.Customers.Where(         "City == @0 and Orders.Count >= @1", "London", 10).
   OrderBy("CompanyName").
   Select("New(CompanyName as Name, Phone)");

All of the heavy lifting happens in the Dynamic.cs file that has 11 classes.  The interface happens through DynamicQuery static class, which extends the IQueriable interface with new Where, OrderBy, and Select methods.  To use these extensions you have to include this line in your code: using System.Linq.Dynamic; along with the Dynamic file in your project.

I don’t have a use for this quite yet, but I think its time will come.

So, a fellow coworker called me out on this: why am I returning collections other than IEnumerable<T> anyway? What conditions actually require the extensibility of Collection<T>, or the extra utility of List<T>? I didn’t have an answer for this off the top of my head, so over the weekend I created a new experimental branch of a project and started hacking interface signatures. What follows are some conclusions from the experiment.

Setting Up the Experiment

I replaced all the public signatures of IList, Collection, List, etc. with IEnumerable<T>. If it was a public API input or output, its now IEnumerable. Each signature change was followed by re-running all unit tests to make sure that nothing critical broke.

Conclusion: System.Linq makes IEnumerable<T> Useable

There were two major “breaking” changes found in this experiment. The first is that IEnumerable<T> doesn’t expose a Count property, but there are places where we need to know if the list is empty, has one item, has N items, etc.

Fortunately, this codebase was upgraded to Visual Studio 2008 and a .NET 3.5 target a while back. This gave me an opportunity to use the Count() extension method from the System.Linq namespace. First problem: Solved.

Next, there are cases where I’d need to access items in a collection by index. The native IEnumerable doesn’t provide this, but System.Linq does with extensions like First(), and ElementAt().

So, there’s two big reasons for not using IEnumerable<T> taken care of. These changes handled almost all of the collection issues I ran into.

Note: now I’m “stuck” with the .NET 3.5 target. Not a problem for me, YMMV.

[Test]
public void GetControls()
{
    // SetUp code omitted for brevity...
    var cat = new BrowsableUserControlCatalog();
    var controls = cat.GetRegisteredUserControls(); // IEnumerable
    Assert.AreEqual(1, controls.Count());
    Assert.AreEqual("virtualPath", controls.First().VirtualPath);
}

Conclusion: Sometimes you have to extend Collections

One of the reasons that the Framework Guidlines encourage Collection<T> vs. List<T> is that Collection is easily extended. I ran into one case where a class had been extended from Collection<T> in order to change the behavior of the InsertItem() and SetItem() methods. So we have a collection that requires the ability to add items to it. Even worse, we have methods added to this collection to provide additional required functionality: swap to items in the collection, reset the sorting index of the items, move an item up or down, that sort of thing.

So, that’s one collection that remained as-is. I can live with that. Perhaps on some other weekend, I could split the additional functionality out from that collection and into “something else,” which might have additional advantages. Something for next time..

Conclusion: Sometimes you have to Sort() [for now...]

One List<T> that I haven’t gotten rid of (yet) relies on a Collection<T> supplied by another component. We are getting a list of files, and putting them into a sort order based on what the user interface wants. The library has no idea what kinds of sorting options are available, the calling implementation can do pretty much whatever it wants. The element that varies is the sorting routine passed into List<T>.Sort().

System.Linq provides an .OrderBy() extension, but its signature doesn’t match up with List<T>.Sort()…which turned into more of a change than I wanted to deal with for this current experiment. Saved for next time…

So what have we learned?

Extension methods are fun. I look forward to abusing them heavily in all my new work. Because of them, its now possible to change 99% of this API to use the most general collection types possible.

But does it make sense to do so? I’m not totally convinced. It does simplify things. The semantics of what you can do with a given collection is much clearer. Most of the time, we only needed the abilities of IEnumerable<T>, and it makes sense to use the most generic interface you can get away with – especially for a platform where you can’t predict how these things are going to be used.

• Pull up object browser, set Browse to only show 3.5. (Will not work if you set to all components)
• Set the filter to ‘Show Extension Members’

• Select a type in the browser
• In the right pane you will see an ‘Extension Members’ folder
• Now you can browse the public type extensions

Before:

IEnumerable<TDomainEntity> domainEntities = Repository.Find(criteria);
IEnumerable<TDto> dtos = Assembler.DomainToService(domainEntities);
return new List<TDto>(dtos);

return Repository
           .Find(criteria)
           .ToList()
           .ConvertAll<TDto>(Assembler.DomainToService);

Point LINQPad at a SQL Server database and then you can write your LINQ queries right in the tool.  No having to deal with DataContext objects or any messy stuff like that.  It also works with LINQ to Objects and LINQ to XML; plus it comes with about 200 samples.   It reminds me a bit of the HQL Query Analyzer of Ayende’s — just a lot simpler to use.  The main point is that you can get nearly instant results from your query, which defiantly helps in that critical “getting to know you” stage with a new technology.

The only gripe I have with it right now is that intellesense isn’t implemented yet.  That is kind of like flying blind these days.  But who is to complain over a free tool like this.

Note:LINQPad  was written in conjunction with the book C# 3.0 in a Nutshell.

He also gives us a glimpse of what it is like to live your life visiting other people’s development shops. Did you know source control is stil optional in some organizations?

Chris is a true code craftsman and this shows in his clear explanations of some very advanced programming concepts. If you haven’t played with Lambda expressions, anonymous delegates, or LINQ, start with this podcast.

Download the episode MP3

The UI has received a little attention. You can see by the gradient colors on this properties dialog menu that someone on the Visual Studio team finally called someone over from the User Experience Group. Now, if those menus are so awesome, then I have a single window utility for working with unit tests, right?

Not so fast, Homer.

All kidding aside, there are some things to look forward to in Visual Studio. First of all, this is first version of Visual Studio to provide support for multiple frameworks out of the box. Here is a screen shot of the drop down on the Project Properties dialog that lets me target a specific framework.

Overall, Microsoft claims more than 250 new or improved features and I for one am content with the fact that this is a v.Next and not a v.NewThingCompletely.

I may be up all night playing with LINQ. Look what I can do:

   1: Console.WriteLine("Unioning sets");

   2:  

   3: int[] numbers1 = { 1, 3, 5, 7, 9 };

   4: int[] numbers2 = { 2, 4, 6, 8, 10 };

   5:  

   6: IEnumerable<int> allNums = from n in numbers1.Union<int>(numbers2)

   7:                            where n > 3

   8:                            orderby n

   9:                            select n;

  10:  

  11: foreach (int i in allNums)

  12: {

  13:     Console.Write(i + ", ");

  14: }

And it gives me this result.

Unioning sets
4, 5, 6, 7, 8, 9, 10,

This is fun, I have to admit. It’s so new and shiny that the syntax high lighter in Live Writer doesn’t see all the keywords. You want to really go to bed late, work your way through this page of 101 LINQ samples. That’s what I’m doing.