I use a VirtualPC environment for all my software development work, usually using a unique environment for every customer. This eats up the drive space in my laptop pretty darn quick. So after reading about running a VirtualPC image from a USB Flash Drive I decided to give it a try. I purchased a 32GB memory stick and plugged it in.

After a little experimenting I can now confirm it runs the VirtualPC nice and fast. But writing data to the disk and reading at the same time is horrendously slow. So you need to do two things:

a) Make sure the .vmc file is NOT located on the flash drive
b) Enable UndoDisks

These two steps will create a temporary file on your harddisk, in the folder where the .vmc is located. This means that while using the drive you only read from the flash drive, but never write.

When you shut down the VPC you can choose to commit the changes to the flash drive, this may take a little while, so only do it when you have time to wait for it to complete.
I usually choose 'Save State' which allows me to restart the VPC where I left off.

If you're using the xsd.exe tool to generate C# code from an XML Schema you'll find that an attribute defined as an integer is generated into a string field.

The reason is listed on MSDN:

The xs:integer type is specified as a number with no upper or lower bound on its size. For this reason, neither XML serialization nor validation map it to the System.Int32 type. Instead, XML serialization maps the xs:integer to a string while validation maps it to the Decimal type that is much larger than any of the integer types in the .NET Framework.

Ted Neward offers a very good description of what a Software Architect is:

"an architect is not like a construction architect, but more like the conductor of a band or symphony. Yes, the band could play without him, but at the end of the day, the band plays better with one guy coordinating the whole thing. The larger the band, the more necessary a conductor becomes. Sometimes the conductor is the same thing as the composer (and perhaps that's the most accurate analogous way to view this), in which case it's his "vision" of how the music in his head should come out in real life, and his job is to lead the performers into contributing towards that vision. Each performer has their own skills, freedom to interpret, and so on, but within the larger vision of the work."

My article on combining AIM Call Out with geocoding a phone number to display the location of the person you're trying to call has gone live on the AOL Developer Network.

I think it turned into a very cool sample application.

Dial a number and see the location of the person you're calling!

It seems there is some controversy (1) (2) around whether Live Mesh is good or bad. Here is my 2 cents: I've installed Live Mesh Tech Preview about a month ago and am pretty impressed by it so far. It seems to me Microsoft may have found the tool that will unify the desktop (where they make their money) with the cloud (revenue?). Currently there are two features that I use and like:

a) Sync files automatically with all machines in my Live Mesh group of devices
b) If my Live Mesh device is on, then I can use Remote Desktop Connection (or a Live Mesh version thereof) to remotely connect to that device. Even if it is behind a firewall and on a dynamic IP DSL connection. This is great because my machines at the office are connected to the Internet via a dynamic IP connection and now I can just connect to them, by clicking them via the Live Mesh icon in my icon tray.

The sync files feature will be further improved in the future when Peer 2 Peer synchronization will be supported. I suggested this feature on MS Connect, but it was already planned :-)
Here is the response I got:

We plan to include selectable direct Peer to Peer (P2P) as a sync scenario in a later milestone, which is in effect what you have asked for here I believe.
Thank you for this report!
Tim

I use a lot of Virtual PC images. I'm hoping I can use this P2P sync service to create continuous backups (don't know if the bandwidth needed will prove to be a killer).

What is interesting is that files on Live Mesh will sync, even if the user is not signed in. This means that on the client Live Mesh is connected to the cloud without a user logging on. This offers potential for an interesting feature like 'Live Mesh Lockdown'. Suppose my machine is stolen. I could use some other device, go to the Live Mesh Desktop on the web and mark the device as stolen. This could lead to the machine being locked for further use. I have no idea what information is stored on the server with regards to the device. Perhaps this feature could even become part of the next version of Windows. That way if the thief re-installs the machine the server can still recognize the device (based on MAC address?) and still lock the machine.

Anyway, can't wait to see what the developer API for Live Mesh looks like.

The Software Developer Network user group will be hosting it's quarterly event on Monday, June 23. The theme of the event will be Collaboration, but plenty of general topic sessions will be held as well (a total of 30 sessions!).

Go to www.sdn.nl/sde to sign up.

Here is an overview of the sessions:

Anyone familiar with building applications using .NET Remoting (in .NET 2.0) knows that the DataSet and DataTable classes have a property called RemotingFormat. This could be set to either XML or Binary where Binary would give you a performance boost since it is more compact.

Windows Communication Foundation does not use this property at all. The service binding dictates the serialization format, no matter what you set the RemotingFormat property to be, even if your using a NetHttpBinding.

The following configuration will setup a service to use .NET Binary formatting over Http:

<system.serviceModel>
  <bindings>
    <customBinding>
      <binding name="NetHttpBinding">
        <reliableSession />
        <compositeDuplex />
        <oneWay  />
        <binaryMessageEncoding  />
        <httpTransport />
      </binding>
    </customBinding>
  </bindings>
  <services>
    <service behaviorConfiguration="ServiceBehavior" name="MyService">
      <endpoint address="" binding="customBinding"
        bindingConfiguration="NetHttpBinding" name="HttpBinding" contract="IService" />
      <endpoint address="mex" binding="mexHttpBinding" contract="IMetadataExchange" />
    </service>
  </services>
  <behaviors>
    <serviceBehaviors>
      <behavior name="ServiceBehavior">
        <!-- To avoid disclosing metadata information, set the value below to false and remove the metadata endpoint above before deployment -->
        <serviceMetadata httpGetEnabled="true"/>
        <!-- To receive exception details in faults for debugging purposes, set the value below to true.  Set to false before deployment to avoid disclosing exception information -->
        <serviceDebug includeExceptionDetailInFaults="false"/>
      </behavior>
    </serviceBehaviors>
  </behaviors>
</system.serviceModel>

So even if your service looks something like this:

public DataSet GetData()
{
    DataSet ds = BuildDataSet();   // retrieve some data here
    ds.RemotingFormat = SerializationFormat.Xml;
    return ds;
}

The DataSet will still get serialized as a .NET binary as defined in the binding ('binaryMessageEncoding').

The article I wrote about building a Voice over IP .NET application using AIM Call Out and the AOL Open Voice API has just gone live on the AOL Developer Network. Read it here.

A lot is being blogged about the availability of VS 2008 SP1 and TFS SP1. It contains fixes and many new features and sound almost too good to be true, but I checked, it's not an April fool's joke :-)

A little lost in the noise about new features is the fact that .NET Framework 3.5 SP1 will include .NET CLR 2.0 SP2. I've been unable to find anything about this other than this one post by Eric Eilebrecht, but any CLR update is significant.

Okay, so you read the title of this post. Perhaps you're expecting huge amounts of code, but guess what. As it turns out, this is so ridiculously easy. This will be a very short post.

Step one is to have a method that loads an RSS feed. WCF offers a new class called SyndicationFeed.

private SyndicationFeed Load( string url )

{

  XmlReader reader = XmlReader.Create( url );

  SyndicationFeed feed = SyndicationFeed.Load( reader );

  return feed;

}

The above method will take a url and use to load a feed. Now suppose I have a list of urls and I want to take all the items in all the feeds, sort them and use them to generate a new, aggregated feed. Sounds like a fair amount of work, right.

Here is the code:

private SyndicationFeed Aggregate( List<string> urls )

{

  var items = from url in urls

              from item in Load( url ).Items

              orderby item.PublishDate descending

              select item;

  SyndicationFeed feed = new SyndicationFeed( items );

  return feed;

}

Cool!

Heroes Happen in Bangor! The BAND is proud to announce we will be putting on a mini-launch event for Microsoft's Heroes Happen Here launch of the 2008 products.  Come to the event at Kominsky Hall at Husson College in Bangor on Tuesday, May 27 at 6:00 pm.

Greg Howe and Jeff Hall, BAND co-leaders, will be talking about Visual Studio 2008 and how it will impact your development efforts.  There will be two 45-minute talks, one focusing on the web world, and one focusing on the IDE.  You will leave this event knowing how you can benefit from the new products, including Windows Sever 2008 and SQL Server 2008.

More info here.

My blog runs on dasBlog version 2.x and when I started blogging I did all my typing online. Then Office 2007 came along and Word offered the feature of creating a blog entry offline and then upload it to dasBlog using the MovableType API.

This wasn't too great though, since Word markup would end up in the HTML and sometimes the publish process just froze or refused to logon to my web site. Also, uploading pictures was kind of a hack.

Last week I installed Windows Live Writer and this runs as a charm. Definitely a recommendation!

A new quiz on www.justsayhi.com says I'm:

I heard about Live Mesh last week and decided to check it out. So I’ve signed up for Live Mesh beta program and it is pretty neat, but still fairly simple. I’ve not (yet) been accepted into the Mesh Developer beta, which is a separate program. As I understand it Live Mesh will allow you to not just share files, but Silverlight applications as well.

Current state of Live Mesh

Live Mesh allows you to turn a folder on your machine into a Mesh Folder. This in turn allows you to automatically share the folder across multiple devices. Every account has one default device: the Mesh Live Desktop, an online desktop which acts like a Windows desktop.

Mesh Folders can be shared with any Live Messenger contact. Each Mesh folder will track all changes and allows collaboration my attaching messages to the folder.

Picture of Live Mesh Desktop, I've shared the Develop-One folder which sits on my laptop. It shows up as a folder on my Live Mesh desktop.

Device support will include Windows Mobile and Mac!

For anyone that knows Office Groove, it'll be interesting to see how the final version of Live Mesh and Groove compare.

An important part of LINQ and C# 3.0 is the concept of deferred execution. What does this mean?

Let's have a look at the following code:

static void Main( string[] args )
{
   List<int> numbers = newList<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
   var evenNumbers = numbers.Select( x => ( x % 2 == 0 ) );  

   foreach ( int i in evenNumbers )
   {
     if ( i == 6 )
         numbers.Add( 12 ); // add a number to the list of numbers
     Console.WriteLine( i );
   }
   Console.ReadLine();
}

public static List<int> Select( thisList<int> numbers, Filter filter )
{
   List<int> result = newList<int>();
   foreach ( int i in numbers )
   {
      // call the filter method/delegate to see if this
      // number needs to be in the result
      if ( filter( i ) == true )
      {
         // if i matches the filter then add it to the result
         result.Add( i );
      }
   }
   return result;
}

In the code above the extension method 'Select' will apply a filter and return a subset of the original collection of numbers. When the numbers are printed we add the number '12' to the original collection. Since the Select method created a new collection with the subset we will not see the number 12 being printed to the console. If we want a more dynamic interaction we can rewrite the Select method to return an enumerator rather than a List.

public static IEnumerable<int> Select( thisList<int> numbers, Filter filter )
{
    for ( int n = 0; n < numbers.Count; n++ )
    {
        if ( filter( numbers[n] ) == true )
        {
            // if numbers[n] matches the filter then yield the value
            yieldreturn numbers[n];
        }
    }
}

The code above shows that instead of returning a List of numbers we now yield the value of each number as it passes through the filter. Now when we run the same Main we will see that the value '12' is included in our output.  If we put a breakpoint inside the application we can inspect the type of 'evenNumbers'.

As you can see it point to the Select methods and the Lambda has been compiled into an anonymous delegate. Rather than having a fixed result the Select method keeps being called until there are no more numbers being 'yielded'. You can preview the results by opening the 'Results View', but that will only provide a view of the iterator at that specific point in time.