Scott Guthrie just posted on his blog that ASP.Net MVC 2 has been released.  Looks like I am going to have to buy a new ASP.Net MVC book, and I didn’t even finish the last one!

I stumbled across this great Visual Studio code snippet editor and thought I should share the link.  I have already created a few snippets with it, and it my development time is benefiting from it.

The editor allows one to highlight existing code and export it into a snippet file.  This is a great launch pad for snippet development.  The editor runs in Visual Studio, and once a snippet is saved with a shortcut it is immediately available in the IDE.  The editor also allows the editing of existing snippet files.

I have been playing around with C# 4.0 Beta 2 and stumbled onto the ExpandoObject (in the System.Dynamic namespace, System.Core assembly).  The object is built to be used in the DRL (Dynamic Language Runtime).  The DLR is a way for strongly-typed code to play nicely with weakly-typed code like IronPython, and vice-versa.  In C# 4.0 the dynamic keyword is used to reference objects that are weakly typed, and the ExandoObject is a .Net class that pretends to be a weakly-typed object.

ExpandoObject allows for addition of member properties and methods are run-time similar to popular scripting languages like Javascript.  Yet ExpandoObject is a real .Net type, and implements a couple of  interesting .Net interfaces: IDictionary<string, object> and INotifyPropertyChanged.  A dictionary of members is provides through the dictionary interface, and property changed events are fired through the property changed interface.  The only way to really leverage the power of ExpandoObject is with the dynamic keyword/type, which skips compile-time checking.  Method and property calls are not shown in intellisense.  You don’t know if your code will execute property until run-time.  So to access the above mentioned interfaces, the ExpandoObject’s dynamic reference must be cast to the interface type.

Here is some very simple, sample code that illustrates the concepts discussed (runs in Visual Studio 2010 / .Net 4.0 Beta 2):

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Dynamic;

namespace DynamcMethodExample
{
    class Program
    {
        static void Main(string[] args)
        {
            dynamic person = new ExpandoObject();
            person.Name = "John";
            person.Gender = 'm';
            person.Age = 10;

            Console.WriteLine(person);
            Console.WriteLine(person.Name);
            Console.WriteLine(person.Gender);
            Console.WriteLine(person.Age);
            Console.ReadKey();

            person.MakeTacos = (Func<string>)(() => "Tacos are ready!");
            Console.WriteLine(person.MakeTacos());
            Console.ReadKey();

            ((INotifyPropertyChanged)person).PropertyChanged += (s, e) =>
                {
                    IDictionary<string, object> personAsDictionary = (IDictionary<string, object>)person;
                    Console.WriteLine("Property {0} changed to {1}.", e.PropertyName, personAsDictionary[e.PropertyName]);
                };

            person.Name = "Jane";
            person.Gender = 'f';
            person.Age = 11;
            Console.ReadKey();

        }
    }
}

A lot of the hype around .Net 4.0 is surrounding new features such as the Dynamic Language Runtime (DLR), and C# 4.0 features such as the dynamic type and co/contra-variance.  Something not getting as much press, but in many ways more helpful is the inclusion of many new, useful types included in 4.0.  The BCL team has a blog article about many of these types.  Here are a couple of my favorites:

• Enum.HasFlag(Enum enum)
  I have written this code a couple of times before.  It detects whether a bit is set in an enum Flag value.
• Enum.TryParse<EnumType>(string value, out EnumType result)
  I have also had to write this.  I think every core value-type should have a TryParse, which leads to:
• Guid.TryParse(string value, out Guid result)
• String.Join and String.Concat now take IEnumerable<T>!  I have written string.Join(“,”, values.Select(v=>v.ToString()).ToArray()) more that a few times.

I am really looking forward to .Net 4.0.  If you want to get your hands on it now .Net 4.0 and Visual Studio 2010 are available for download here.

Scott Guthrie has a very informative series about Visual Studio 2010 over on his web site.  Today’s article is about enhanced multi-monitor support in VS 2010.  I have only had a chance to use VS 2010 in a virtual machine, and have not had a chance to take the multi-monitor stuff mentioned in his article for a test drive.  It does look very cool.

Something I am particularly interested in is support for varying numbers of monitors.  At work I have a dual 19″ monitor display rig.  At home I remote into my desktop from my single-monitor 17″ laptop.  I occasionally have trouble with windows displaying correctly when I remote in. particularly using Visual Studio 2008 with tool boxes that are on the second monitor.  In VS 2010, window settings are kept in the local user file for the project, so if nothing else one should be able to move off-screen windows on-screen with a little text editing.  I am interested to see what kind of built-in support VS 2010 will have to detect that the second monitor is not present in this type of situation.  If it doesn’t auto-detect, it might now be easy to build a tool to edit the user file, or swap out user files.