Visual Studio 2008 has lots of goodies in it, like LINQ syntax, CSS editing, and testing tools. There’s a lesser-known feature which I really appreciate though – the “Remove and Sort Usings” command in the C# editor.

You activate the command by placing your cursor over the using statements and clicking on the right mouse-button.

Using this groovy tool, I’ve been able to go through my old ugly C# files and get rid of all the superfluous using statements, then tidy them up, all at the click of a button. It’s something I always wanted to do, but had no time for, and didn’t want to pay for an extra tool to do it for me.

The only problem with the feature is that you have to go through every file and right-click on the “using” statements to tidy them up. That can get a bit tedious, but it’s worth it.

But now it’s the Visual Studio Extensibility Team to the rescue!

The VSX team at Microsoft have just released PowerCommands for Visual Studio 2008. It’s a free tool for Visual Studio with loads of new tools for making a VS-developer’s life easier. And one of those new tools is a Remove and Sort Usings command at the project level.

You activate it with a right-click on the project itself.

The tool then does the same Remove and Sort command for every file in the project.

Tip: Make sure your project is buildable before using the tool. If there is an error stopping the build from running, you will get dialogs asking you to confirm every change in every file.

PowerCommands for Visual Studio 2008 also contains commands for:

• Collapse Projects
• Copy Class
• Paste Class
• Copy References
• Paste References
• Copy As Project Reference
• Edit Project File
• Open Containing Folder
• Open Command Prompt
• Unload Projects
• Reload Projects
• Remove and Sort Usings
• Extract Constant
• Clear Recent File List
• Clear Recent Project List
• Transform Templates
• Close All

So, where can you get the tool?

The official site for PowerCommands is at the Visual Studio Gallery, but when you get there, you won’t see a download button. You actually have to click the “Learn More” button to go to the download page at the MSDN code gallery.

You can read more about PowerCommands on the Visual Studio Team Extensibility blog.

Until recently I thought this was a well-known feature. After demonstrating it a few times, I found out it wasn’t.

A long time ago, in an cubicle far, far away, someone created the .Net Framework. To cut a long story short, they simultaneously produced guidelines for creating Exception classes, which you should always use or face having your fingernails pulled out with a staple-gun.

The guidelines state:

“Use the common constructors shown in the following code example when creating exception classes. “

[C#]

public class XxxException : ApplicationException
{
public XxxException() {… }
public XxxException(string message) {… }
public XxxException(string message, Exception inner) {… }
public XxxException(SerializationInfo info, StreamingContext context) {…}
}

If you don’t believe me, you can look here:

http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpgenref/html/cpconerrorraisinghandlingguidelines.asp

Now, I don’t know about you, but I can’t remember all that every time I create a custom exception class. Maybe that’s why the guidelines also state:

In most cases, use the predefined exception types. Only define new exception types for programmatic scenarios, where you expect users of your class library to catch exceptions of this new type and perform a programmatic action based on the exception type itself.

But let’s ignore that. It’s not relevant.

So, did you know that there is a Visual Studio code snippet that does the work for you? Here’s how you use it.

1. Create a new class.
2. inside the namespace definition of the new class, type

   Exception

3. Press the tab key twice.

You then get the following code, free of charge:

[global::System.Serializable]
public class MyException : Exception {

  public MyException() { }
  public MyException(string message) : base(message) { }
  public MyException(string message, Exception inner) : base(message, inner) { }
  protected MyException(
  System.Runtime.Serialization.SerializationInfo info,
  System.Runtime.Serialization.StreamingContext context)
    : base(info, context) { }
}

What’s more, you get code snippet functionality which automatically changes the names of all the constructors when you change the name of the class.

I wonder what other code snippets are available. Do you know of any cool ones? What are your favorites?

Scott Guthrie has just announced that the source code for the .Net framework has just been made available for reference use.

It will be particularly useful to see how the controls in ASP.Net and Windows Forms have been done.

Detailed instructions for how to set it up are here.

One caveat: it’s not available for the Express editions of Visual Studio. Shame! I was just starting to have some fun with them too.