C# IDE: New Features for Whidbey

I’m sitting in a large conference room watching my manager, Scott Wiltamuth, do a
presentation about the new features in the C# IDE. The highlights are:

  1. Expansions, which are user-written “code templates” which are triggered through the
    standard CTRL-Space syntax. They are somewhat like a Cut/Paste, except that you can
    define fields in the text that can be replaced, and the IDE will highlight as you
    step through them.
  2. Code formatting. Formatting is always a religous
    , and previous versions of C# didn’t give you very much freedom in following
    your own formatting beliefs. In Whidbey, we’ve developed an approach with much finer-grained
    control on how you code is formatted. There are 80-some different settings that you
    can set to control exactly how your code is formatting
  3. Refactoring. VC# in Whidbey contains support for some commonly-used refactorings.
    One of our goals WRT refactorings is to be able to make the refactorings that we do
    very trustworthy. In other words, to make sure that they work every time. To do that,
    we’ve hooked in to the C# compiler, so that refactoring can use the “gold standard”
    information about the code when doing refactorings.
  4. Debug visualizers. Visualizers are C# forms that the debugger uses to display values.
    If you’ve ever tried to figure out what’s going on in a hashtable or a dataset, you
    know that the current model isn’t great. With visualizers, you can use a custom viewer
    on top of the data.
  5. New build system (ie msbuild). Think of something like Nant.

Comments (7)

  1. Nice. Even with all the momentous other PDC announcements, those are five practical items that are each totally lovable and super-practical in their own right–if the framework was locked at 1.1, these would have me reasonably excited.

  2. Jason Allen says:

    Very nice, can’t wait to try this stuff out. Does the version of Whidbey released at PDC support all these features? Does it include C# 2.0?

  3. Eric Gunnerson says:


    The PDC bits do support these features, with the caveat that they all show up in "work in progress" form. The UI, exact language syntax, minor details about the features will possibly change between now and the final version.

    Or, to put it another way, we’re still working on this puppy.

  4. Sean Malloy says:

    I’m really looking forward to the refactoring capabilities, but my question is, will there be some sort of framework to extend/implement new refactorings?

    I’m relieved to hear the QA going into the refactorings that we will get, but I just want more of them! :)

  5. Ayende says:

    What I really wants to see in C# is something like this:
    … code …
    catch( ExceptionA, ExceptionB, ExceptionC: Exception e)
    .. handle exceptions …

    The idea is that in one catch statement you can handle number of exceptions.
    The condition is that all the exceptions will’ve a common base (either exception or something higher up in the tree).
    For instance, I could do this:
    TextReader s = File.OpenText("ayende.txt",FileMode.Open);
    int i = int.Parse(s.ReadLine());
    catch(FileNotFoundException, AccessDeniedException : IOException e)
    Console.WriteLine("Can’t use file, reason: " + e.Message);
    catch(UnderFlowException, OverFlowException: ArithmaticException e)
    Console.WriteLine("Can’t parse the file, bad data. Reason: " + e.Message);


    It would save having to write a different catch statement for a set of related exceptions.

  6. Timothy D. Chase says:

    Hope you don’t mind, but I’ll post a couple of comments. In this one, for anyone who is really interested in the new features which will be appearing in C# 2.0 (e.g., generics), you may want to check out "The C# Programming Language" by Anders Hejlsberg, Scott Wiltamuth, and Peter Golde. Clearly a great deal of thought has been put into the development of this language.

  7. Timothy D. Chase says:

    I would be interested if anyone has read the article at:


    entitled: Does Microsoft Understand Refactoring?

    The basic idea behind the article is that the essence of refactoring is to improve the performance of code (e.g., speed) and/or its structure without actually affecting the behavior of that code, however, according to the author, the refactoring methods listed for Whidbey will necessarily affect the behavior of code (which would mean that they could break applications which use such code), and therefore isn’t true refactoring.

    My question is this for anyone familiar with Whidbey:

    Are the methods which will be made available under the name of "refactoring" true refactorings?

    Thanx from an otherwise avid fan of C# and DotNet.