Pilchie's C# and Visual Studio Blog

Slides from my CodeMash Session

Pilchie (Kevin Pilch-Bisson) — Mon, 24 Jan 2011 22:56:02 GMT

Sorry for the delay. I took a disconnected vacation for a week after CodeMash. Now that I’ve completed my own personal Planes, Trains and Automobiles trip, I wanted to make sure that I posted the slides from my CodeMash session. You can get them here. Remember, you can find the async demos that I did inside the Async CTP for Visual Studio 2010.

Seattle CodeCamp 2010.

Pilchie (Kevin Pilch-Bisson) — Sun, 18 Apr 2010 02:56:00 GMT

Well, it's been about a year since the last time I posted. It's a little funny that my previous post was about how I'm going to speak at Seattle CodeCamp in 2008, and this post is about having just spoken at Seattle CodeCamp 2010. Anyway, I've mostly been using Twitter to share what I've been working on. I'm @Pilchie there. Anyway, today I presented again on C# IDE Tips and Tricks for Visual Studio 2010. Some people asked me if I could post the slides, so I've attached them to this post as a way to get them. I also found out that all the sessions at CodeCamp were recorded, and are available online. My talk is here.

I’m speaking at Seattle Code Camp this weekend.

Pilchie (Kevin Pilch-Bisson) — Fri, 14 Nov 2008 05:08:07 GMT

This Saturday from 2:45-4:00 I’ll be giving a talk on “What’s coming up in VS2010 for C# Developers?” at Seattle Code Camp. I’ll mostly be showing off some of the new features we’ve been working on for VS2010, especially those related to the C# editor. I’d love it if you stopped by!

Hotfix for VS2008 SP1 Available

Pilchie (Kevin Pilch-Bisson) — Fri, 31 Oct 2008 03:34:35 GMT

In VS2008 SP1 our team added a significant new feature: live semantic analysis of open files (or “background squiggles” as we called it internally). Unfortunately, soon after release we found a few small issues with the release. They are:

Incorrect errors when you open a solution with breakpoints in .aspx.cs files.
Incorrect errors regarding conversions of constants in rare cases.
An issue importing metadata from some non-C# assemblies.
Some timing issues where errors would appear and then disappear during typing or file/solution opening.

We spent some time analyzing the issues, and we’ve come up with a hotfix to address them. If you’re seeing any issues where you get live semantic errors that you don’t expect, please download this fix and try it out.

Let me know if you find any issues with it!

Thanks!

CodeRush Xpress for C#

Pilchie (Kevin Pilch-Bisson) — Tue, 28 Oct 2008 21:13:07 GMT

Yesterday at the PDC, Dustin announced the availability of CodeRush Xpress for C#. This is a free addin for VS 2008 that provides a whole bunch of fantastic editor productivity features. Download it today and give it a shot!

Removing elements from a Dictionary

Pilchie (Kevin Pilch-Bisson) — Tue, 28 Oct 2008 03:42:23 GMT

The topic of removing elements from a dictionary came up recently on an internal mailing list. Someone was iterating through all the elements of a collection and wanting to remove some of them. The problem with that is that modifying the collection underlying the enumerator throws. He had the following pseudo code:

void RemoveSomeElements(Dictionary<string, int> dict)
{
    foreach (var e in dict)
    {
        if (e.Value < 35)
        {
            // Remove e!
        }
    }
}

Several people replied that he could just create a list of elements to be removed and then iterate that afterwards:

var keysToRemove = new List<string>();
foreach (var e in dict)
{
    if (e.Value < 35)
    {
        keysToRemove.Add(e.Key);
    }
}

foreach (var key in keysToRemove)
{
    dict.Remove(key);
}

That works, but it’s pretty verbose. Someone suggested a more functional way to do it that’s pretty nice:

dict.ToList().Where(pair => pair.Value < 35).ToList().ForEach(pair => dict.Remove(pair.Key));

At this point I decided to show off, and make it more efficient by using an “Apply” extension method instead of the .ForEach method that shipped on List<T> in .Net 2.0. I came up with this:

dict.Where(pair => pair.Value < 35).Apply(pair => dict.Remove(pair.Key)).Apply();

Along with the code to Apply:

public static class ApplyExtensions
{
    public static IEnumerable<T> Apply<T>(this IEnumerable<T> source, Action<T> action)
    {
        Argument.NotNull(source, () => () => source);
        Argument.NotNull(action, () => () => action);
        return ApplyInternal(source, action);
    }

    internal static IEnumerable<T> ApplyInternal<T>(IEnumerable<T> source, Action<T> action)
    {
        foreach (var e in source)
        {
            action(e);
            yield return e;
        }
    }

    public static void Apply<T>(this IEnumerable<T> source)
    {
        foreach (var e in source)
        {
            // do nothing, just make sure the elements are enumerated.
        }
    }

}

Here I thought I was doing right by C# 3.0, and showing people how to use lazily chained iterators. Unfortunately, this code drops us right back to the original problem! Because of lazy iteration, we’re actually still iterating the dictionary when we try to remove the elements, and so we invalidate the first iterator in our chain.

It’s a simple fix, but still a reminder that the semantics of delayed execution can be tricky to reason about sometimes:

dict.Where(pair => pair.Value < 35).ToArray().Apply(pair => dict.Remove(pair.Key)).Apply();

The “ToArray” call finishes the iteration of the dictionary, but uses less space than the original “.ForEach” solution, since we only realize a collection of the elements to be removed, instead of all of the elements in the dictionary.

ArgumentNullException and refactoring

Pilchie (Kevin Pilch-Bisson) — Mon, 27 Oct 2008 17:58:51 GMT

I hate using strings to represent program elements! One of the big problems is that it hinders automated refactoring. Strings don’t have any semantic meaning, so refactoring tools don’t know which references to the string need to be updated.

While playing with expression trees, a while ago I came up with this:

public static class Argument
{
    public static void NotNull(object value, Expression<Func<Func<object>>> arg)
    {
        if (value == null)
        {
            var body1 = (Expression<Func<object>>)arg.Body;
            var body2 = (MemberExpression)body1.Body;
            throw new ArgumentNullException(body2.Member.Name);
        }

    }
}

You can use this for argument validation like this:

static void Main(string[] args)
{
    Argument.NotNull(args, () => () => args);
}

This looks a little strange, but has some interesting properties:

There are no strings, which means that refactoring tools “Just Work” and update all references.
The majority of the reflection code happens only in the exception code, which means that this has significantly better performance than my first attempt (which took just an “Expression<Func<object>>”

On the other hand it has some drawbacks too:

The calling side looks a little strange with “() => () =>'”
Using this approach will lead to a LOT of compiler generated display classes to store the parameter references.

I’m not sure I would use this in production code, but it was an interesting exercise to come up with a way of validating parameters that doesn’t involve strings.

What do you think?

Virtualization Update

Pilchie (Kevin Pilch-Bisson) — Mon, 27 Oct 2008 17:38:08 GMT

Just a quick update. After my previous post, I actually stopped using virtualization for most cases, since I found the performance hit to be too significant. While the automation I mentioned before still doesn’t support HyperV, I hand built a couple of VM’s with it and I have to say that I’m quite impressed.

On my host machine, it takes about 8 minutes to do a clean build of the code I usually work on. With my previous virtual machine, it took about 32 minutes! I think this happened because while my host machine has 4 processors, the VM can only access one of those. I wasn’t willing to pay that price. With HyperV today it takes about 9.5 minutes, and I am willing to pay that price for the added flexibility and the time I can save installing builds.

Getting on the virtualization bandwagon

Pilchie (Kevin Pilch-Bisson) — Fri, 15 Aug 2008 17:55:46 GMT

Lately I've been trying to support work happening in a variety of our development branches, and that's been challenging to the two machine setup I mentioned here. Visual Studio (unfortunately) takes a long time to install and uninstall. Also during our development cycle uninstall is sometimes broken. That means that people often re-image (at least) their test machines whenever they need to install a new build of Visual Studio.

In order to do work in three different branches somewhat simultaneously, I need to have test machines that have those three different branches installed. It wasn't reasonable to re-image and re-install my single test machine every time I needed to switch branches. It's also not very cost effective for me to have 3 test machines where two of them spend the vast majority of their time idle, not to mention that this doesn't scale well if one day I need a 4th branch.

So last week, I jumped on the virtualization bandwagon. I flattened my best machine, installed windows server 2008 64-bit*, and started using virtual machines for my test machines. So far it's been working out very well for me, but I do have to give credit to some other people. A few people in our test group have written some automation around Virtual Server to make life easy for people wanting to use virtual machines. They have some software that manages creating VMs for you. It basically does the following steps:

Pull an image of a selected OS from the network, and cache it locally.
Create a VM
Install the OS
Add it to the corporate network domain
Install the latest set of Windows Updates
Add my domain account to the Administrators group.
Optionally run a custom script to install more software.

For step 7, this group has provided stock scripts for installing various versions of Visual Studio, and one to install the latest build from a selected branch. It's really convenient, since steps 2 to 6 only take about 25 minutes (and step 1 is usually skipped because the image is in the usually in your local cache).

They also have an option to have the VM be destroyed and re-created every night, which means that you can come in to work in the morning and have a fresh test machine with the latest build on it.

So, I started out need to have 3 test machines in 3 different branches, but the system is so easy to use that I've already built up a larger set than that. My current list of virtual machines is:

VS2008 without SP1
VS2008 with SP1.
A debug build of VS from each of the 3 branches I mentioned above.
A release build of VS from the branch I normally work in for performance testing (I don't need absolute numbers, just finding the hotspots).

My only wish is that they update it to take advantage of Hyper-V soon to improve performance of the hosted machines.

* I previously had Vista 32-bit on the machine because at the time I set it up Server 2008 wasn't released yet, and there was a bug in the interim builds of visual studio that made install fail on 64-bit machines.

Where has Kevin been?

Pilchie (Kevin Pilch-Bisson) — Fri, 15 Feb 2008 01:55:25 GMT

I'm still here, I've just been very busy. We're in the thick of planning out what we'd like to do for the next version of Visual Studio. If you have any suggestions, please drop them in the comments section. I'm most interested in the sorts of features that would be Visual Studio features (as opposed to language features), and the ones that apply while you are actually editing C# code.

Also, I've changed roles a bit. I'm now the dev lead for the C# IDE team, instead of an individual contributor on the team, so I'm learning what it's like to be a people manager.

I have a few ideas queued up for future blog posts, but I'm definitely interested in your questions too. What parts of features in the C# editor are you curious about? What about work at MS and our processes, is that a topic of any interest?